Transformer的多变量回归预测pytorch代码

下面是使用PyTorch实现多变量回归预测的Transformer模型的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 构建Transformer模型
class Transformer(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim, num_layers, num_heads):
        super(Transformer, self).__init__()
        self.input_embedding = nn.Linear(input_dim, hidden_dim)
        self.positional_encoding = PositionalEncoding(hidden_dim)
        self.transformer_encoder = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(hidden_dim, num_heads),
            num_layers
        )
        self.output_layer = nn.Linear(hidden_dim, output_dim)
        
    def forward(self, x):
        x = self.input_embedding(x)
        x = self.positional_encoding(x)
        x = self.transformer_encoder(x)
        x = self.output_layer(x)
        return x

# 位置编码
class PositionalEncoding(nn.Module):
    def __init__(self, hidden_dim):
        super(PositionalEncoding, self).__init__()
        self.hidden_dim = hidden_dim

    def forward(self, x):
        seq_len = x.size(1)
        pos_enc = torch.zeros(x.size(0), seq_len, self.hidden_dim)
        position = torch.arange(0, seq_len).unsqueeze(0)
        div_term = torch.exp(torch.arange(0, self.hidden_dim, 2) * -(math.log(10000.0) / self.hidden_dim))
        pos_enc[:, :, 0::2] = torch.sin(position * div_term)
        pos_enc[:, :, 1::2] = torch.cos(position * div_term)
        pos_enc = pos_enc.to(x.device)
        x = x + pos_enc
        return x

# 准备训练数据
input_data = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32)
target_data = torch.tensor([[10, 20], [30, 40], [50, 60]], dtype=torch.float32)
dataset = TensorDataset(input_data, target_data)
dataloader = DataLoader(dataset, batch_size=1)

# 定义模型参数
input_dim = input_data.size(1)
output_dim = target_data.size(1)
hidden_dim = 128
num_layers = 2
num_heads = 4

# 创建模型和优化器
model = Transformer(input_dim, output_dim, hidden_dim, num_layers, num_heads)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 模型训练
num_epochs = 100
for epoch in range(num_epochs):
    for batch_input, batch_target in dataloader:
        optimizer.zero_grad()
        output = model(batch_input)
        loss = criterion(output, batch_target)
        loss.backward()
        optimizer.step()
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")

# 使用模型进行预测
new_input = torch.tensor([[2, 3, 4]], dtype=torch.float32)
predicted_output = model(new_input)
print("Predicted Output:", predicted_output)

请注意，上述代码中的模型和数据是示例用途，你需要根据你的实际问题进行相应的调整。此外，还可以根据需要添加正则化、调整超参数等来改进模型的性能。