RNN 实战指南：用 PyTorch 从零实现文本分类

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！

系列文章目录

Pytorch基础篇

01-PyTorch新手必看：张量是什么？5 分钟教你快速创建张量！
02-张量运算真简单！PyTorch 数值计算操作完全指南
03-Numpy 还是 PyTorch？张量与 Numpy 的神奇转换技巧
04-揭秘数据处理神器：PyTorch 张量拼接与拆分实用技巧
05-深度学习从索引开始：PyTorch 张量索引与切片最全解析
06-张量形状任意改！PyTorch reshape、transpose 操作超详细教程
07-深入解读 PyTorch 张量运算：6 大核心函数全面解析，代码示例一步到位！
08-自动微分到底有多强？PyTorch 自动求导机制深度解析

Pytorch实战篇

09-从零手写线性回归模型：PyTorch 实现深度学习入门教程
10-PyTorch 框架实现线性回归：从数据预处理到模型训练全流程
11-PyTorch 框架实现逻辑回归：从数据预处理到模型训练全流程
12-PyTorch 框架实现多层感知机（MLP）：手写数字分类全流程详解
13-PyTorch 时间序列与信号处理全解析：从预测到生成
14-深度学习必备：PyTorch数据加载与预处理全解析
15-PyTorch实战：手把手教你完成MNIST手写数字识别任务
16-PyTorch 训练循环全攻略：从零到精通的深度学习秘籍
17-PyTorch实现CNN：CIFAR-10图像分类实战教程
18-RNN 实战指南：用 PyTorch 从零实现文本分类

前言

在深度学习的世界中，序列数据无处不在，比如文章中的单词、股票价格的波动、甚至是语音信号。如何让机器理解这些有序的数据？答案之一就是循环神经网络（RNN）。RNN 因其独特的“记忆”能力，成为处理序列数据的利器，广泛应用于自然语言处理（NLP）、时间序列分析等领域。本文将以 PyTorch 为工具，带你从零开始构建一个 RNN 模型，并通过一个文本分类任务（基于 IMDb 电影评论数据集），让你快速上手 RNN 的核心概念和实战技巧。

一、RNN 基础知识

RNN 是深度学习中处理序列数据的基础模型。本节将从“什么是 RNN”入手，逐步为你揭开它的神秘面纱。

1.1 什么是 RNN？

循环神经网络（RNN, Recurrent Neural Network）是一种专门设计用来处理序列数据的神经网络。不同于传统的全连接网络，RNN 有一个“循环”结构，能记住之前的信息，并在处理当前数据时加以利用。

1.1.1 RNN 的核心思想

想象你在读一本书，每读一句话，你都会结合前文来理解当前的内容。RNN 也是如此：它通过一个“隐藏状态”（hidden state），在每个时间步（time step）传递信息，从而捕捉序列中的依赖关系。

• 输入：当前时刻的数据（比如一个单词）。
• 隐藏状态：RNN 的“记忆”，包含之前的信息。
• 输出：当前时刻的预测结果（可选）。

用一个简单的公式表示 RNN 的工作原理：
$$h_t=\tanh (W_{ih}{x}_t+W_{hh}{h}_{t-1}+b)$$

• (x_t)：当前输入
• (h_{t-1})：上一时刻的隐藏状态
• (h_t)：当前隐藏状态
• (W) 和 (b)：权重和偏置

1.1.2 RNN 的应用场景

• 文本分类：判断一段评论是正面还是负面。
• 机器翻译：将英文翻译成中文。
• 时间序列预测：预测明天的股票价格。

1.2 RNN 的优缺点

RNN 虽强大，但并非完美。了解它的优缺点，能帮你更好地选择合适的模型。

1.2.1 优点

• 处理变长序列：无论是一句话还是整篇文章，RNN 都能适应。
• 时间依赖性：能捕捉序列中的先后关系，比如“今天很热”中的“热”依赖“今天”。

1.2.2 缺点

• 梯度问题：训练时可能出现梯度消失（学得太慢）或爆炸（学得太猛）。
• 长距离依赖：当序列很长时，RNN 容易“忘”掉早期的信息。

小贴士：为了解决这些问题，后续出现了 LSTM 和 GRU 等改进模型，后面我们也会提到解决方案。

二、PyTorch 中的 RNN 模块

PyTorch 提供了便捷的 RNN 模块，让我们无需手动实现复杂的公式。接下来，我们看看如何用它快速搭建模型。

2.1 RNN 模块简介

PyTorch 的 torch.nn.RNN 是一个开箱即用的工具，支持单向、双向甚至多层 RNN。

2.1.1 核心参数

• input_size：输入的特征维度（比如单词向量的长度）。
• hidden_size：隐藏状态的维度（决定记忆容量）。
• num_layers：RNN 的层数（多层可以学到更复杂的模式）。
• bidirectional：是否双向（True 表示同时考虑前后文）。
• batch_first：输入数据是否以 [batch, seq_len, feature] 的形式组织。

2.1.2 输入与输出

• 输入：形状为 [seq_len, batch, input_size]（若 batch_first=True 则为 [batch, seq_len, input_size]）。
• 输出：包含每个时间步的隐藏状态 [seq_len, batch, hidden_size] 和最后一个时间步的隐藏状态 [num_layers, batch, hidden_size]。

2.2 简单示例

让我们用代码感受一下 RNN 的用法：

import torch
import torch.nn as nn

# 定义 RNN
rnn = nn.RNN(input_size=10, hidden_size=20, batch_first=True)

# 输入数据：[batch_size, seq_len, input_size]
x = torch.randn(2, 5, 10)  # 2 个样本，每个样本 5 个时间步，每步 10 维

# 前向传播
output, h_n = rnn(x)
print(output.shape)  # [2, 5, 20]：每个时间步的输出
print(h_n.shape)     # [1, 2, 20]：最后一层的隐藏状态

• output：每个时间步的隐藏状态，常用于序列标注任务。
• h_n：最后一个时间步的隐藏状态，适合分类任务。

三、文本分类任务实战

接下来，我们将用 RNN 解决一个实际问题：基于 IMDb 数据集的情感分类（判断电影评论是正面还是负面）。

3.1 任务概述

3.1.1 数据集简介

IMDb 数据集包含 50,000 条电影评论，每条评论标注为“正面”（1）或“负面”（0）。我们的目标是让 RNN 读懂评论并预测情感。

3.1.2 流程概览

1. 数据预处理：将文本转为数字。
2. 模型构建：用 RNN 提取文本特征。
3. 训练与评估：优化模型并测试效果。

3.2 数据预处理

文本是字符串，RNN 需要数字输入，所以我们要先做一些“翻译”工作。

3.2.1 文本分词与词汇表

• 分词：将句子拆成单词，比如“I like it”变成 [“I”, “like”, “it”]。
• 词汇表：给每个单词一个编号，比如 “I” 是 1，“like” 是 2。

可以用 torchtext 简化这个过程：

from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator

tokenizer = get_tokenizer("basic_english")
def yield_tokens(data_iter):
    for text, _ in data_iter:
        yield tokenizer(text)

vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"])

3.2.2 序列填充

评论长短不一，RNN 需要统一长度。我们用 <pad> 填充短序列：

from torch.nn.utils.rnn import pad_sequence

sequences = [torch.tensor(vocab(tokenizer(text))) for text, _ in train_iter]
padded_sequences = pad_sequence(sequences, batch_first=True, padding_value=0)

四、构建 RNN 模型

现在，我们用 PyTorch 搭建一个完整的 RNN 分类器。

4.1 模型结构

模型包含三个部分：

• 嵌入层：将单词编号转为向量。
• RNN 层：提取序列特征。
• 全连接层：输出分类结果。

4.2 代码实现

import torch
import torch.nn as nn

class RNNClassifier(nn.Module):
    def __init__(self, vocab_size, embed_size, hidden_size, num_classes):
        super(RNNClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size)  # 词嵌入
        self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True)  # RNN 层
        self.fc = nn.Linear(hidden_size, num_classes)  # 全连接层
    
    def forward(self, x):
        x = self.embedding(x)  # [batch_size, seq_len, embed_size]
        _, h_n = self.rnn(x)   # h_n 是最后一个时间步的隐藏状态
        h_n = h_n.squeeze(0)   # [batch_size, hidden_size]
        logits = self.fc(h_n)  # [batch_size, num_classes]
        return logits

# 初始化模型
model = RNNClassifier(vocab_size=len(vocab), embed_size=100, hidden_size=128, num_classes=2)

• 关键点：h_n 是 RNN 的最终记忆，我们用它来做分类。

4.3 数据流可视化

用 Mermaid 图展示模型的数据流：

五、训练与评估

模型建好后，我们需要训练它并验证效果。

5.1 训练模型

5.1.1 定义损失和优化器

criterion = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # Adam 优化器

5.1.2 训练循环

for epoch in range(10):  # 10 个 epoch
    for inputs, labels in train_loader:
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item()}")

5.2 评估模型

5.2.1 计算准确率

model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
accuracy = correct / total
print(f"Accuracy: {accuracy:.4f}")

六、完整代码实现

为了方便读者直接上手，这里提供从数据加载到模型训练的完整代码。代码基于 IMDb 数据集，并用 PyTorch 实现情感分类任务。

6.1 完整代码

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
from torchtext.datasets import IMDB
from torch.nn.utils.rnn import pad_sequence

# 1. 数据预处理
tokenizer = get_tokenizer("basic_english")

# 加载 IMDb 数据集
train_iter, test_iter = IMDB(split=('train', 'test'))

# 构建词汇表
def yield_tokens(data_iter):
    for text, label in data_iter:
        yield tokenizer(text)

vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>", "<pad>"])
vocab.set_default_index(vocab["<unk>"])

# 数据转换函数
def text_pipeline(text):
    return torch.tensor(vocab(tokenizer(text)), dtype=torch.long)

def label_pipeline(label):
    return 1 if label == "pos" else 0  # 正面为 1，负面为 0

# 自定义数据集类
class IMDbDataset(Dataset):
    def __init__(self, data_iter):
        self.data = [(text_pipeline(text), label_pipeline(label)) for text, label in data_iter]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx]

# 填充函数
def collate_batch(batch):
    texts, labels = zip(*batch)
    texts = pad_sequence(texts, batch_first=True, padding_value=vocab["<pad>"])
    labels = torch.tensor(labels, dtype=torch.long)
    return texts, labels

# 数据加载器
train_dataset = IMDbDataset(train_iter)
test_dataset = IMDbDataset(test_iter)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, collate_fn=collate_batch)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, collate_fn=collate_batch)

# 2. 定义模型
class RNNClassifier(nn.Module):
    def __init__(self, vocab_size, embed_size, hidden_size, num_classes):
        super(RNNClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=vocab["<pad>"])
        self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)
    
    def forward(self, x):
        x = self.embedding(x)
        _, h_n = self.rnn(x)
        h_n = h_n.squeeze(0)
        logits = self.fc(h_n)
        return logits

# 初始化模型
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = RNNClassifier(vocab_size=len(vocab), embed_size=100, hidden_size=128, num_classes=2).to(device)

# 3. 定义损失和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 4. 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for texts, labels in train_loader:
        texts, labels = texts.to(device), labels.to(device)
        outputs = model(texts)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  # 梯度裁剪
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {total_loss / len(train_loader):.4f}")

# 5. 评估模型
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for texts, labels in test_loader:
        texts, labels = texts.to(device), labels.to(device)
        outputs = model(texts)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
accuracy = correct / total
print(f"Test Accuracy: {accuracy:.4f}")

6.2 代码说明

• 数据预处理：使用 torchtext 加载 IMDb 数据集，构建词汇表并将文本转为数字序列。
• 模型定义：嵌入层使用 padding_idx 忽略填充值，RNN 输出接全连接层进行分类。
• 训练优化：加入梯度裁剪防止爆炸，支持 GPU 加速。
• 运行结果：10 个 epoch 后，测试准确率通常能达到 80% 以上（具体取决于超参数调整）。

提示：运行前需安装 torch 和 torchtext（pip install torch torchtext）。

七、常见问题及解决方案

实战中总会遇到问题，这里总结两个常见坑和解决办法。

7.1 梯度消失或爆炸

7.1.1 现象

训练时损失不下降或突然变成 NaN。

7.1.2 解决方案

• 梯度裁剪：限制梯度大小（已在上文代码中实现）。
• 用 LSTM/GRU：替换 nn.RNN 为 nn.LSTM 或 nn.GRU。

7.2 过拟合

7.2.1 现象

训练集效果好，测试集很差。

7.2.2 解决方案

• Dropout：在 RNN 后加 dropout。

self.dropout = nn.Dropout(0.5)
logits = self.fc(self.dropout(h_n))

• 早停：监控验证集损失，提前停止。

八、总结

通过这篇实战指南，我们从 RNN 的基础概念入手，用 PyTorch 搭建了一个文本分类模型，并在 IMDb 数据集上完成了情感分析任务。RNN 的“记忆”能力让它在序列数据处理中大放异彩，虽然有梯度问题等局限，但通过 LSTM/GRU 和一些技巧可以轻松改进。希望你能通过本文掌握 RNN 的核心思想，并在自己的项目中实践起来！