PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测

下面是一个使用PyTorch搭建LSTM进行多变量输入多变量输出时间序列预测的示例代码，其中包含数据预处理、模型搭建、训练和预测部分。

首先，假设我们有一个包含多个变量的时间序列数据集，每个变量都有多个时间步。我们需要将数据集分成训练集和测试集，并对数据进行标准化处理，这里使用scikit-learn库中的MinMaxScaler进行归一化操作。

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# 读取数据
data = pd.read_csv('data.csv', header=None)
data = data.values

# 分割数据集
train_size = int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

# 标准化数据
scaler = MinMaxScaler(feature_range=(0, 1))
train_data = scaler.fit_transform(train_data)
test_data = scaler.transform(test_data)

接下来，我们需要将数据转换为输入输出对的形式，其中每个样本的输入包含多个时间步的多个变量，输出为多个时间步的多个变量。我们可以定义一个函数来实现这个转换过程。

def create_dataset(dataset, lookback=1, lookahead=1):
    X, Y = [], []
    for i in range(len(dataset)-lookback-lookahead+1):
        X.append(dataset[i:(i+lookback), :])
        Y.append(dataset[(i+lookback):(i+lookback+lookahead), :])
    return np.array(X), np.array(Y)

# 转换数据
lookback = 10
lookahead = 5
trainX, trainY = create_dataset(train_data, lookback, lookahead)
testX, testY = create_dataset(test_data, lookback, lookahead)

接下来，我们可以使用PyTorch搭建LSTM模型。这里使用两层LSTM，每层有64个隐藏单元。注意，输入和输出的形状需要与数据集的形状相匹配。

import torch
import torch.nn as nn

class LSTM(nn.Module):
    def __init__(self, input_size, output_size, hidden_size, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])
        return out

# 定义模型
input_size = trainX.shape[-1]
output_size = trainY.shape[-1]
hidden_size = 64
num_layers = 2
model = LSTM(input_size, output_size, hidden_size, num_layers)

然后，我们需要定义损失函数和优化器。这里使用均方误差损失函数和Adam优化器。

criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

现在，我们可以开始训练模型了。训练过程中，我们使用批量梯度下降来更新模型参数。在每个epoch结束时，我们对模型在测试集上的表现进行评估。

# 训练模型
num_epochs = 100
batch_size = 64
train_loss = []
test_loss = []
for epoch in range(num_epochs):
    # 训练模型
    model.train()
    for i in range(0, len(trainX), batch_size):
        optimizer.zero_grad()
        inputs = torch.tensor(trainX[i:i+batch_size]).float()
        targets = torch.tensor(trainY[i:i+batch_size]).float()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        train_loss.append(loss.item())

    # 测试模型
    model.eval()
    with torch.no_grad():
        inputs = torch.tensor(testX).float()
        targets = torch.tensor(testY).float()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        test_loss.append(loss.item())

    # 打印损失
    print('Epoch [{}/{}], Train Loss: {:.4f}, Test Loss: {:.4f}'
          .format(epoch+1, num_epochs, train_loss[-1], test_loss[-1]))

最后，我们可以使用训练好的模型进行预测。注意，预测过程中需要将标准化后的输出重新还原为原始数据。

# 预测模型
model.eval()
with torch.no_grad():
    inputs = torch.tensor(testX).float()
    outputs = model(inputs)
    preds = scaler.inverse_transform(outputs.numpy())

这就是使用PyTorch搭建LSTM进行多变量输入多变量输出时间序列预测的完整过程。