PyTorch 循环神经网络（千字长文）

PyTorch 循环神经网络入门：从零开始理解序列建模

在深度学习的世界里，处理序列数据一直是个挑战。我们每天都在面对文本、语音、时间序列这些具有“顺序”特征的数据。传统神经网络就像一个只会看“快照”的人，无法理解事件之间的前后关系。而 PyTorch 循环神经网络（RNN）就像是一个善于记忆的读者，它能记住前面读过的内容，再结合当前信息做出判断。

想象一下你正在读一本小说。如果你只看当前这一页，可能无法理解角色的情感变化。但如果你还记得前几页的情节，就能更好地理解此刻的对话。RNN 的核心思想正是如此——它通过“记忆”机制，让模型能够理解序列中各个元素之间的依赖关系。

PyTorch 循环神经网络提供了灵活且强大的工具来构建这类模型。它不仅支持标准的 RNN 结构，还集成了 LSTM 和 GRU 等更先进的变体，让你在处理复杂序列任务时游刃有余。

什么是循环神经网络？

循环神经网络是一种专门设计用于处理序列数据的神经网络架构。与前馈神经网络不同，RNN 的核心特点是具有“循环连接”——输出结果会反馈回网络自身，形成一个时间上的闭环。

你可以把 RNN 想象成一个不断翻页的笔记本。每一页代表一个时间步，当你翻到下一页时，你不仅看当前的内容，还会参考之前记下的笔记。这种“记忆”能力，使得 RNN 非常适合处理像自然语言、股票走势、语音信号等具有时间依赖性的任务。

在 PyTorch 中，torch.nn.RNN 是最基础的循环层。它的基本结构如下：

import torch
import torch.nn as nn

rnn = nn.RNN(
    input_size=10,      # 输入特征维度
    hidden_size=20,     # 隐藏状态维度
    num_layers=2,       # 层数
    batch_first=True    # 是否将 batch 放在第一维
)

这里的 input_size 是每个时间步输入的特征数量，比如一个词向量的维度。hidden_size 是隐藏状态的大小，也就是“记忆”的容量。num_layers 表示堆叠多少层 RNN，可以增强模型表达能力。

RNN 的基本工作原理与代码实现

让我们通过一个具体的例子来理解 RNN 是如何工作的。假设我们有一组时间序列数据，每个时间步有一个 10 维的输入向量。

batch_size = 3
seq_len = 5
input_size = 10
hidden_size = 20

inputs = torch.randn(batch_size, seq_len, input_size)

hidden = torch.zeros(2, batch_size, hidden_size)

output, hidden = rnn(inputs, hidden)

print(f"输出形状: {output.shape}")  # 输出: (3, 5, 20)
print(f"最终隐藏状态形状: {hidden.shape}")  # 输出: (2, 3, 20)

在这段代码中：

• inputs 是一个三维张量，形状为 (batch_size, seq_len, input_size)，表示 3 个序列，每个序列有 5 个时间步，每个时间步输入 10 维特征。
• hidden 是初始隐藏状态，形状为 (num_layers, batch_size, hidden_size)，代表每个序列的初始“记忆”。
• rnn(inputs, hidden) 执行前向传播，返回两个结果：
  • output：每个时间步的输出，形状为 (batch_size, seq_len, hidden_size)
  • hidden：最终的隐藏状态，可用于下一个序列或作为上下文信息

关键点在于：RNN 在每个时间步都会更新隐藏状态，并将它传递到下一步。这个过程就像你一边读书一边在心里总结，每读一段，就更新一次你的理解。

LSTM 与 GRU：更高级的循环单元

虽然标准 RNN 很直观，但它在处理长序列时容易遇到“梯度消失”问题——越往后的信息越难被记住。为了解决这个问题，LSTM（长短期记忆网络）和 GRU（门控循环单元）应运而生。

LSTM 通过引入“门控机制”来控制信息的流动。它有三个门：输入门、遗忘门和输出门。你可以把这三个门想象成一个图书馆的管理员：

• 遗忘门：决定哪些旧知识该丢弃
• 输入门：决定哪些新知识该记录
• 输出门：决定当前时刻该输出什么信息

在 PyTorch 中，使用 LSTM 非常简单：

lstm = nn.LSTM(
    input_size=10,
    hidden_size=20,
    num_layers=2,
    batch_first=True
)

output, (hidden, cell) = lstm(inputs)

print(f"LSTM 输出形状: {output.shape}")
print(f"隐藏状态形状: {hidden.shape}")   # (2, 3, 20)
print(f"细胞状态形状: {cell.shape}")     # (2, 3, 20)

GRU 则是 LSTM 的简化版，它合并了遗忘门和输入门，只保留两个门：更新门和重置门。这使得 GRU 更高效，同时在很多任务中表现不输于 LSTM。

gru = nn.GRU(
    input_size=10,
    hidden_size=20,
    num_layers=2,
    batch_first=True
)

output, hidden = gru(inputs)

构建一个文本分类模型实例

接下来，我们用 PyTorch 循环神经网络实现一个简单的文本分类任务：判断一段评论是正面还是负面。

import torch
import torch.nn as nn
import torch.optim as optim

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes, num_layers=2):
        super(TextClassifier, self).__init__()
        
        # 词嵌入层：将词汇索引映射为向量
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        
        # 循环神经网络层
        self.rnn = nn.LSTM(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,
            bidirectional=True  # 双向 RNN，同时看前后上下文
        )
        
        # 全连接层：将隐藏状态映射到类别
        self.fc = nn.Linear(hidden_dim * 2, num_classes)  # *2 因为是双向

    def forward(self, x):
        # x: (batch_size, seq_len)
        
        # 1. 词嵌入
        embedded = self.embedding(x)  # (batch_size, seq_len, embed_dim)
        
        # 2. RNN 处理
        output, (hidden, cell) = self.rnn(embedded)
        
        # 3. 取最后一个时间步的隐藏状态（或使用池化）
        # 这里我们用双向，所以需要拼接前向和后向的最终状态
        # hidden: (num_layers * 2, batch_size, hidden_dim)
        # 取最后一层的两个方向
        last_hidden = torch.cat((hidden[-2], hidden[-1]), dim=1)  # (batch_size, hidden_dim * 2)
        
        # 4. 分类
        logits = self.fc(last_hidden)  # (batch_size, num_classes)
        
        return logits

vocab_size = 10000
embed_dim = 128
hidden_dim = 64
num_classes = 2
batch_size = 16
seq_len = 50

model = TextClassifier(vocab_size, embed_dim, hidden_dim, num_classes)

sample_input = torch.randint(1, vocab_size, (batch_size, seq_len))  # 随机词索引
sample_label = torch.randint(0, num_classes, (batch_size,))         # 随机标签

logits = model(sample_input)
print(f"模型输出: {logits.shape}")  # (16, 2)

这个模型的关键设计点：

• 使用 双向 LSTM，能同时捕捉上下文信息
• 通过 torch.cat 拼接前后向隐藏状态，增强表达力
• 最后一层全连接输出类别概率

实际应用建议与常见问题

在实际项目中使用 PyTorch 循环神经网络时，有几个要点需要注意：

此外，对于长序列任务，现代方法更推荐使用 Transformer 架构。但 RNN 依然在轻量级、低延迟场景中具有不可替代的优势。

总结

PyTorch 循环神经网络是处理序列数据的基石工具。从基础的 RNN 到更强大的 LSTM 和 GRU，它们通过“记忆”机制，让模型能够理解时间依赖关系。

本文从原理到实战，一步步带你构建了一个完整的文本分类模型。你不仅学会了如何定义网络结构，还掌握了前向传播、参数管理、训练流程等核心技能。

如果你正在处理文本、语音或时间序列任务，不妨从一个简单的 RNN 开始尝试。记住：不要追求复杂，先让模型“记住”上下文。当你看到模型开始理解“前后文”的时候，你就真正掌握了 PyTorch 循环神经网络的精髓。

下一步，你可以尝试将模型迁移到真实数据集，比如 IMDB 电影评论，进一步优化超参数，探索更复杂的架构。深度学习之路，始于每一个小小的“记忆”。