PyTorch实战：TextCNN与TextRNN(LSTM)文本分类模型详解与对比

1. 项目概述：从理论到实践的文本分类跨越

最近在复盘几个老项目，发现无论是舆情分析、评论情感判断，还是新闻自动归类，文本分类始终是绕不开的基础任务。很多朋友学了PyTorch，也跑通了MNIST手写数字识别，但一到处理自己业务里的文本数据就卡壳——模型结构怎么搭？词向量怎么用？训练过程怎么调？问题一个接一个。这期内容，我就以最经典的文本分类场景为切入点，用PyTorch实战TextCNN和TextRNN（LSTM）这两个“常青树”模型。我们的目标不是简单地复现论文，而是搞懂从原始文本到最终分类的每一个环节，包括数据怎么预处理、模型层为什么这样设计、训练时有哪些坑，以及如何解读模型的行为。无论你是想快速上手一个可用的分类器，还是希望深入理解序列模型和卷积模型在文本上的差异，这篇笔记都能给你提供一份可直接运行的“脚手架”和背后的思考逻辑。

2. 核心思路与模型选型：为什么是TextCNN和TextRNN？

面对文本分类任务，选模型就像选工具。全连接网络（Dense Network）直接处理词袋模型（Bag-of-Words）简单粗暴但丢失了词序信息，对于“我喜欢你”和“你喜欢我”可能给出相同的结果，这显然不合理。因此，我们需要能捕捉序列或局部特征的模型。

TextCNN（文本卷积神经网络）的核心思想借鉴了图像CNN。在图像里，卷积核在像素空间滑动，提取局部特征（如边缘、纹理）。在文本里，我们将句子视为一个“词向量矩阵”，每个词是一个行向量。卷积核在“词维度”上滑动（通常是2、3、4个词的窗口），提取相邻词之间的局部语义关联。例如，一个3-gram的卷积核可能专门学习“非常棒”、“质量差”这类短语的特征。最后通过池化层（通常是1-Max Pooling）提取每个特征通道的最显著信号，拼接后送入全连接层分类。它的优势是速度快，能高效捕捉局部关键短语的特征，在情感分析、主题分类等任务上表现优异，尤其是当关键判断信息集中在几个连续词中时。

TextRNN（这里特指基于LSTM的文本循环神经网络）则采取了完全不同的策略。RNN及其变体LSTM、GRU是为序列数据量身定做的。它们按顺序（从左到右）读取句子中的每一个词，并通过隐藏状态（Hidden State）传递历史信息。LSTM通过精巧的门控机制（输入门、遗忘门、输出门）缓解了原始RNN的梯度消失/爆炸问题，能够学习更长的依赖关系。这意味着，TextRNN（LSTM）擅长捕捉上下文依赖和长距离语义。比如判断“尽管价格昂贵，但其卓越的性能和精美的工艺让它物有所值”的情感，需要理解“尽管”带来的转折关系，这正是LSTM的用武之地。通常，我们会使用最后时刻的隐藏状态，或者所有时刻隐藏状态的平均/最大值，来代表整个句子的语义进行分类。

注意：模型选择没有绝对的好坏，只有是否适合。TextCNN像是一个高效的“局部特征扫描仪”，适合模式明显的短文本；TextRNN（LSTM）则像一个“上下文理解者”，适合需要理解逻辑和结构的长文本。在实际项目中，我常常会两者都尝试，或者尝试将它们结合（如RCNN、CNN+LSTM）。

2.1 环境搭建与数据准备实操

工欲善其事，必先利其器。一个稳定、可复现的环境是高效实验的基础。我强烈推荐使用Conda进行环境管理，它能很好地解决包依赖冲突的问题。

# 创建并激活一个专门的PyTorch环境 conda create -n pytorch-text-classify python=3.9 conda activate pytorch-text-classify # 安装PyTorch（以CUDA 11.8为例，请根据你的显卡驱动去官网复制对应命令） pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装必要的工具库 pip install numpy pandas scikit-learn tqdm matplotlib # 用于文本处理 pip install jieba # 中文分词 # 用于数据加载和模型构建 pip install torchtext # 注意：新版PyTorch中torchtext可能需独立安装，且API有变化

对于数据，我们以中文情感分类为例。假设我们有一个data.csv文件，包含text和label两列，标签0代表负面，1代表正面。

import pandas as pd from sklearn.model_selection import train_test_split # 读取数据 df = pd.read_csv('data.csv') texts = df['text'].tolist() labels = df['label'].tolist() # 划分训练集、验证集、测试集 (8:1:1) train_texts, temp_texts, train_labels, temp_labels = train_test_split( texts, labels, test_size=0.2, random_state=42, stratify=labels) val_texts, test_texts, val_labels, test_labels = train_test_split( temp_texts, temp_labels, test_size=0.5, random_state=42, stratify=temp_labels)

接下来是最关键的一步：构建词汇表（Vocabulary）并将文本转换为索引序列。这里我们抛弃复杂的torchtext，手动实现以加深理解。

import jieba from collections import Counter def build_vocab(texts, min_freq=5): """构建词汇表""" word_counter = Counter() for text in texts: # 使用jieba进行中文分词，英文则按空格分即可 words = jieba.lcut(text) word_counter.update(words) # 按词频排序，并过滤低频词 sorted_words = sorted(word_counter.items(), key=lambda x: x[1], reverse=True) vocab = {‘<pad>‘: 0, ‘<unk>‘: 1} # 填充符和未知词 idx = 2 for word, freq in sorted_words: if freq >= min_freq: vocab[word] = idx idx += 1 return vocab def text_to_sequence(text, vocab, max_len=50): """将单条文本转换为索引序列，并进行填充/截断""" words = jieba.lcut(text) seq = [vocab.get(word, vocab[‘<unk>‘]) for word in words[:max_len]] # 截断 if len(seq) < max_len: seq += [vocab[‘<pad>‘]] * (max_len - len(seq)) # 填充 return seq # 构建词汇表（仅使用训练集） vocab = build_vocab(train_texts, min_freq=3) vocab_size = len(vocab) print(f"词汇表大小: {vocab_size}") # 转换所有数据集 max_length = 64 # 根据你的数据分布调整，可以取比如95%分位数 train_sequences = [text_to_sequence(text, vocab, max_length) for text in train_texts] val_sequences = [text_to_sequence(text, vocab, max_length) for text in val_texts] test_sequences = [text_to_sequence(text, vocab, max_length) for text in test_texts]

实操心得：max_length的设置非常关键。设得太小，长文本信息被截断；设得太大，短文本填充过多，浪费计算资源且可能引入噪声。一个实用的技巧是绘制文本长度的分布直方图，选择能覆盖大多数样本（如95%）的长度作为max_length。对于长文档分类，可以考虑分层或截断策略。

3. TextCNN模型详解与实现

理解了思路，我们来动手搭建TextCNN。它的结构清晰，主要包括嵌入层、卷积层、池化层和全连接层。

3.1 模型结构拆解

1. 嵌入层（Embedding Layer）：将每个词的整数索引映射为一个固定维度的稠密向量。这相当于一个可学习的查找表。embedding_dim通常取100, 200, 300。
2. 卷积层（Convolutional Layer）：使用多个不同高度的卷积核（如2,3,4）在嵌入矩阵上滑动。每个卷积核产生一个特征图（Feature Map）。
3. 池化层（Pooling Layer）：对每个特征图进行1-Max Pooling，即取出整个序列中该特征的最大值。这一步抓住了该卷积核所检测特征的最强激活信号。
4. 全连接层（Fully Connected Layer）：将所有卷积核池化后的特征拼接起来，通过一个或多个全连接层，最后用Softmax输出分类概率。

import torch import torch.nn as nn import torch.nn.functional as F class TextCNN(nn.Module): def __init__(self, vocab_size, embed_dim, num_classes, filter_sizes=(2,3,4), num_filters=100, dropout=0.5): super(TextCNN, self).__init__() self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) # padding_idx=0对应<pad> # 创建多个并行的卷积层 self.convs = nn.ModuleList([ nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) for fs in filter_sizes ]) self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(len(filter_sizes) * num_filters, num_classes) def forward(self, x): # x shape: [batch_size, seq_len] embedded = self.embedding(x) # [batch_size, seq_len, embed_dim] embedded = embedded.unsqueeze(1) # 增加通道维 [batch_size, 1, seq_len, embed_dim] conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs] # 每个元素形状: [batch_size, num_filters, seq_len - filter_size + 1] pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved] # 每个元素形状: [batch_size, num_filters] cat = self.dropout(torch.cat(pooled, dim=1)) # [batch_size, num_filters * len(filter_sizes)] out = self.fc(cat) # [batch_size, num_classes] return out

关键参数解析：

• filter_sizes=(2,3,4)：这表示我们同时使用能看到2个词、3个词、4个词上下文的卷积核。这样模型就能同时捕捉到二元词组、三元词组和四元词组的特征。
• num_filters=100：每种尺寸的卷积核有100个，意味着模型可以学习100种不同的模式（比如“非常好”是一种正面模式，“质量差”是一种负面模式）。
• dropout=0.5：在分类器前随机丢弃50%的神经元，是防止过拟合非常有效的手段。

3.2 TextCNN训练流程与技巧

模型定义好了，接下来是训练循环。这里有几个比模型本身更重要的实践细节。

from torch.utils.data import DataLoader, TensorDataset, random_split import torch.optim as optim from tqdm import tqdm # 准备DataLoader batch_size = 64 train_dataset = TensorDataset(torch.LongTensor(train_sequences), torch.LongTensor(train_labels)) val_dataset = TensorDataset(torch.LongTensor(val_sequences), torch.LongTensor(val_labels)) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False) # 初始化模型、损失函数、优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = TextCNN(vocab_size, embed_dim=128, num_classes=2, dropout=0.5).to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=1e-3) # Adam是默认的好选择 # 训练循环 num_epochs = 20 best_val_acc = 0.0 for epoch in range(num_epochs): model.train() total_loss, total_correct = 0, 0 progress_bar = tqdm(train_loader, desc=f'Epoch {epoch+1}/{num_epochs}') for batch_seq, batch_labels in progress_bar: batch_seq, batch_labels = batch_seq.to(device), batch_labels.to(device) optimizer.zero_grad() outputs = model(batch_seq) loss = criterion(outputs, batch_labels) loss.backward() # 梯度裁剪，防止梯度爆炸，对RNN尤其重要，对CNN也有益无害 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() total_loss += loss.item() _, predicted = torch.max(outputs, 1) total_correct += (predicted == batch_labels).sum().item() progress_bar.set_postfix({'loss': loss.item()}) avg_train_loss = total_loss / len(train_loader) train_acc = total_correct / len(train_dataset) # 验证阶段 model.eval() val_correct = 0 with torch.no_grad(): for batch_seq, batch_labels in val_loader: batch_seq, batch_labels = batch_seq.to(device), batch_labels.to(device) outputs = model(batch_seq) _, predicted = torch.max(outputs, 1) val_correct += (predicted == batch_labels).sum().item() val_acc = val_correct / len(val_dataset) print(f'Epoch {epoch+1}: Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}') # 保存最佳模型 if val_acc > best_val_acc: best_val_acc = val_acc torch.save(model.state_dict(), 'best_textcnn_model.pth') print(f' -> Best model saved with val_acc: {val_acc:.4f}')

注意事项：这里我使用了梯度裁剪（Gradient Clipping）。这是一个简单但极其重要的技巧，特别是当文本序列较长时。它通过限制梯度向量的范数，防止在反向传播过程中梯度变得过大（爆炸），从而稳定训练过程。max_norm=1.0是一个常用的经验值。

4. TextRNN（LSTM）模型详解与实现

如果说TextCNN是“空间局部特征”的专家，那么LSTM就是“时间序列依赖”的大师。我们来构建一个用于分类的双向LSTM模型。

4.1 双向LSTM模型构建

双向LSTM（Bi-LSTM）会同时从两个方向（前向和后向）读取序列，最后将两个方向的最终隐藏状态结合起来。这样，每个词的表示都融合了其左右两侧的上下文信息，对于理解语义通常更有帮助。

class BiLSTMTextClassifier(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes, num_layers=2, dropout=0.5): super(BiLSTMTextClassifier, self).__init__() self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) # 双向LSTM self.lstm = nn.LSTM(input_size=embed_dim, hidden_size=hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=True, dropout=dropout if num_layers > 1 else 0) # 因为是双向，所以LSTM输出的隐藏状态维度是 hidden_dim * 2 self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(hidden_dim * 2, num_classes) # 双向，所以是2倍 def forward(self, x): # x shape: [batch_size, seq_len] embedded = self.embedding(x) # [batch_size, seq_len, embed_dim] # 打包序列，提高效率并处理变长序列（这里我们使用了固定长度，但此操作仍有意义） # lengths = (x != 0).sum(dim=1) # 计算实际长度（非填充部分） # packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, lengths.cpu(), batch_first=True, enforce_sorted=False) lstm_out, (hidden, cell) = self.lstm(embedded) # lstm_out shape: [batch_size, seq_len, hidden_dim * 2] # hidden shape: [num_layers * 2, batch_size, hidden_dim] # 取最后一个时间步的输出，或者取前向和后向最后一个隐藏状态的拼接 # 方法1: 取lstm_out的最后一个有效时间步（需要处理padding，略复杂） # 方法2: 直接使用最终隐藏状态（更常用） # 将双向最后层的隐藏状态拼接起来 [batch_size, hidden_dim * 2] hidden_combined = torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1) out = self.dropout(hidden_combined) out = self.fc(out) # [batch_size, num_classes] return out

关键设计决策：

• batch_first=True：让输入输出的张量形状以[batch_size, seq_len, ...]为优先，更符合直觉。
• bidirectional=True：启用双向，这是文本分类的标配，能显著提升模型对上下文的理解能力。
• num_layers=2：使用两层堆叠的LSTM，让模型能够学习更复杂的层次化特征。但层数不是越多越好，通常2-3层足够，更深可能导致难以训练。
• 隐藏状态的使用：这里我使用了最终隐藏状态hidden。hidden[-2]是最后一层的前向LSTM的最终状态，hidden[-1]是最后一层的后向LSTM的最终状态。将它们拼接起来代表整个序列的语义。你也可以尝试使用lstm_out的所有输出做平均或最大池化，有时效果更好。

4.2 LSTM训练的特殊考量

LSTM的训练与CNN大同小异，但有几个点需要特别注意：

# 初始化LSTM模型 model_lstm = BiLSTMTextClassifier(vocab_size, embed_dim=128, hidden_dim=128, num_classes=2, dropout=0.5).to(device) criterion = nn.CrossEntropyLoss() # LSTM的参数通常比CNN多，学习率可以稍小一点 optimizer_lstm = optim.Adam(model_lstm.parameters(), lr=5e-4) # 学习率调度器：在训练停滞时降低学习率 scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer_lstm, mode='max', factor=0.5, patience=2, verbose=True) for epoch in range(num_epochs): model_lstm.train() total_loss = 0 # ... (训练循环与CNN类似，包含梯度裁剪) # 每个epoch结束后在验证集上评估 val_acc = evaluate_on_val(val_loader, model_lstm, device) # 根据验证集性能调整学习率 scheduler.step(val_acc) # 保存最佳模型...

为什么LSTM需要更小的学习率？LSTM的参数更多，结构更复杂，损失平面可能更崎岖。较大的学习率容易导致训练不稳定（损失剧烈震荡）或陷入局部最优点。从1e-3降到5e-4或1e-4是常见的做法。

为什么要用学习率调度器？ReduceLROnPlateau调度器会监控验证集指标（如准确率）。如果连续patience个epoch指标没有提升，它就认为学习可能陷入了平台期，于是将学习率乘以factor（例如减半）。这是一种动态调整策略，能帮助模型在后期精细调优。

5. 实验对比与结果分析

模型训练好了，我们不能只看最后的准确率数字。更重要的是理解模型的行为，分析它们各自擅长什么，在哪里会出错。

5.1 性能指标对比

我们通常在独立的测试集上评估最终模型。除了准确率（Accuracy），还应关注精确率（Precision）、召回率（Recall）和F1分数，特别是当数据类别不均衡时。

from sklearn.metrics import classification_report, confusion_matrix def evaluate_model(model, test_loader, device): model.eval() all_preds = [] all_labels = [] with torch.no_grad(): for seq, labels in test_loader: seq, labels = seq.to(device), labels.to(device) outputs = model(seq) _, preds = torch.max(outputs, 1) all_preds.extend(preds.cpu().numpy()) all_labels.extend(labels.cpu().numpy()) print(classification_report(all_labels, all_preds, target_names=[‘负面‘, ‘正面‘])) # 可以进一步绘制混淆矩阵 # cm = confusion_matrix(all_labels, all_preds) # sns.heatmap(cm, annot=True, fmt='d') return all_preds, all_labels # 加载最佳模型并评估 best_cnn_model = TextCNN(...).to(device) best_cnn_model.load_state_dict(torch.load(‘best_textcnn_model.pth‘)) print("TextCNN 测试集表现：") cnn_preds, cnn_labels = evaluate_model(best_cnn_model, test_loader, device) best_lstm_model = BiLSTMTextClassifier(...).to(device) best_lstm_model.load_state_dict(torch.load(‘best_bilstm_model.pth‘)) print("\nBiLSTM 测试集表现：") lstm_preds, lstm_labels = evaluate_model(best_lstm_model, test_loader, device)

假设我们得到如下对比（虚构数据）：

从结果看，BiLSTM在各项指标上略胜一筹，但代价是训练速度慢了3倍。TextCNN虽然整体指标稍低，但速度优势巨大。

5.2 错误案例分析：洞察模型弱点

数字背后的故事更重要。我们需要看模型具体在哪些样本上分错了。

# 找出两个模型预测不一致的样本 disagree_samples = [] for i in range(len(test_texts)): if cnn_preds[i] != lstm_preds[i] and cnn_preds[i] != test_labels[i]: # CNN错且与LSTM判断不同 disagree_samples.append({ ‘text‘: test_texts[i], ‘true_label‘: test_labels[i], ‘cnn_pred‘: cnn_preds[i], ‘lstm_pred‘: lstm_preds[i] }) # 分析前几个样本 for sample in disagree_samples[:5]: print(f"文本: {sample[‘text‘]}") print(f"真实标签: {‘正面‘ if sample[‘true_label‘]==1 else ‘负面‘}") print(f"TextCNN预测: {‘正面‘ if sample[‘cnn_pred‘]==1 else ‘负面‘}") print(f"BiLSTM预测: {‘正面‘ if sample[‘lstm_pred‘]==1 else ‘负面‘}") print("-"*50)

通过分析，你可能会发现：

• TextCNN容易误判的：句子较长，情感关键词分散在句子各处，或者依赖复杂否定、转折逻辑的句子。例如：“这部电影的特效可以说是一流的，然而剧情之空洞、对白之尴尬，让人如坐针毡。” CNN可能捕捉到了“一流”，但忽略了“然而”后面的强烈负面信息。
• BiLSTM容易误判的：句子很短，但包含强烈的情感俚语或网络新词，而这些词在训练语料中不常见，词向量未能学好。或者句子中有非常关键的局部搭配，但被长序列稀释了。例如：“这手机续航拉胯。” “拉胯”这个词如果未在训练集出现，LSTM可能无法理解。

实操心得：错误分析是提升模型性能和改进数据质量的黄金步骤。如果发现某一类错误频繁出现，可以考虑：1）针对性地增加此类训练数据；2）引入更强大的预训练词向量（如Word2Vec, GloVe, 或中文的Tencent AI Lab Embedding）；3）尝试更复杂的模型结构，如Attention机制，让模型学会聚焦关键部分。

6. 进阶探索与优化方向

当你掌握了这两个基础模型后，可以尝试以下方向进一步提升性能或适应更复杂场景：

1. 使用预训练词向量我们之前使用的嵌入层是随机初始化并在任务中学习的。可以加载在大规模语料上预训练好的词向量（如Word2Vec、GloVe或中文的BERT字向量）来初始化嵌入层，通常能带来显著的性能提升，尤其是在训练数据较少时。

def load_pretrained_embeddings(vocab, embedding_file, embed_dim): """从文件中加载预训练词向量，并构建与当前词汇表对应的权重矩阵""" embeddings = np.random.randn(len(vocab), embed_dim) * 0.01 # 随机初始化 # 读取预训练文件，将对应词的向量赋值给embeddings矩阵 # ... (具体读取逻辑) return torch.FloatTensor(embeddings) # 在模型初始化后，替换embedding层的权重 pretrained_weight = load_pretrained_embeddings(vocab, ‘sgns.zhihu.word‘, embed_dim=300) model.embedding.weight.data.copy_(pretrained_weight) model.embedding.weight.requires_grad = True # 微调词向量，或设为False冻结

2. 引入注意力机制（Attention）对于LSTM，可以使用注意力机制让模型在分类时，动态地给予句子中不同词不同的权重。这相当于让模型学会“哪里是重点”。

class LSTMAttention(nn.Module): def __init__(self, ...): # ... 初始化LSTM和embedding self.attention = nn.Linear(hidden_dim * 2, 1) # 计算每个时间步的重要性得分 # ... def forward(self, x): lstm_out, _ = self.lstm(self.embedding(x)) # [batch, seq_len, hidden*2] # 计算注意力权重 attention_scores = torch.tanh(self.attention(lstm_out)).squeeze(2) # [batch, seq_len] attention_weights = F.softmax(attention_scores, dim=1).unsqueeze(2) # [batch, seq_len, 1] # 加权求和得到句子向量 context_vector = torch.sum(lstm_out * attention_weights, dim=1) # [batch, hidden*2] # ... 后续全连接层

3. 超参数系统优化使用网格搜索（Grid Search）或随机搜索（Random Search）来系统性地调整超参数，如embed_dim,hidden_dim,filter_sizes,num_filters,dropout_rate,learning_rate,batch_size等。工具可以使用Optuna或Ray Tune。

4. 模型集成将TextCNN和BiLSTM的预测结果进行集成（如投票或平均概率），往往能结合两者的优势，获得比单一模型更鲁棒、更准确的结果。

7. 避坑指南与常见问题排查

在实际操作中，你肯定会遇到各种各样的问题。这里我总结了一份“踩坑实录”：

问题1：模型不收敛，损失居高不下或震荡剧烈。

• 检查数据：确认输入数据（索引序列）和标签是否正确对应。打印几个样本看看。
• 检查梯度：在训练循环中打印出模型参数的梯度范数。如果梯度接近0，可能是梯度消失；如果非常大，可能是梯度爆炸（需加强梯度裁剪）。
• 调整学习率：尝试更小的学习率（如1e-4），这是最常解决问题的办法。
• 检查初始化：对于深层网络，不合适的初始化会导致训练困难。PyTorch默认的初始化通常工作良好，但也可以尝试nn.init.xavier_uniform_。

问题2：模型在训练集上表现很好，但在验证集上很差（过拟合）。

• 增加Dropout：这是对抗过拟合的首选武器。尝试将dropout率从0.5提高到0.7。
• 增加正则化：为优化器添加L2权重衰减（optim.Adam(..., weight_decay=1e-5)）。
• 获取更多数据：最根本的方法。如果不行，尝试数据增强，如回译（对文本而言）、随机同义词替换等。
• 简化模型：减少卷积核数量、LSTM隐藏层维度或层数。

问题3：训练速度非常慢。

• 增大batch_size：在GPU内存允许的范围内，增大batch size能提高并行度，显著加速。但注意，太大的batch size可能影响泛化性能。
• 使用pack_padded_sequence：对于LSTM，如果序列长度差异很大，使用此功能避免对填充部分进行计算，可以大幅提速。我们需要一个记录实际长度的张量lengths。
• 检查数据加载：确保DataLoader的num_workers参数大于0（如4或8），以并行加载数据。

问题4：GPU内存溢出（CUDA out of memory）。

• 减小batch_size：最直接有效的方法。
• 减小序列最大长度：检查你的max_length是否设置得过大。
• 使用梯度累积：如果想要的batch_size太大，可以累加多个小batch的梯度后再更新一次参数，模拟大batch的效果。
• 使用混合精度训练：使用torch.cuda.amp进行自动混合精度训练，可以减少显存占用并可能加速。

最后，模型部署上线后，要建立持续的监控机制，关注线上预测数据的分布是否与训练数据发生偏移（概念漂移），并定期用新数据更新模型。机器学习项目从来不是一劳永逸的，而是一个需要持续迭代和维护的系统工程。