博客

Pytorch实现LSTM案例总结学习

  • Post category:Python

当使用PyTorch实现LSTM模型的时候，可以遵循以下步骤：

第一步：准备数据

首先需要准备好LSTM模型的训练数据，这些数据应该是经过预处理和标准化的。通常，需要将数据划分为训练集和测试集。在训练集上训练模型，然后使用测试集来评估模型的性能。

第二步：创建模型

在PyTorch中，可以使用torch.nn.LSTM类来创建LSTM模型，这个类封装了所有LSTM层的逻辑。创建LSTM模型的基本步骤如下：

1. 导入必要的模块

import torch
import torch.nn as nn

2. 定义LSTM模型类

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

    def forward(self, input):
        h0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size).to(input.device)
        c0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size).to(input.device)
        out, _ = self.lstm(input, (h0, c0))
        out = self.fc(out[-1, :, :])
        return out

3. 实例化模型

# 输入维度为1，输出维度为1，隐藏层维度为32，LSTM层数为2
lstm = LSTM(1, 32, 2, 1)

第三步：定义损失函数和优化器

定义LSTM模型后，需要定义损失函数和优化器。在回归问题中，通常使用均方误差（MSE）作为损失函数。优化器可以选择Adam或者SGD。

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

第四步：训练模型

在训练模型之前，需要将训练数据转换为PyTorch的Tensor格式。同时，需要将输入数据和标签数据都变为PyTorch可接受的形式。

train_x = torch.from_numpy(train_x).float()
train_y = torch.from_numpy(train_y).float()

接下来，我们将模型迭代训练指定的轮数，每轮训练过程包含以下步骤：

1. 将输入传入LSTM模型

outputs = lstm(train_x)

2. 计算损失

loss = criterion(outputs, train_y)

3. 梯度反向传播和参数更新

optimizer.zero_grad()
loss.backward()
optimizer.step()

第五步：模型评估

完成训练后，我们使用测试集来评估模型性能。在评估模型时，需要将测试集转换为Tensor格式，并使用训练好的模型来预测测试数据的结果。

test_x = torch.from_numpy(test_x).float()
test_y = torch.from_numpy(test_y).float()
with torch.no_grad():
    test_outputs = lstm(test_x)

在预测结果后，我们可以使用参数mse_loss()来计算预测的误差。

test_loss = criterion(test_outputs, test_y)

示例一：LSTM实现多元时间序列预测

在这个示例中，我们将使用LSTM模型来预测气温、相对湿度和气压的多元时间序列。

准备数据

我们使用一个包含365天气象数据的数据集。将数据集的前300天作为训练数据，后65天作为测试数据。我们需要将气象数据中的每个变量归一化到[0,1]范围内。

scaler = MinMaxScaler(feature_range=(0, 1))
data = pd.read_csv('weather.csv')
data['Date'] = pd.to_datetime(data['Date'], format='%Y/%m/%d')
data.set_index('Date', inplace=True)
data = scaler.fit_transform(data.values)

然后，我们将训练数据和测试数据转换为LSTM的输入形式。

train_x, train_y = create_dataset(data[:300], window_size)
test_x, test_y = create_dataset(data[300:], window_size)

LSTM模型

我们构建一个基于PyTorch的LSTM模型，包含一个带有激活函数的全连接层。

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        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):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

训练模型

在训练模型之前，我们需要定义损失函数和优化器。

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

然后，我们迭代训练模型，每轮训练输出训练损失和测试损失。

for epoch in range(num_epochs):
    lstm.train()
    outputs = lstm(train_x)
    optimizer.zero_grad()
    loss = criterion(outputs, train_y)
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print("Epoch:{}, MSE Loss:{:.8f}".format(epoch, loss.item()))

lstm.eval()
train_predict = lstm(train_x).detach().numpy()
test_predict = lstm(test_x).detach().numpy()

模型评估

训练完成后，我们使用测试集来评估模型的预测性能。

train_loss = mean_squared_error(train_y, train_predict)
test_loss = mean_squared_error(test_y, test_predict)
print("Train Loss:{:.8f}, Test Loss:{:.8f}".format(train_loss, test_loss))

示例二：LSTM实现多分类问题

在这个示例中，我们将使用LSTM模型来完成鸢尾花数据集的分类任务。

准备数据

我们使用鸢尾花数据集，使用前120个样本作为训练集，后30个样本作为测试集。为了便于处理，我们将类别标签转换为One-Hot编码。

data = pd.read_csv('iris.csv')
data.drop(['Unnamed: 0'], axis=1, inplace=True)
data = pd.get_dummies(data, columns=['Species'])
train_data = data.iloc[:120, :]
test_data = data.iloc[120:, :]
train_x = train_data.drop(['Species_Iris-setosa', 'Species_Iris-versicolor', 'Species_Iris-virginica'], axis=1)
train_y = train_data[['Species_Iris-setosa', 'Species_Iris-versicolor', 'Species_Iris-virginica']]
test_x = test_data.drop(['Species_Iris-setosa', 'Species_Iris-versicolor', 'Species_Iris-virginica'], axis=1)
test_y = test_data[['Species_Iris-setosa', 'Species_Iris-versicolor', 'Species_Iris-virginica']]

LSTM模型

我们构建一个具有两个LSTM层和一个全连接层的PyTorch模型。

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

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

训练模型

在训练模型之前，我们需要定义损失函数和优化器。

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

然后，我们迭代训练模型，每轮训练输出训练损失和测试损失。

for epoch in range(num_epochs):
    model.train()
    optimizer.zero_grad()
    outputs = model(train_x)
    loss = criterion(outputs, train_y)
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print("Epoch:{}, BCE Loss:{:.8f}".format(epoch, loss.item()))

model.eval()
train_predict = torch.sigmoid(model(train_x)).detach().numpy()
test_predict = torch.sigmoid(model(test_x)).detach().numpy()

模型评估

训练完成后，我们使用测试集来评估模型的预测性能。

train_loss = log_loss(train_y.values, train_predict)
test_loss = log_loss(test_y.values, test_predict)
print("Train Loss:{:.5f}, Test Loss:{:.5f}".format(train_loss, test_loss))

这样我们就完成了LSTM模型的实现，同时也可以结合具体的数据集灵活运用LSTM模型解决不同的问题。

Tags: