PyTorch2 Python深度学习 - 循环神经网络（RNN）实例

锋哥原创的PyTorch2 Python深度学习视频教程：

https://www.bilibili.com/video/BV1eqxNzXEYc

课程介绍

​基于前面的机器学习Scikit-learn，深度学习Tensorflow2课程，我们继续讲解深度学习PyTorch2，所以有些机器学习，深度学习基本概念就不再重复讲解，大家务必学习好前面两个课程。本课程主要讲解基于PyTorch2的深度学习核心知识，主要讲解包括PyTorch2框架入门知识，环境搭建，张量，自动微分，数据加载与预处理，模型训练与优化，以及卷积神经网络（CNN），循环神经网络（RNN），生成对抗网络（GAN），模型保存与加载等。

PyTorch2 Python深度学习 - 循环神经网络（RNN）实例

在PyTorch2中，nn.RNN是一个实现了基本循环神经网络（RNN）的类。它用于处理序列数据并进行时序预测任务。以下是nn.RNN的构造方法以及核心参数简介：

class torch.nn.RNN(
    input_size: int,         # 输入特征的维度
    hidden_size: int,        # 隐藏状态的维度
    num_layers: int = 1,     # RNN层数
    bias: bool = True,       # 是否使用偏置项
    batch_first: bool = False,  # 如果True，输入和输出的维度将是(batch, seq, feature)
    dropout: float = 0,      # 如果num_layers > 1，添加dropout
    bidirectional: bool = False, # 是否使用双向RNN
    nonlinearity: str = 'tanh' # 激活函数，'tanh' 或 'relu'
)

核心参数解析

1. input_size:

   • 输入特征的维度。对于每个时间步，RNN接收的输入向量的大小。比如，在文本处理中，它可能是词向量的维度。

2. hidden_size:

   • 隐藏层的大小，即隐藏状态向量的维度。每个时间步的RNN都会生成一个隐藏状态，表示该时间步的记忆。这个值决定了隐藏状态的大小。

3. num_layers:

   • RNN的层数，默认为1。多层RNN通过将多个RNN层堆叠在一起实现。这个参数对模型的学习能力有影响，但也增加了计算的复杂度。

4. bias:

   • 是否使用偏置项。默认值为True，表示每个RNN层都会有一个偏置项。

5. batch_first:

   • 如果设置为True，输入和输出的维度顺序会变为(batch, seq, feature)，否则是(seq, batch, feature)。如果处理的数据集按批次组织，通常选择batch_first=True，使得数据处理更加直观。

6. dropout:

   • 如果num_layers > 1，这个参数会启用dropout，防止过拟合。它定义了每层之间的丢弃概率（dropout的比例）。默认值是0，表示不使用dropout。

7. bidirectional:

   • 是否使用双向RNN。如果设置为True，模型会同时考虑序列的正向和反向信息，这通常有助于提高性能，尤其是在长序列任务中。

8. nonlinearity:

   • 激活函数的类型。'tanh'是默认值，它会在每个时间步计算隐藏状态时应用tanh函数，帮助隐藏状态保持在[-1, 1]的范围内。也可以选择'relu'，这是另一种常用的激活函数。

具体示例-猜数字小游戏

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
​
# 设置随机种子
torch.manual_seed(42)
​
​
class NumberGuessingRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(NumberGuessingRNN, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
​
        # 嵌入层 - 将数字转换为向量
        self.embedding = nn.Embedding(input_size, hidden_size)
​
        # RNN层
        self.rnn = nn.RNN(hidden_size, hidden_size, num_layers, batch_first=True)
​
        # 输出层
        self.fc = nn.Linear(hidden_size, output_size)
​
    def forward(self, x, hidden=None):
        # 嵌入层
        embedded = self.embedding(x)
​
        # RNN层
        if hidden is None:
            rnn_out, hidden = self.rnn(embedded)
        else:
            rnn_out, hidden = self.rnn(embedded, hidden)
​
        # 只取最后一个时间步的输出
        last_output = rnn_out[:, -1, :]
​
        # 全连接层
        output = self.fc(last_output)
​
        return output, hidden
​
​
def generate_sequence_data(seq_length=5, num_samples=1000, max_num=20):
    """生成数字序列数据"""
    sequences = []
    targets = []
​
    for _ in range(num_samples):
        # 生成随机起始数字
        start = np.random.randint(0, max_num - seq_length)
​
        # 创建序列 (例如: [3,4,5,6,7])
        seq = [start + i for i in range(seq_length)]
        sequences.append(seq)
​
        # 目标是序列的下一个数字 (例如: 8)
        target = start + seq_length
        targets.append(target)
​
    return np.array(sequences), np.array(targets)
​
​
def train_model():
    """训练模型"""
    # 生成训练数据
    sequences, targets = generate_sequence_data(seq_length=5, num_samples=10000, max_num=50)
    print(sequences, len(sequences))
    print(targets, len(targets))
    # 转换为PyTorch张量
    sequences_tensor = torch.tensor(sequences, dtype=torch.long)
    targets_tensor = torch.tensor(targets, dtype=torch.long)
​
    # 创建数据集
    dataset = torch.utils.data.TensorDataset(sequences_tensor, targets_tensor)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
​
    # 模型参数
    input_size = 51  # 0-50
    hidden_size = 64
    output_size = 51  # 0-50
    num_layers = 2
​
    # 创建模型
    model = NumberGuessingRNN(input_size, hidden_size, output_size, num_layers)
​
    # 损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
​
    # 训练循环
    for epoch in range(100):
        epoch_loss = 0
        for batch_sequences, batch_targets in dataloader:
            # 前向传播
            outputs, _ = model(batch_sequences)
            loss = criterion(outputs, batch_targets)
​
            # 反向传播
            optimizer.zero_grad()  # 清空梯度
            loss.backward()  # 反向传播
            optimizer.step()  # 更新参数
​
            print(f'Epoch [{epoch}], Loss: {loss:.4f}')
​
    return model
​
​
def play_game(model, max_num=50):
    """与训练好的模型玩猜数字游戏"""
    model.eval()
​
    print("\n=== 数字猜测游戏 ===")
    print("规则: 输入一个数字序列，模型会预测下一个数字")
    print(f"数字范围: 0-{max_num}")
    print("输入'quit'退出游戏\n")
​
    while True:
        user_input = input("请输入一个递增的数字序列 (例如: 3 4 5 6 7): ")
​
        if user_input.lower() == 'quit':
            break
​
        try:
            # 解析输入
            sequence = [int(num) for num in user_input.split()]
​
            # 准备输入数据
            input_tensor = torch.tensor([sequence], dtype=torch.long)
​
            # 模型预测
            with torch.no_grad():  # 禁用梯度计算
                output, _ = model(input_tensor)  # 模型预测
                predicted = torch.argmax(output, dim=1).item()  # 获取预测结果
​
            # 显示结果
            actual_next = sequence[-1] + 1
            print(f"序列: {sequence}")
            print(f"模型预测的下一个数字: {predicted}")
            print(f"实际的下一个数字: {actual_next}")
​
            if predicted == actual_next:
                print("✅ 模型猜对了!")
            else:
                print("❌ 模型猜错了!")
​
        except Exception as e:
            print(f"发生错误: {e}")
​
​
if __name__ == "__main__":
    # 训练模型
    print("开始训练模型...")
    model = train_model()
​
    # 玩游戏
    play_game(model)

运行输出：