Pytorch入门-day15:循环神经网络(RNN)与LSTM

学习目标

1. 理解RNN基础：掌握RNN的架构及其在序列数据处理中的用途。
2. 学习LSTM机制：理解LSTM如何通过门控机制解决标准RNN的梯度消失问题。
3. 实现序列预测：使用PyTorch构建并训练LSTM模型，预测合成序列的下一个值。
4. 应用PyTorch的RNN模块：通过实践熟悉nn.RNN和nn.LSTM的使用。

关键术语

• 循环神经网络（RNN）：专为序列数据设计的神经网络，通过隐藏状态捕获前序时间步的信息。
• 隐藏状态（Hidden State）：RNN的“记忆”，在时间步之间传递，编码序列信息。
• 梯度消失问题（Vanishing Gradient Problem）：标准RNN在反向传播中梯度过小，导致难以学习长期依赖。
• 长短期记忆网络（LSTM）：RNN的改进版本，使用输入门、遗忘门和输出门管理长期和短期记忆，缓解梯度消失问题。
• 序列预测（Sequence Prediction）：根据序列历史值预测下一个或多个值的任务。
• 时间步（Time Step）：序列中RNN/LSTM处理的单个时间点。
• 单元状态（Cell State）：LSTM中用于携带长期信息的独立记忆向量。
• 门控机制（Gates）：LSTM中控制信息流动和保留的机制，如遗忘门、输入门和输出门。

任务：使用LSTM进行简单序列预测

我们将生成一个合成数据集（例如正弦波），并使用LSTM预测序列中的下一个值，以展示LSTM处理序列依赖的能力。

带详细注释的代码

python

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子以确保结果可重现
torch.manual_seed(42)

# 1. 生成合成数据（正弦波）
def generate_sine_wave(seq_length, num_samples):
    x = np.linspace(0, 50, num_samples)  # 创建时间点
    data = np.sin(x)  # 生成正弦波值
    sequences = []
    targets = []
    for i in range(len(data) - seq_length):
        sequences.append(data[i:i + seq_length])  # 输入序列
        targets.append(data[i + seq_length])     # 预测的下一个值
    return np.array(sequences), np.array(targets)

# 参数设置
seq_length = 10  # 输入序列长度
num_samples = 1000  # 数据点总数
sequences, targets = generate_sine_wave(seq_length, num_samples)

# 转换为PyTorch张量
sequences = torch.FloatTensor(sequences).unsqueeze(-1)  # 形状：[样本数, 序列长度, 1]
targets = torch.FloatTensor(targets).unsqueeze(-1)      # 形状：[样本数, 1]

# 划分训练集和测试集
train_size = int(0.8 * len(sequences))
train_seq, test_seq = sequences[:train_size], sequences[train_size:]
train_targets, test_targets = targets[:train_size], targets[train_size:]

# 2. 定义LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        # LSTM层：处理输入序列并维护隐藏状态和单元状态
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        # 全连接层：将LSTM输出映射到预测值
        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)

        # 通过LSTM进行前向传播
        # 输出out：[批次大小, 序列长度, 隐藏单元数], (hn, cn)：最终隐藏和单元状态
        out, _ = self.lstm(x, (h0, c0))
        # 取最后一个时间步的输出并通过全连接层
        out = self.fc(out[:, -1, :])
        return out

# 模型超参数
input_size = 1    # 每个时间步输入大小（单变量序列为1）
hidden_size = 32  # LSTM隐藏单元数
num_layers = 1    # LSTM层数
output_size = 1   # 输出大小（预测一个值）

# 实例化模型
model = LSTMModel(input_size, hidden_size, num_layers, output_size)

# 3. 训练设置
criterion = nn.MSELoss()  # 均方误差损失函数，用于回归任务
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)  # Adam优化器
num_epochs = 50  # 训练轮数

# 将数据移到GPU（如果可用）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
train_seq, train_targets = train_seq.to(device), train_targets.to(device)
test_seq, test_targets = test_seq.to(device), test_targets.to(device)

# 4. 训练循环
for epoch in range(num_epochs):
    model.train()
    # 前向传播
    outputs = model(train_seq)
    loss = criterion(outputs, train_targets)

    # 反向传播和优化
    optimizer.zero_grad()  # 清空之前的梯度
    loss.backward()        # 计算梯度
    optimizer.step()       # 更新模型参数

    # 每10轮打印损失
    if (epoch + 1) % 10 == 0:
        print(f'轮次 [{epoch+1}/{num_epochs}]，损失: {loss.item():.6f}')

# 5. 评估模型
model.eval()
with torch.no_grad():
    test_predictions = model(test_seq)
    test_loss = criterion(test_predictions, test_targets)
    print(f'测试损失: {test_loss.item():.6f}')

# 6. 可视化结果
plt.figure(figsize=(10, 5))
plt.plot(test_targets.cpu().numpy(), label='真实值', color='blue')
plt.plot(test_predictions.cpu().numpy(), label='预测值', color='orange')
plt.title('LSTM序列预测')
plt.xlabel('样本')
plt.ylabel('值')
plt.legend()
plt.show()

代码说明

1. 数据生成： 使用正弦波生成合成数据集。 每个输入序列包含seq_length个点，目标是预测序列的下一个点。 数据被重塑为PyTorch要求的输入格式：[批次大小, 序列长度, 输入大小]。
2. LSTM模型： LSTMModel类定义了一个LSTM层和一个全连接层。 nn.LSTM处理输入序列，输出每个时间步的结果以及最终的隐藏状态和单元状态。 仅使用最后一个时间步的输出，通过全连接层生成预测值。
3. 训练： 使用均方误差（MSE）作为损失函数，Adam优化器进行优化。 每次前向传播初始化隐藏状态和单元状态为零。 训练50轮，每10轮打印损失。
4. 评估与可视化： 在测试集上进行预测并计算测试损失。 绘制预测值与真实值的对比图，检查模型性能。

预期输出

• 训练损失随轮次减少（例如，从0.1降到0.001，具体取决于数据）。
• 测试损失较低（例如，~0.001），表明预测准确性较高。
• 可视化图显示预测值与真实正弦波值高度吻合。

资源建议

• PyTorch RNN文档：torch.nn.RNN
• PyTorch LSTM文档：torch.nn.LSTM
• 补充阅读：Chris Olah的“理解LSTM网络”（colah.github.io/posts/2015-08-Understanding-LSTMs/，需翻译）

注意事项

• RNN与LSTM的区别：标准RNN（nn.RNN）结构简单，但因梯度消失问题难以处理长期依赖。LSTM（nn.LSTM）通过门控机制选择性记忆或遗忘信息，适合较长序列。
• 任务扩展：尝试增加seq_length，在正弦波中加入噪声，或堆叠多层LSTM（num_layers > 1）以实验模型能力。
• 调试提示：如果损失不下降，检查学习率、序列长度或隐藏单元数是否合适。