PyTorch D-Linear模型输出形状匹配与单变量预测实践

# 模型输出的形状示例：[4, 3, 5] (Batch, Pred_len, Channels)
# 目标数据的形状示例：[4, 3] (Batch, Pred_len)
# 尝试计算损失时会报错
# loss = criterion(outputs, targets)

# 错误信息示例：
# RuntimeError: The size of tensor a (5) must match the size of tensor b (3) at non-singleton dimension 2
# (这里的3是pred_len，5是enc_in/channels，错误信息中可能混淆了维度索引或具体值，但核心是最后一个维度不匹配)

overall_predictions = torch.sum(model_output, dim=2)

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from torch.utils.data import DataLoader, TensorDataset
import torch.optim as optim

# ==============================================================================
# D-Linear Model Definition (与问题描述中一致，此处省略，假设已定义)
# class moving_avg(nn.Module): ...
# class series_decomp(nn.Module): ...
# class Model(nn.Module): ...
# ==============================================================================

# 创建随机数据框 (与问题描述中一致)
df = pd.DataFrame(np.random.randint(0,100,size=(1000, 5)), columns=list('ABCDE'))
np.random.seed(42)

# 参数设置 (与问题描述中一致)
seq_len = 12
pred_len = 3
kernel_size = 5
batch_size = 4
individual = True
target_column = 'A'

# 函数：创建序列 (与问题描述中一致)
def create_sequence(data, seq_len, pred_len):
    sequences = []
    targets = []
    for i in range(len(data) - seq_len - pred_len + 1):
        sequence = data.iloc[i:i + seq_len].values
        target = data.iloc[i + seq_len:i + seq_len + pred_len][target_column].values
        sequences.append(sequence)
        targets.append(target)
    return np.array(sequences), np.array(targets)

sequences, targets = create_sequence(df, seq_len, pred_len)

# 划分、标准化数据 (与问题描述中一致)
train_data, test_data, train_target, test_target = train_test_split(sequences, targets, test_size = 0.25, random_state = 42)
train_data, val_data, train_target, val_target = train_test_split(train_data, train_target, test_size = 0.33, random_state = 42)

scaler = StandardScaler()
train_data = scaler.fit_transform(train_data.reshape(-1, train_data.shape[-1])).reshape(train_data.shape)
val_data = scaler.transform(val_data.reshape(-1, val_data.shape[-1])).reshape(val_data.shape)
test_data = scaler.transform(test_data.reshape(-1, test_data.shape[-1])).reshape(test_data.shape)

train_data_tensor = torch.Tensor(train_data)
train_target_tensor = torch.Tensor(train_target)
val_data_tensor = torch.Tensor(val_data)
val_target_tensor = torch.Tensor(val_target)
test_data_tensor = torch.Tensor(test_data)
test_target_tensor = torch.Tensor(test_target)

# 创建DataLoader (与问题描述中一致)
train_dataset = TensorDataset(train_data_tensor, train_target_tensor)
train_loader = DataLoader(train_dataset, batch_size = batch_size, shuffle = True)

# 实例化模型、优化器、损失函数 (与问题描述中一致)
# enc_in 应该等于输入数据的特征数量，即df.shape[1]
model = Model(seq_len = seq_len, pred_len = pred_len, individual = individual, enc_in = df.shape[1], kernel_size = kernel_size)
optimizer = optim.Adam(model.parameters(), lr = 0.001)
criterion = nn.MSELoss()

num_epoch = 30

# 修正后的训练循环
for epoch in range(num_epoch):
    model.train()
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)

        # 关键修正：聚合模型输出的通道维度
        outputs = torch.sum(outputs, dim=2) # 将 [Batch, Pred_len, Channels] 变为 [Batch, Pred_len]

        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

    model.eval()
    with torch.no_grad():
        val_inputs = val_data_tensor
        val_targets = val_target_tensor
        val_outputs = model(val_inputs)
        # 关键修正：聚合模型输出的通道维度
        val_outputs = torch.sum(val_outputs, dim=2)
        val_loss = criterion(val_outputs, val_targets)

    with torch.no_grad():
        test_inputs = test_data_tensor
        test_targets = test_target_tensor
        test_outputs = model(test_inputs)
        # 关键修正：聚合模型输出的通道维度
        test_outputs = torch.sum(test_outputs, dim=2)
        test_loss = criterion(test_outputs, test_targets)

    print(f'EPOCH: {epoch + 1}')
    print(f'TRAINING LOSS {loss.item()}')
    print(f'VALIDATION LOSS {val_loss.item()}')
    print(f'TEST LOSS {test_loss.item()}')