从LSTM到Transformer：NLP入门实战与模型选择指南

想入门 NLP，但面对 Transformer、BERT、LLM 这些层出不穷的术语，是不是感觉无从下手？网上教程要么是晦涩的数学公式，要么是零散的代码片段，学了半天还是不知道如何把它们串起来解决一个实际问题。

这篇文章要解决的就是这个痛点。我的核心判断是：NLP 入门的关键不在于死磕某个模型的数学细节，而在于快速建立“问题-模型-工具”的映射关系，并亲手跑通一个从数据到结果的完整流程。很多初学者卡在理论里，恰恰是因为缺少一次“从零到一”的实战体验。

本文将带你用 2026 年的视角，重新梳理 NLP 的核心脉络。我们不追求成为理论专家，而是聚焦于：当你拿到一段文本数据时，如何判断该用 LSTM、Transformer 还是 BERT？如何用 PyTorch 快速搭建并训练一个模型？以及，在 LLM 当道的今天，传统的序列模型还有哪些不可替代的价值？

读完本文，你将能清晰地理解 NLP 主流模型（RNN/LSTM/Transformer/BERT）的适用场景与核心差异，并亲手完成一个基于 LSTM 的文本分类实战项目。更重要的是，你会建立起一套属于自己的 NLP 问题解决框架，知道下一步该往哪里深入。

1. 从“黑话”到工具：重新理解 NLP 技术栈

在深入代码之前，我们必须先理清概念。很多初学者感到混乱，是因为把不同层次的概念混为一谈。我们可以把 NLP 技术栈分为四个层次：

第一层：任务定义层。这是你要解决的具体问题，比如情感分析（判断评论正负面）、命名实体识别（找出文本中的人名、地名）、机器翻译、文本摘要等。

第二层：模型架构层。这是解决任务的“算法蓝图”。过去十年，主流架构经历了从RNN/LSTM到Transformer的演变。LSTM 擅长处理有前后依赖关系的序列（如时间序列、文本），而 Transformer 凭借其“自注意力”机制，能更好地捕捉长距离依赖，并行效率也更高，成为当前大模型的基石。

第三层：预训练模型层。这是基于特定架构，在海量文本上预先训练好的“知识库”。BERT就是基于 Transformer 架构的著名预训练模型。你不需要从零开始训练，只需在 BERT 学到的通用语言知识基础上，用你的业务数据做微调，就能快速得到一个高质量模型。这大大降低了 NLP 的应用门槛。

第四层：大语言模型层。这是预训练模型的进一步升级，通常指参数量巨大（如千亿级）、能力极强的模型，如 GPT、LLaMA 等。它们通常基于 Transformer 的 Decoder 部分，具备强大的生成和理解能力。对于大多数入门和中级任务，我们更多是“调用”而非“训练”LLM。

它们之间的关系，可以用一个简单的表格来厘清：

对于初学者，最容易产生的误解是：认为 Transformer 和 BERT 是并列关系，或者认为 LSTM 已经彻底过时。实际上，Transformer 是一种架构，BERT 是基于该架构的一个具体模型实例。而 LSTM 在数据量较小、序列顺序性极强的任务（如某些传感器时序预测）中，依然有其简洁高效的优势。

接下来，我们将从最经典、最能体现序列建模思想的 LSTM 入手，完成一个完整的实战项目。理解它，是理解更复杂模型的基础。

2. 环境准备：构建可复现的 PyTorch 开发环境

工欲善其事，必先利其器。一个独立、版本清晰的环境是避免“跑不通代码”噩梦的第一步。强烈建议使用 Conda 或 venv 创建虚拟环境。

2.1 创建并激活虚拟环境

# 使用 conda（推荐） conda create -n nlp_tutorial python=3.9 conda activate nlp_tutorial # 或者使用 venv python -m venv nlp_tutorial # Windows nlp_tutorial\Scripts\activate # Linux/Mac source nlp_tutorial/bin/activate

2.2 安装核心依赖

我们将使用 PyTorch 作为深度学习框架，并用 torchtext 来处理文本数据。请注意，torchtext 的 API 在较新版本中有较大变化，为了教程稳定，我们指定一个广泛兼容的版本。

# 安装 PyTorch (请根据你的CUDA版本前往 https://pytorch.org/ 获取最新命令) # 此处以CPU版本为例，适合所有环境 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu # 安装 torchtext 和必要工具 pip install torchtext==0.15.2 pip install scikit-learn pandas tqdm

验证安装：

import torch import torchtext print(f"PyTorch 版本: {torch.__version__}") print(f"Torchtext 版本: {torchtext.__version__}") print(f"CUDA 是否可用: {torch.cuda.is_available()}")

如果成功输出版本信息且无报错，则环境准备就绪。

3. 核心概念聚焦：LSTM 为何能缓解梯度问题？

在动手写代码前，我们需要理解为什么选择 LSTM 作为第一个实战模型。这涉及到 RNN 的一个经典难题：梯度消失/爆炸。

通俗理解：想象你要训练一个模型理解一段话。RNN 就像一个人逐字阅读，每读一个新字，他都会结合刚读的字来更新自己的理解。但当这段话很长时（比如100个字），最早读的那些字对当前理解的影响就会变得微乎其微（梯度消失），或者影响被异常放大（梯度爆炸）。这导致模型无法学习长距离的依赖关系。

LSTM 的解决方案：LSTM（长短期记忆网络）在 RNN 的基础上，引入了“细胞状态”和三个“门控机制”。

• 细胞状态：像一条传送带，贯穿整个序列，可以相对稳定地传递信息。
• 遗忘门：决定从细胞状态中丢弃哪些旧信息。
• 输入门：决定将哪些新信息存入细胞状态。
• 输出门：基于当前的细胞状态，决定输出什么。

你可以把 LSTM 单元想象成一个有“记忆”的决策单元。它不会被动地让所有信息随时间衰减，而是主动地选择“记住什么”、“忘记什么”、“输出什么”。正是这种精密的门控设计，使得它能够有效地捕捉长序列中的依赖关系，缓解了普通 RNN 的梯度问题。

理解了这一点，再看代码中的nn.LSTM模块，你就知道它内部在忙活些什么了。

4. 实战项目：基于 LSTM 的文本情感分类

我们将使用经典的 IMDB 电影评论数据集，构建一个二分类模型（正面/负面评价）。这个项目麻雀虽小，五脏俱全，涵盖了 NLP 任务的标准流程。

4.1 数据加载与预处理

首先，我们使用 torchtext 加载并预处理 IMDB 数据集。torchtext 帮我们完成了下载、分词、构建词汇表等繁琐工作。

import torch from torchtext.datasets import IMDB from torchtext.data.utils import get_tokenizer from torchtext.vocab import build_vocab_from_iterator from torch.utils.data import DataLoader from torch import nn import time # 1. 定义分词器（使用基本的分词器） tokenizer = get_tokenizer('basic_english') # 2. 定义数据迭代器，并构建词汇表 def yield_tokens(data_iter): for _, text in data_iter: yield tokenizer(text) # 加载训练集 print("正在加载 IMDB 数据集并构建词汇表...") train_iter = IMDB(split='train') # 构建词汇表，设置最大词汇量，并添加特殊标记 vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=['<unk>', '<pad>', '<bos>', '<eos>']) vocab.set_default_index(vocab['<unk>']) # 设置默认索引，遇到未知词用<unk>代替 print(f"词汇表大小: {len(vocab)}") # 3. 文本转换管道：将文本字符串转换为词汇索引的Tensor text_pipeline = lambda x: [vocab[token] for token in tokenizer(x)] label_pipeline = lambda x: 1 if x == 'pos' else 0 # 4. 数据批处理函数 def collate_batch(batch): label_list, text_list, text_lengths = [], [], [] for (_label, _text) in batch: label_list.append(label_pipeline(_label)) processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64) text_list.append(processed_text) text_lengths.append(processed_text.size(0)) # 对文本进行填充，使一个batch内的序列长度一致 text_list = nn.utils.rnn.pad_sequence(text_list, padding_value=vocab['<pad>'], batch_first=True) label_list = torch.tensor(label_list, dtype=torch.int64) text_lengths = torch.tensor(text_lengths, dtype=torch.int64) # 对文本长度进行排序（后续 pack_padded_sequence 需要） text_lengths, perm_idx = text_lengths.sort(descending=True) text_list = text_list[perm_idx] label_list = label_list[perm_idx] return label_list, text_list, text_lengths # 5. 创建 DataLoader BATCH_SIZE = 64 train_iter = IMDB(split='train') # 重新获取迭代器 train_dataloader = DataLoader(list(train_iter), batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch) # 取一个批次看看形状 for labels, texts, lengths in train_dataloader: print(f'标签批次形状: {labels.shape}') # torch.Size([64]) print(f'文本批次形状: {texts.shape}') # torch.Size([64, 最大序列长度]) print(f'长度批次形状: {lengths.shape}') # torch.Size([64]) break

关键点解析：

• vocab：将单词映射为数字索引的字典，是文本进入模型前的必要步骤。
• collate_batch：这是DataLoader的核心。因为每个评论长度不同，我们需要用<pad>将它们填充到同一长度（pad_sequence），并记录原始长度。对长度排序是为了后续 LSTM 使用pack_padded_sequence提高计算效率。
• DataLoader：PyTorch 的数据加载器，负责批量生成数据，并自动打乱。

4.2 构建 LSTM 模型

现在，我们来定义模型。一个典型的用于文本分类的 LSTM 网络包含以下几个部分：

1. 嵌入层：将单词索引转换为密集向量。
2. LSTM 层：核心序列处理层。
3. 全连接层：将 LSTM 的输出映射到分类结果。

class LSTMModel(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim, n_layers, dropout_rate, pad_idx): super().__init__() # 嵌入层 self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_idx) # LSTM层 self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers=n_layers, bidirectional=False, # 先使用单向LSTM batch_first=True, dropout=dropout_rate if n_layers > 1 else 0) # 多层时使用dropout # 全连接层 self.fc = nn.Linear(hidden_dim, output_dim) # Dropout层 self.dropout = nn.Dropout(dropout_rate) def forward(self, text, text_lengths): # text shape: [batch_size, seq_len] # 1. 通过嵌入层 embedded = self.dropout(self.embedding(text)) # shape: [batch_size, seq_len, embed_dim] # 2. 打包序列，提高LSTM效率 packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=True) packed_output, (hidden, cell) = self.lstm(packed_embedded) # hidden shape: [num_layers * num_directions, batch_size, hidden_dim] # 3. 取最后一层的隐藏状态作为序列的表示 # 我们使用的是单向LSTM，所以 hidden[-1, :, :] 就是最后一个时间步的隐藏状态 hidden = self.dropout(hidden[-1, :, :]) # shape: [batch_size, hidden_dim] # 4. 通过全连接层输出 output = self.fc(hidden) # shape: [batch_size, output_dim] return output # 模型参数 VOCAB_SIZE = len(vocab) EMBED_DIM = 100 HIDDEN_DIM = 256 OUTPUT_DIM = 2 # 正面/负面 N_LAYERS = 2 DROPOUT_RATE = 0.5 PAD_IDX = vocab['<pad>'] # 实例化模型 model = LSTMModel(VOCAB_SIZE, EMBED_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, DROPOUT_RATE, PAD_IDX) print(model)

代码精讲：

• nn.Embedding：这是 NLP 的标配。它将每个单词索引（一个整数）映射为一个固定长度的向量（embed_dim维）。这个向量会在训练过程中被优化，可以理解为模型学到的“单词含义”。
• pack_padded_sequence：这是处理变长序列的关键技巧。它告诉 LSTM 哪些位置是填充的，从而避免在填充部分进行无意义的计算，能显著提升训练速度。
• hidden[-1, :, :]：LSTM 会输出所有时间步的隐藏状态，但对于分类任务，我们通常只关心序列整体的语义。这里我们取最后一层 LSTM 的最后一个有效时间步的隐藏状态（通过pack_padded_sequence处理，hidden的最后一维已经对应了序列的末尾）作为整个句子的向量表示。
• Dropout：一种正则化技术，随机“关闭”一部分神经元，防止模型过拟合。在嵌入层后和全连接层前使用效果较好。

4.3 定义损失函数与优化器

模型定义好后，我们需要告诉它如何学习（优化器）以及学得好不好（损失函数）。

# 定义损失函数和优化器 import torch.optim as optim # 损失函数：交叉熵损失，适用于分类问题 criterion = nn.CrossEntropyLoss() # 优化器：Adam，自适应学习率，非常常用 optimizer = optim.Adam(model.parameters(), lr=1e-3) # 将模型移动到GPU（如果可用） device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) criterion = criterion.to(device) print(f'使用设备: {device}')

关键概念：

• nn.CrossEntropyLoss()：分类任务的标准损失函数。它内部已经包含了 Softmax 操作，所以模型最后一层不需要再加 Softmax。
• optim.Adam：当前最流行的优化器之一，相比传统的 SGD，它能为每个参数计算自适应学习率，收敛更快更稳。lr=1e-3是一个常用的初始学习率。

4.4 训练与验证循环

这是整个流程的核心，我们将实现一个标准的训练 epoch 和一个评估 epoch。

def train_epoch(model, dataloader, criterion, optimizer, device): model.train() # 切换到训练模式（启用Dropout等） epoch_loss = 0 epoch_acc = 0 for batch_idx, (labels, texts, lengths) in enumerate(dataloader): # 将数据移动到设备 labels = labels.to(device) texts = texts.to(device) lengths = lengths.to(device) # 1. 梯度清零 optimizer.zero_grad() # 2. 前向传播 predictions = model(texts, lengths).squeeze(1) # 3. 计算损失 loss = criterion(predictions, labels) # 4. 计算准确率 acc = calculate_accuracy(predictions, labels) # 5. 反向传播 loss.backward() # 6. 更新参数 optimizer.step() epoch_loss += loss.item() epoch_acc += acc.item() # 每处理一定批次打印一次进度 if batch_idx % 50 == 0: print(f' Batch {batch_idx}/{len(dataloader)}, Loss: {loss.item():.4f}, Acc: {acc.item():.4f}') return epoch_loss / len(dataloader), epoch_acc / len(dataloader) def evaluate(model, dataloader, criterion, device): model.eval() # 切换到评估模式（关闭Dropout等） epoch_loss = 0 epoch_acc = 0 with torch.no_grad(): # 关闭梯度计算，节省内存和计算 for labels, texts, lengths in dataloader: labels = labels.to(device) texts = texts.to(device) lengths = lengths.to(device) predictions = model(texts, lengths).squeeze(1) loss = criterion(predictions, labels) acc = calculate_accuracy(predictions, labels) epoch_loss += loss.item() epoch_acc += acc.item() return epoch_loss / len(dataloader), epoch_acc / len(dataloader) def calculate_accuracy(preds, y): """计算准确率""" # preds shape: [batch_size, output_dim] # y shape: [batch_size] _, predicted = torch.max(preds, dim=1) # 取概率最大的类别 correct = (predicted == y).float() acc = correct.sum() / len(correct) return acc # 准备验证集 valid_iter = IMDB(split='test') valid_dataloader = DataLoader(list(valid_iter), batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_batch) # 开始训练 N_EPOCHS = 5 print("开始训练...") for epoch in range(N_EPOCHS): start_time = time.time() train_loss, train_acc = train_epoch(model, train_dataloader, criterion, optimizer, device) valid_loss, valid_acc = evaluate(model, valid_dataloader, criterion, device) end_time = time.time() epoch_mins, epoch_secs = divmod(end_time - start_time, 60) print(f'Epoch: {epoch+1:02} | Time: {epoch_mins:.0f}m {epoch_secs:.0f}s') print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%') print(f'\t Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:.2f}%')

运行结果与解读： 运行上述代码，你会看到类似下面的输出（具体数值会因随机性而不同）：

开始训练... Batch 0/391, Loss: 0.6931, Acc: 0.5000 Batch 50/391, Loss: 0.6321, Acc: 0.6562 ... Epoch: 01 | Time: 2m 30s Train Loss: 0.512 | Train Acc: 74.32% Val. Loss: 0.432 | Val. Acc: 80.15% ... Epoch: 05 | Time: 2m 25s Train Loss: 0.285 | Train Acc: 88.91% Val. Loss: 0.318 | Val. Acc: 86.74%

这意味着什么？

• Loss（损失）：衡量模型预测与真实标签的差距，越低越好。训练 Loss 持续下降说明模型在学习。
• Accuracy（准确率）：预测正确的比例。在 IMDB 二分类任务上，一个简单的 LSTM 模型在 5 个 epoch 后能达到86%+的验证集准确率，这已经是一个不错的结果，证明了模型的有效性。
• 关键观察：验证集准确率（Val. Acc）与训练集准确率（Train Acc）相差不大，说明模型没有严重过拟合。如果 Train Acc 远高于 Val. Acc，则需要考虑增加 Dropout、降低模型复杂度或获取更多数据。

5. 模型推理：用训练好的模型预测新评论

训练完成后，我们可以保存模型，并用于预测新的电影评论。

def predict_sentiment(model, sentence, vocab, tokenizer, device, max_length=500): """预测单条文本的情感""" model.eval() # 文本预处理 tokenized = tokenizer(sentence) if len(tokenized) > max_length: tokenized = tokenized[:max_length] # 截断过长的句子 indexed = [vocab[t] for t in tokenized] tensor = torch.LongTensor(indexed).unsqueeze(0).to(device) # shape: [1, seq_len] length_tensor = torch.LongTensor([len(indexed)]).to(device) with torch.no_grad(): prediction = model(tensor, length_tensor) # 获取概率 probabilities = torch.softmax(prediction, dim=1) # 获取预测类别 _, predicted_class = torch.max(prediction, dim=1) sentiment = '正面' if predicted_class.item() == 1 else '负面' confidence = probabilities[0][predicted_class.item()].item() return sentiment, confidence # 测试几个例子 test_sentences = [ "This movie is fantastic! The acting was great and the plot was engaging.", "A terrible waste of time. Boring and poorly acted.", "It was okay, not as good as I expected but had some funny moments." ] print("\n--- 模型预测测试 ---") for sent in test_sentences: sentiment, confidence = predict_sentiment(model, sent, vocab, tokenizer, device) print(f'评论: \"{sent[:50]}...\"') print(f' 预测情感: {sentiment} (置信度: {confidence:.2%})') print()

6. 从 LSTM 到 Transformer 与 BERT：技术演进与选择

跑通了 LSTM 项目，你现在已经掌握了 NLP 建模的完整流程：数据处理、词嵌入、序列模型、训练、评估。这是理解一切更高级模型的基础。

那么，LSTM、Transformer、BERT 和 LLM 到底是什么关系？我们该如何选择？

1. LSTM (及其变体 GRU)：

• 核心价值：序列建模的经典方法，结构相对简单，参数量小，在小数据集或对序列顺序极其敏感的任务上仍有优势。
• 适用场景：中等长度文本分类、时间序列预测、作为复杂模型的子模块。
• 本文位置：作为理解序列建模的“教学模型”。

2. Transformer：

• 核心突破：完全基于“自注意力”机制，摒弃了 RNN 的循环结构，实现了高度的并行化，极大地提升了训练效率，并能更好地建模长距离依赖。
• 与 LSTM 的关键区别：LSTM 是“串行”处理，Transformer 是“并行”处理。Transformer 的注意力机制让每个词都能直接与句子中所有其他词建立联系，无论距离多远。
• 适用场景：几乎所有现代 NLP 任务的基石架构，尤其是机器翻译、文本生成、长文档理解。

3. BERT：

• 本质：是基于 Transformer 编码器部分，在海量语料上通过“掩码语言模型”和“下一句预测”任务进行预训练得到的模型。
• 给你的价值：你不需要从零开始训练一个 Transformer。你可以下载预训练好的 BERT，在其强大的通用语言表征基础上，用你的少量业务数据（如几千条评论）进行“微调”，就能快速得到一个高性能的专业模型。这被称为“迁移学习”。
• 操作变化：在代码层面，你需要将nn.LSTM换成transformers.BertModel，并在其输出后接一个分类头。数据处理部分也需要使用 BERT 对应的分词器。

4. LLM (大语言模型)：

• 本质：通常是基于 Transformer 解码器部分，在超大规模数据和算力上训练出的巨型模型（如 GPT、LLaMA）。
• 给你的选择：
  • 调用 API：对于大多数应用，直接调用 OpenAI、文心一言等提供的 API 是最快的方式。
  • 本地部署与微调：对于有隐私、成本或定制化需求的场景，可以下载开源 LLM（如 LLaMA 3），在自己的领域数据上进行“指令微调”或“全参数微调”。这需要强大的 GPU 资源和更复杂的工程技巧。

选择建议：

• 入门/教学/轻量级任务：从LSTM开始，理解本质。
• 需要快速获得高精度：使用BERT等预训练模型进行微调。
• 需要生成文本、对话、复杂推理：考虑使用或微调LLM。
• 研究或定制化架构：深入理解Transformer并自己实现或修改。

7. 常见问题与排查思路

在实践过程中，你几乎一定会遇到下面这些问题。这里提供一个快速排查指南。

8. 最佳实践与工程建议

当你掌握了基础流程后，下面这些建议能让你的项目更加稳健和专业。

1. 数据预处理是重中之重

• 文本清洗：去除 HTML 标签、特殊字符、统一大小写。
• 分词：对于英文，basic_english分词器足够入门。对于中文，需要专门的分词工具（如 jieba）或基于字的分词。
• 词汇表：考虑设置最大词汇量，过滤掉出现频率过低的词，以控制模型大小。

2. 模型调试技巧

• 超参数调优：EMBED_DIM（100-300）、HIDDEN_DIM（128-512）、N_LAYERS（1-3）、DROPOUT_RATE（0.3-0.7）和学习率是需要重点调节的。建议使用网格搜索或随机搜索，但先从本文的默认值开始。
• 监控训练过程：使用 TensorBoard 或 WandB 记录 loss 和 accuracy 曲线，直观判断模型状态。

3. 项目结构规范化

your_nlp_project/ ├── data/ # 存放原始和处理后的数据 ├── src/ │ ├── data_loader.py # 数据加载与预处理模块 │ ├── model.py # 模型定义 │ ├── train.py # 训练脚本 │ └── predict.py # 推理脚本 ├── configs/ # 配置文件（超参数） ├── saved_models/ # 保存训练好的模型 ├── requirements.txt # 项目依赖 └── README.md # 项目说明

4. 迈向下一步：用 BERT 升级你的项目当你用 LSTM 跑通流程后，升级到 BERT 会非常顺畅。主要改动点：

• 安装transformers库：pip install transformers
• 将分词器换成BertTokenizer.from_pretrained('bert-base-uncased')
• 将模型换成BertModel.from_pretrained('bert-base-uncased')，并在其输出上添加分类头。
• 训练时，通常只需要微调最后几层，可以冻结 BERT 的前面层以加快训练。

通过这个 LSTM 实战项目，你不仅学会了一个可运行的模型，更重要的是掌握了 NLP 从数据到结果的完整工作流。这个工作流是通用的，无论是面对 Transformer、BERT 还是未来的新模型，你都知道该如何入手：处理数据、构建模型、定义损失、训练优化、评估验证。

下一步，我建议你尝试用相同的 IMDB 数据集，但将模型替换为 BERT，亲身体验一下预训练模型带来的性能提升和便捷性。你会发现，很多底层流程是相通的，变化的只是模型模块和分词方式。这才是学习 NLP 最有效率的方式：掌握不变的模式，去拥抱万变的技术。