PyTorch D-Linear模型输出形状不匹配问题的解决方案

target = data.iloc[i + seq_len:i + seq_len + pred_len][target_column].values

loss = criterion(outputs, targets)

RuntimeError: The size of tensor a (5) must match the size of tensor b (3) at non-singleton dimension 2

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

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

# ... (D-Linear Model definition as provided in the problem statement) ...

# creating random dataframe (as in the problem statement)
df = pd.DataFrame(np.random.randint(0,100,size=(1000, 5)), columns=list('ABCDE'))

np.random.seed(42)

# Parameters
seq_len = 12
pred_len = 3
kernel_size = 5
batch_size = 4
individual = True
target_column = 'A'

# Function to create sequences for training (as in the problem statement)
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)

# split and standardize data (as in the problem statement)
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)

# Create DataLoader
train_dataset = TensorDataset(train_data_tensor, train_target_tensor)
train_loader = DataLoader(train_dataset, batch_size = batch_size, shuffle = True)

# Model initialization (as in the problem statement)
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

# Corrected Training Loop
for epoch in range(num_epoch):
    model.train()
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)

        # 核心修正：在通道维度上求和，使outputs形状与targets匹配
        outputs_aggregated = torch.sum(outputs, dim=2) 

        loss = criterion(outputs_aggregated, 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_aggregated = torch.sum(val_outputs, dim=2)
        val_loss = criterion(val_outputs_aggregated, val_targets)

    with torch.no_grad():
        test_inputs = test_data_tensor
        test_targets = test_target_tensor
        test_outputs = model(test_inputs)
        # 同样对测试集输出进行聚合
        test_outputs_aggregated = torch.sum(test_outputs, dim=2)
        test_loss = criterion(test_outputs_aggregated, 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()}')