时间序列预测transformer代码

当然可以！以下是一个简单的时间序列预测的 Transformer 模型的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

class TimeSeriesTransformer(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim, num_layers):
        super(TimeSeriesTransformer, self).__init__()

        self.encoder = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(hidden_dim, nhead=4),
            num_layers=num_layers
        )

        self.decoder = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

# 生成训练数据
def generate_data(input_dim, output_dim, hidden_dim, num_layers):
    # 随机生成一些时间序列数据
    x = np.random.randn(1000, input_dim)
    y = np.random.randn(1000, output_dim)

    # 将数据划分为训练集和测试集
    train_x, train_y = x[:800], y[:800]
    test_x, test_y = x[800:], y[800:]

    # 转换为张量格式
    train_x = torch.tensor(train_x, dtype=torch.float32)
    train_y = torch.tensor(train_y, dtype=torch.float32)
    test_x = torch.tensor(test_x, dtype=torch.float32)
    test_y = torch.tensor(test_y, dtype=torch.float32)

    model = TimeSeriesTransformer(input_dim, output_dim, hidden_dim, num_layers)
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # 开始训练
    for epoch in range(100):
        optimizer.zero_grad()
        output = model(train_x)
        loss = criterion(output, train_y)
        loss.backward()
        optimizer.step()
        print(f"Epoch: {epoch+1}, Loss: {loss.item()}")

    # 测试模型
    with torch.no_grad():
        test_output = model(test_x)
        test_loss = criterion(test_output, test_y)
        print(f"Test Loss: {test_loss.item()}")

# 设置模型参数
input_dim = 10
output_dim = 5
hidden_dim = 64
num_layers = 2

# 生成数据并训练模型
generate_data(input_dim, output_dim, hidden_dim, num_layers)

注意，这只是一个简单的示例，实际中可能需要根据数据的特点进行调整和优化。希望这个代码对你有所帮助！如果有任何其他问题，请随时问我。