MAE/MSE/MAPE

MAE、MSE和MAPE是常用的评估指标，用于衡量预测模型的性能和准确度。

MAE（Mean Absolute Error，平均绝对误差）是预测值与真实值之间差值的绝对值的平均值。它衡量了预测值与真实值之间的平均误差大小，其计算公式为：MAE = (|预测值-真实值|)的平均值。MAE的值越小，表示模型的预测误差越小。

MSE（Mean Squared Error，均方误差）是预测值与真实值之间差值的平方的平均值。它衡量了预测值与真实值之间的平均误差的平方大小，其计算公式为：MSE = ((预测值-真实值)^2)的平均值。MSE的值越小，表示模型的预测误差越小。

MAPE（Mean Absolute Percentage Error，平均绝对百分比误差）是预测值与真实值之间差值的绝对值占真实值的百分比的平均值。它衡量了预测值与真实值之间的平均百分比误差大小，其计算公式为：MAPE = (|预测值-真实值|/真实值)的平均值 * 100%。MAPE的值越小，表示模型的预测误差越小。

相关问题

写出mae/mse/mape的定义，并给出计算公式和公式量说明

MAE、MSE和MAPE是常用的回归模型评价指标，它们分别表示平均绝对误差、均方误差和平均绝对百分比误差。

平均绝对误差（MAE）

平均绝对误差是指预测值与真实值之间差的绝对值的平均值。它的计算公式如下：
$$ MAE = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y_i}| $$
其中，$y_i$表示真实值，$\hat{y_i}$表示预测值，$n$表示样本数量。
MAE的量纲跟原始数据相同，因此可以直观地反映出预测误差的大小。

均方误差（MSE）

均方误差是指预测值与真实值之间差的平方的平均值。它的计算公式如下：
$$ MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y_i})^2 $$
MSE的量纲是原始数据的平方，因此它的值通常比MAE更大。同时，MSE对大误差的惩罚比MAE更重。

平均绝对百分比误差（MAPE）

平均绝对百分比误差是指预测值与真实值之间差的绝对值除以真实值的平均值，再乘以100%。它的计算公式如下：
$$ MAPE = \frac{1}{n} \sum_{i=1}^{n} \frac{|y_i - \hat{y_i}|}{y_i} \times 100% $$
MAPE的值为百分数，可以直观地反映出预测误差相对于真实值的大小。但是，如果存在真实值为0的情况，MAPE将无法计算，因此需要进行特殊处理。
总体而言，MAE、MSE和MAPE都是常用的回归模型评价指标，它们各有优缺点，需要根据具体问题选择合适的指标进行评价。

写一个使用Jupyter实现FEDformer预测的代码，用于对一个包含5维特征的1400x5的数据集进行预测。代码中包括了数据标准化、绘制数据趋势图、早停、正则化、计算训练损失和验证损失并绘图，以及绘制各列数据的预测图和总体数据的预测图，并计算MAE/MAPE/MSE/RMSE/SMAPE指标。

以下是一个使用Jupyter实现FEDformer预测的代码示例：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 数据预处理
data = pd.read_csv('dataset.csv') # 读取数据集
scaler = MinMaxScaler() # 数据标准化
data_scaled = scaler.fit_transform(data)

# 数据集划分为训练集和验证集
train_data, val_data = train_test_split(data_scaled, test_size=0.2, shuffle=False)

# 数据集类定义
class CustomDataset(Dataset):
def __init__(self, data):
self.data = data

def __len__(self):
return len(self.data)

def __getitem__(self, idx):
return self.data[idx]

# FEDformer模型定义
class FEDformer(nn.Module):
def __init__(self, input_dim):
super(FEDformer, self).__init__()
self.fc = nn.Linear(input_dim, 1)

def forward(self, x):
return self.fc(x)

# 训练函数
def train(model, dataloader, criterion, optimizer, device):
model.train()
train_loss = 0

for i, data in enumerate(dataloader):
inputs = data.to(device)
optimizer.zero_grad()

outputs = model(inputs)
loss = criterion(outputs, inputs)
loss.backward()
optimizer.step()

train_loss += loss.item()

return train_loss / len(dataloader)

# 验证函数
def validate(model, dataloader, criterion, device):
model.eval()
val_loss = 0

with torch.no_grad():
for i, data in enumerate(dataloader):
inputs = data.to(device)

outputs = model(inputs)
loss = criterion(outputs, inputs)

val_loss += loss.item()

return val_loss / len(dataloader)

# 训练过程
def train_model(model, train_dataloader, val_dataloader, criterion, optimizer, device, num_epochs=100, patience=5):
train_losses = []
val_losses = []
best_val_loss = float('inf')
best_model = None
early_stop_counter = 0

for epoch in range(num_epochs):
train_loss = train(model, train_dataloader, criterion, optimizer, device)
val_loss = validate(model, val_dataloader, criterion, device)

train_losses.append(train_loss)
val_losses.append(val_loss)

print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')

if val_loss < best_val_loss:
best_val_loss = val_loss
best_model = model.state_dict()
early_stop_counter = 0
else:
early_stop_counter += 1
if early_stop_counter >= patience:
print('Early stopping.')
break

model.load_state_dict(best_model)
return model, train_losses, val_losses

# 设置超参数和设备
input_dim = 5
batch_size = 32
lr = 0.001
num_epochs = 100
patience = 5
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 创建数据集和数据加载器
train_dataset = CustomDataset(train_data)
val_dataset = CustomDataset(val_data)
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)

# 初始化模型
model = FEDformer(input_dim).to(device)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=lr)

# 训练模型
trained_model, train_losses, val_losses = train_model(model, train_dataloader, val_dataloader,
criterion, optimizer, device, num_epochs, patience)

# 绘制训练损失和验证损失曲线
plt.plot(train_losses, label='Train Loss')
plt.plot(val_losses, label='Val Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

# 预测函数
def predict(model, dataloader, scaler, device):
model.eval()
predictions = []

with torch.no_grad():
for data in dataloader:
inputs = data.to(device)
outputs = model(inputs)
predictions.extend(outputs.cpu().numpy())

predictions = np.array(predictions)
predictions = scaler.inverse_transform(predictions) # 反标准化

return predictions

# 预测训练集和验证集
train_predictions = predict(trained_model, train_dataloader, scaler, device)
val_predictions = predict(trained_model, val_dataloader, scaler, device)

# 计算指标
def calculate_metrics(actual, predicted):
mae = mean_absolute_error(actual, predicted)
mape = np.mean(np.abs((actual - predicted) / actual)) * 100
mse = mean_squared_error(actual, predicted)
rmse = np.sqrt(mse)
smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100

return mae, mape, mse, rmse, smape

# 计算训练集和验证集的指标
train_mae, train_mape, train_mse, train_rmse, train_smape = calculate_metrics(train_data, train_predictions)
val_mae, val_mape, val_mse, val_rmse, val_smape = calculate_metrics(val_data, val_predictions)

# 绘制各列数据的预测图
plt.figure(figsize=(12, 6))
for i in range(input_dim):
plt.subplot(2, 3, i+1)
plt.plot(train_data[:, i], label='Actual')
plt.plot(train_predictions[:, i], label='Predicted')
plt.xlabel('Time')
plt.ylabel(f'Feature {i+1}')
plt.title(f'Feature {i+1} - Train')
plt.legend()

plt.tight_layout()
plt.show()

# 绘制总体数据的预测图
plt.plot(train_data.flatten(), label='Actual')
plt.plot(train_predictions.flatten(), label='Predicted')
plt.xlabel('Time')
plt.ylabel('Value')
plt.title('Overall Prediction - Train')
plt.legend()
plt.show()

# 打印指标结果
print('Train Metrics:')
print(f'MAE: {train_mae:.4f}')
print(f'MAPE: {train_mape:.4f}%')
print(f'MSE: {train_mse:.4f}')
print(f'RMSE: {train_rmse:.4f}')
print(f'SMAPE: {train_smape:.4f}%')

print('\nVal Metrics:')
print(f'MAE: {val_mae:.4f}')
print(f'MAPE: {val_mape:.4f}%')
print(f'MSE: {val_mse:.4f}')
print(f'RMSE: {val_rmse:.4f}')
print(f'SMAPE: {val_smape:.4f}%')

请确保将数据集文件命名为dataset.csv并与代码文件放在同一目录下。替换代码中的输入数据集、超参数等部分以适应你的实际需求。在Jupyter中运行此代码将输出训练损失和验证损失的曲线图，以及各列数据的预测图和总体数据的预测图，并打印出训练集和验证集的指标结果。