基于pytroch简单的LSTM回归预测代码

以下是使用 PyTorch 实现简单的 LSTM 进行回归预测的 Python 代码示例：

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

# 创建一些随机的数据用于回归预测
X = np.sort(5 * np.random.rand(80, 1), axis=0)
y = np.sin(X).ravel()

# 定义序列长度和输入特征维度
seq_len = 5
input_dim = 1

# 将数据转换为 LSTM 输入格式
data = []
for i in range(len(X)-seq_len):
    data.append((X[i:i+seq_len], y[i+seq_len]))

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

# 定义 LSTM 模型
class LSTM(nn.Module):
    def __init__(self, input_dim, hidden_dim, batch_size, output_dim):
        super(LSTM, self).__init__()
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.batch_size = batch_size
        self.output_dim = output_dim
        self.lstm = nn.LSTM(self.input_dim, self.hidden_dim)
        self.linear = nn.Linear(self.hidden_dim, self.output_dim)
    
    def init_hidden(self):
        return (torch.zeros(1, self.batch_size, self.hidden_dim),
                torch.zeros(1, self.batch_size, self.hidden_dim))
    
    def forward(self, x):
        lstm_out, self.hidden = self.lstm(x.view(len(x), self.batch_size, -1), self.hidden)
        y_pred = self.linear(lstm_out[-1])
        return y_pred.view(-1)

# 定义模型参数
hidden_dim = 32
batch_size = 1
output_dim = 1
epochs = 100
lr = 0.01

# 创建模型
model = LSTM(input_dim=input_dim, hidden_dim=hidden_dim, batch_size=batch_size, output_dim=output_dim)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=lr)

# 训练模型
for epoch in range(epochs):
    for seq, label in train_data:
        optimizer.zero_grad()
        model.hidden = model.init_hidden()
        y_pred = model(torch.from_numpy(seq).float())
        loss = criterion(y_pred, torch.from_numpy(np.array([label])).float())
        loss.backward()
        optimizer.step()
    if epoch % 10 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, epochs, loss.item()))

# 测试模型
model.eval()
with torch.no_grad():
    y_pred = []
    for seq, label in test_data:
        model.hidden = model.init_hidden()
        y_pred.append(model(torch.from_numpy(seq).float()).item())

# 可视化结果
import matplotlib.pyplot as plt
plt.scatter(X, y, color='darkorange', label='data')
plt.plot(X[seq_len+train_size:], y_pred, color='navy', label='LSTM Regression')
plt.legend()
plt.show()

这段代码首先使用 Numpy 创建一些随机的数据用于回归预测，并将数据转换为 LSTM 输入格式。然后，将数据集分为训练集和测试集。接下来，定义了一个包含一个 LSTM 层和一个全连接层的 LSTM 模型，并定义了模型参数、损失函数和优化器。然后，使用训练数据对模型进行训练，并在训练过程中输出损失函数的值。最后，使用训练好的模型对测试数据进行预测，并使用 Matplotlib 将预测结果可视化出来。