基于rasbt/deeplearning-models的Packed Sequence RNN情感分析实战-CSDN博客

本文链接：https://blog.csdn.net/gitblog_00983/article/details/148375625

基于rasbt/deeplearning-models的Packed Sequence RNN情感分析实战

前言

在自然语言处理(NLP)任务中，处理变长文本序列是一个常见挑战。本文将介绍如何使用PyTorch中的Packed Sequence技术，构建一个高效的RNN模型来完成IMDB电影评论情感分析任务。这个实现来自深度学习模型集合项目，展示了如何利用PyTorch的高级特性优化RNN性能。

为什么需要处理变长序列

在NLP任务中，文本数据天然具有长度不一的特性。传统处理方法通常采用：

截断法：统一截取固定长度
填充法：用特殊标记填充到统一长度

填充法虽然保持了所有信息，但会带来两个问题：

计算资源浪费（对填充部分进行计算）
可能影响模型学习效果

PyTorch提供的pack_padded_sequence和pad_packed_sequence正是为解决这些问题而设计。

环境与数据准备

基础配置

首先设置模型超参数和随机种子确保可复现性：

RANDOM_SEED = 123
torch.manual_seed(RANDOM_SEED)

# 模型参数
VOCABULARY_SIZE = 20000
LEARNING_RATE = 1e-4
BATCH_SIZE = 128
NUM_EPOCHS = 15
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 网络结构参数
EMBEDDING_DIM = 128
HIDDEN_DIM = 256
OUTPUT_DIM = 1

数据加载与预处理

使用torchtext加载IMDB数据集并进行预处理：

TEXT = data.Field(tokenize='spacy', include_lengths=True)  # 包含长度信息
LABEL = data.LabelField(dtype=torch.float)
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
train_data, valid_data = train_data.split(random_state=random.seed(RANDOM_SEED), split_ratio=0.8)

关键点在于include_lengths=True，这会返回文本序列及其实际长度，为后续pack操作做准备。

构建词汇表

TEXT.build_vocab(train_data, max_size=VOCABULARY_SIZE)
LABEL.build_vocab(train_data)

注意词汇表大小会比VOCABULARY_SIZE大2，因为自动添加了<unk>(未知词)和<pad>(填充)两个特殊标记。

创建批处理迭代器

使用BucketIterator可以自动将长度相似的样本分到同一批次，减少填充数量：

train_loader, valid_loader, test_loader = data.BucketIterator.splits(
    (train_data, valid_data, test_data),
    batch_size=BATCH_SIZE,
    sort_within_batch=True,  # 必须设置为True才能使用pack_padded_sequence
    device=DEVICE)

模型架构

RNN模型定义

class RNN(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim)
        self.fc = nn.Linear(hidden_dim, output_dim)
        
    def forward(self, text, text_length):
        embedded = self.embedding(text)
        packed = torch.nn.utils.rnn.pack_padded_sequence(embedded, text_length)
        output, hidden = self.rnn(packed)
        return self.fc(hidden.squeeze(0)).view(-1)

关键组件解析：

Embedding层：将词索引转换为密集向量
pack_padded_sequence：压缩填充后的序列，跳过填充部分计算
RNN层：处理变长序列，输出最后隐藏状态
全连接层：将隐藏状态映射到输出维度

模型初始化

INPUT_DIM = len(TEXT.vocab)
model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)
model = model.to(DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)

训练过程

评估函数

定义计算二元分类准确率的函数：

def compute_binary_accuracy(model, data_loader, device):
    model.eval()
    correct_pred, num_examples = 0, 0
    with torch.no_grad():
        for batch_idx, batch_data in enumerate(data_loader):
            text, text_lengths = batch_data.text
            logits = model(text, text_lengths)
            predicted_labels = (torch.sigmoid(logits) > 0.5).long()
            num_examples += batch_data.label.size(0)
            correct_pred += (predicted_labels == batch_data.label.long()).sum()
        return correct_pred.float()/num_examples * 100

训练循环

完整训练过程包括前向传播、损失计算和反向传播：

for epoch in range(NUM_EPOCHS):
    model.train()
    for batch_idx, batch_data in enumerate(train_loader):
        text, text_lengths = batch_data.text
        logits = model(text, text_lengths)
        cost = F.binary_cross_entropy_with_logits(logits, batch_data.label)
        optimizer.zero_grad()
        cost.backward()
        optimizer.step()
        
    # 每个epoch结束后评估
    train_acc = compute_binary_accuracy(model, train_loader, DEVICE)
    valid_acc = compute_binary_accuracy(model, valid_loader, DEVICE)
    print(f'Epoch: {epoch+1:03d} | Train Acc: {train_acc:.2f}% | Valid Acc: {valid_acc:.2f}%')

性能分析

使用packed sequence技术带来了显著的性能提升：

训练速度：比普通填充方法快约4倍
内存占用：减少了不必要的计算，内存使用更高效
准确率：最终测试集准确率达到73.94%

实际应用示例

训练完成后，可以使用模型预测新文本的情感倾向：

def predict_sentiment(model, sentence):
    model.eval()
    tokenized = [tok.text for tok in nlp.tokenizer(sentence)]
    indexed = [TEXT.vocab.stoi[t] for t in tokenized]
    length = [len(indexed)]
    tensor = torch.LongTensor(indexed).to(DEVICE)
    tensor = tensor.unsqueeze(1)
    length_tensor = torch.LongTensor(length)
    prediction = torch.sigmoid(model(tensor, length_tensor))
    return prediction.item()