python使用transformer实现多元时间序列预测

多元时间序列预测可以使用Transformer模型来实现。下面是一个简单的Python代码示例，用于使用Transformer模型进行多元时间序列预测：

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

class MultiVarTimeSeriesDataset(Dataset):
    def __init__(self, data, seq_len):
        self.data = data
        self.seq_len = seq_len

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

    def __getitem__(self, index):
        return self.data[index:index+self.seq_len], self.data[index+self.seq_len]

class TransformerModel(nn.Module):
    def __init__(self, input_size, output_size, num_layers, hidden_size, num_heads, dropout):
        super().__init__()
        self.input_size = input_size
        self.output_size = output_size
        self.num_layers = num_layers
        self.hidden_size = hidden_size
        self.num_heads = num_heads
        self.dropout = dropout

        self.encoder = nn.ModuleList([
            nn.Linear(input_size, hidden_size),
            nn.TransformerEncoderLayer(hidden_size, num_heads, hidden_size, dropout)
        ])
        self.decoder = nn.ModuleList([
            nn.Linear(input_size, hidden_size),
            nn.TransformerDecoderLayer(hidden_size, num_heads, hidden_size, dropout)
        ])
        self.output_layer = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = x.permute(1, 0, 2)  # (seq_len, batch_size, input_size)
        for i in range(self.num_layers):
            x = self.encoder[i](x)
        for i in range(self.num_layers):
            x = self.decoder[i](x)
        x = x.permute(1, 0, 2)  # (batch_size, seq_len, hidden_size)
        x = self.output_layer(x[:, -1, :])  # (batch_size, output_size)
        return x

if __name__ == '__main__':
    # 生成测试数据
    data = torch.randn(1000, 4)
    train_data = MultiVarTimeSeriesDataset(data[:800], 10)
    test_data = MultiVarTimeSeriesDataset(data[800:], 10)
    train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_data, batch_size=32, shuffle=False)

    # 初始化模型
    model = TransformerModel(input_size=4, output_size=4, num_layers=2, hidden_size=16, num_heads=2, dropout=0.1)
    loss_fn = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

    # 训练模型
    for epoch in range(10):
        for i, (x, y) in enumerate(train_loader):
            optimizer.zero_grad()
            pred = model(x)
            loss = loss_fn(pred, y)
            loss.backward()
            optimizer.step()
            print(f"Epoch {epoch+1}, Batch {i+1}, Loss {loss.item():.4f}")

    # 测试模型
    with torch.no_grad():
        for i, (x, y) in enumerate(test_loader):
            pred = model(x)
            loss = loss_fn(pred, y)
            print(f"Batch {i+1}, Loss {loss.item():.4f}")

此代码中，我们使用`MultiVarTimeSeriesDataset`类将多元时间序列数据转换为训练和测试数据集。我们还定义了`TransformerModel`类来实现Transformer模型。在`forward`方法中，我们首先转置输入张量以便Transformer模型能够处理它。然后我们使用`ModuleList`定义了多个编码器和解码器层，并使用它们来处理输入张量。最后，我们将处理后的张量传递给输出层并返回预测结果。

在训练和测试过程中，我们使用MSE损失函数和Adam优化器对模型进行训练。