BiGRU基础模型实战：从零构建高效文本分类器

1次阅读

共计 3059 个字符，预计需要花费 8 分钟才能阅读完成。

文本分类是自然语言处理 (NLP) 中最基础也最广泛的任务之一，它能够将海量无序文本自动归类，支撑舆情监控、客服工单分类等实际业务。但面对复杂的语言现象，传统规则方法难以应对一词多义、上下文依赖等挑战。深度学习模型通过自动学习文本特征，成为当前最有效的解决方案。

在众多深度学习架构中，循环神经网络 (RNN) 及其变体因其处理序列数据的天然优势被广泛应用。以下是常见模型的对比：

模型类型	参数量(示例)	计算复杂度	准确率(IMDb 数据集)
单向 RNN	1.2M	O(n)	82.3%
LSTM	1.8M	O(n)	85.7%
BiGRU	2.1M	O(2n)	87.2%

测试环境：RTX 3090, CUDA 11.3, hidden_size=256

双向门控循环单元 (Bidirectional GRU) 通过正向和反向两个方向的 GRU 层，能同时捕捉前后文信息。相比 LSTM，GRU(Gated Recurrent Unit)减少了门控数量，在保持相近效果的同时计算效率更高。

import torch
import torch.nn as nn

class BiGRUWithAttention(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_size, num_layers, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.gru = nn.GRU(
            input_size=embed_dim,
            hidden_size=hidden_size,
            num_layers=num_layers,
            bidirectional=True,
            batch_first=True
        )
        self.attention = nn.Linear(hidden_size*2, 1)  # 双向输出拼接
        self.fc = nn.Linear(hidden_size*2, num_classes)

    def forward(self, x):
        # x shape: (batch_size, seq_len)
        embedded = self.embedding(x)  # (batch_size, seq_len, embed_dim)

        # BiGRU 处理
        outputs, _ = self.gru(embedded)  # (batch_size, seq_len, hidden_size*2)

        # 注意力机制
        attention_weights = torch.softmax(self.attention(outputs), dim=1
        )  # (batch_size, seq_len, 1)
        context = torch.sum(attention_weights * outputs, dim=1)  # (batch_size, hidden_size*2)

        return self.fc(context)

关键参数说明：
– hidden_size=256：单方向 GRU 隐藏层维度
– num_layers=2：堆叠 GRU 层数
– batch_first=True：输入输出采用 (batch, seq, feature) 格式

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

tokenizer = get_tokenizer('basic_english')

def build_vocab(texts):
    vocab = build_vocab_from_iterator(map(tokenizer, texts),
        specials=['<unk>', '<pad>']
    )
    vocab.set_default_index(vocab['<unk>'])
    return vocab

# 文本清洗示例
def clean_text(text):
    text = re.sub(r'[^\w\s]', '', text.lower())
    return text.strip()

# Padding 处理
def pad_sequence(batch, max_len=256, pad_idx=1):
    return torch.nn.utils.rnn.pad_sequence([torch.tensor(x[:max_len]) for x in batch],
        batch_first=True,
        padding_value=pad_idx
    )

batch_size	显存占用(GB)	训练速度(s/batch)
32	2.1	0.15
64	3.8	0.21
128	7.2	0.38

from torch.optim.lr_scheduler import LambdaLR

def get_warmup_scheduler(optimizer, warmup_steps):
    def lr_lambda(current_step):
        if current_step < warmup_steps:
            return float(current_step) / float(max(1, warmup_steps))
        return 1.0
    return LambdaLR(optimizer, lr_lambda)

# 使用示例
optimizer = torch.optim.Adam(model.parameters(), lr=5e-4)
scheduler = get_warmup_scheduler(optimizer, warmup_steps=1000)

# 在训练循环中加入梯度裁剪
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)

经验值：
– 普通任务：max_norm=1.0~5.0
– 长文本任务：建议缩小到0.5~2.0

from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence

# 假设 lengths 是每个样本的实际长度
embedded = self.embedding(x)
packed_input = pack_padded_sequence(embedded, lengths.cpu(), batch_first=True, enforce_sorted=False
)
packed_output, _ = self.gru(packed_input)
outputs, _ = pad_packed_sequence(packed_output, batch_first=True)

关键点：
1. 输入序列需按长度降序排列
2. enforce_sorted=False允许不严格排序
3. 计算 attention 前需要恢复 padding 状态