文本分类 on 酒中仙

微调 BERT 模型进行文本分类

Wed, 25 Mar 2026 18:34:25 -0800

微调 BERT 模型进行文本分类

回顾前两节的内容，我们依次实现了一个基于全连接网络的“词袋”模型和一个基于 LSTM 的序列模型。这两次的运行结果揭示了一个有趣的现象，对于当前的新闻分类任务，结构更复杂的 LSTM 模型在性能上并未超越更简单的全连接模型。这说明，对于这个特定任务，捕捉“关键词”比分析“词序”更关键。不过，这两种模型都是从零开始训练的，它们对语言的理解完全依赖于我们提供的小规模 20 Newsgroups 数据集。那么我们能否利用在更大、更通用语料库上预先学到的知识，来帮助模型更好地理解文本，从而提升分类性能呢？

这就是预训练语言模型，特别是 BERT，所要解决的问题。在第五章第一节中，我们已经学习了 BERT 的原理。它通过在海量原始文本上以自监督的方式构造“掩码语言模型”和“下一句预测”等训练任务（无需人工标注标签），学习到了丰富的语言学知识和世界知识。本节是文本分类系列实战的最后一站。我们将把模型架构迁移为 BERT，探索从“从零训练”到“微调”这一范式转变所带来的性能提升。

一、从“序列建模”到“预训练微调”

回顾前两个模型，它们的核心都是在特定任务数据上从随机初始化的词向量开始学习如何进行分类。而基于 BERT 的微调则采用了一种完全不同的范式，通常包含以下三个步骤：

（1）加载预训练权重：我们不再随机初始化模型，而是加载一个已经在海量数据（如维基百科、书籍）上训练好的 BERT 模型。这个模型已经是一个通用的“语言理解专家”。

（2）附加任务相关的“头”：在 BERT 模型的主体结构之上，我们添加一个简单的、未经训练的分类层（通常就是一个全连接层）。

（3）在下游任务上“微调”：使用我们的新闻分类数据，对整个模型（或者仅仅是顶部的分类层）进行训练。由于 BERT 部分已经具备了强大的语言理解能力，整个模型可以很快地适应新的分类任务，并且通常只需要很少的训练轮次和较小的学习率。

这个“预训练-微调”的范式是现代 NLP 领域最主流、最有效的方法之一。它大大降低了对特定任务标注数据的依赖，并显著提升了模型性能的上限。

二、代码修改实践

将 LSTM 模型改造为 BERT 模型，同样遵循之前的思路，主要修改涉及数据处理和模型结构，同时也要相应地调整训练超参数。

本节完整代码

2.1 替换为 `BertTokenizer`

现在我们不需要手动构建词典。transformers 库为每个预训练模型都提供了配套的 Tokenizer。对于英文 20 Newsgroups 数据集，选择 bert-base-uncased 模型及其对应的分词器。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from transformers import BertTokenizer

bert_model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(bert_model_name)

# 查看特殊token
print(f"UNK token: '{tokenizer.unk_token}', ID: {tokenizer.unk_token_id}")
print(f"PAD token: '{tokenizer.pad_token}', ID: {tokenizer.pad_token_id}")
print(f"CLS token: '{tokenizer.cls_token}', ID: {tokenizer.cls_token_id}")
print(f"SEP token: '{tokenizer.sep_token}', ID: {tokenizer.sep_token_id}")
print(f"Vocab size: {tokenizer.vocab_size}")

输出：

1
2
3
4
5


UNK token: '[UNK]', ID: 100
PAD token: '[PAD]', ID: 0
CLS token: '[CLS]', ID: 101
SEP token: '[SEP]', ID: 102
Vocab size: 30522

BertTokenizer 会自动处理文本的预处理（如小写转换、标点分割），并为文本添加特殊的 [CLS] 和 [SEP] 标记。其中，[CLS] 位于序列开头，它在 BERT 输出中对应的向量通常被用作整个序列的聚合表示，非常适合用于分类任务；[SEP] 用于分隔两个句子，在单句分类任务中标志着句子的结束。

2.2 改造 `Dataset` 与 `collate_fn`

为了适配 BERT，数据处理流程需要进行如下调整：

（1）Dataset: BertTextClassificationDataset 现在直接调用 BertTokenizer 来进行分词和ID转换。处理长文本的滑窗分割逻辑保持不变。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class BertTextClassificationDataset(Dataset):
 def __init__(self, texts, labels, tokenizer, max_len=128):
 self.tokenizer = tokenizer
 self.max_len = max_len
 self.processed_data = []

 for text, label in tqdm(zip(texts, labels), total=len(labels), desc="Processing Dataset"):
 # 直接使用BertTokenizer进行编码
 encoding = self.tokenizer(text, add_special_tokens=True, truncation=False)
 input_ids = encoding['input_ids']

 # 滑窗分割逻辑保持不变
 if len(input_ids) <= self.max_len:
 self.processed_data.append({"input_ids": input_ids, "label": label})
 else:
 stride = max(1, int(self.max_len * 0.8))
 for i in range(0, len(input_ids) - self.max_len + 1, stride):
 chunk = input_ids[i:i + self.max_len]
 self.processed_data.append({"input_ids": chunk, "label": label})
 ...

（2）collate_fn: BERT 的一个重要输入是 attention_mask（注意力掩码）。它是一个与 input_ids 形状相同的张量，用 1 标记真实 Token，用 0 标记填充（Padding）的 Token。模型会根据这个掩码，在计算注意力时忽略填充部分。所以，我们需要修改 collate_fn 以生成并返回 attention_mask。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


def bert_collate_fn(batch):
 max_batch_len = max(len(item["input_ids"]) for item in batch)

 batch_input_ids, batch_attention_masks, batch_labels = [], [], []

 for item in batch:
 input_ids = item["input_ids"]
 padding_len = max_batch_len - len(input_ids)

 padded_ids = input_ids + [tokenizer.pad_token_id] * padding_len
 # 新增：生成 attention_mask
 attention_mask = [1] * len(input_ids) + [0] * padding_len

 batch_input_ids.append(padded_ids)
 batch_attention_masks.append(attention_mask)
 batch_labels.append(item["label"])

 return {
 "input_ids": torch.tensor(batch_input_ids, dtype=torch.long),
 # 新增：返回 attention_mask
 "attention_mask": torch.tensor(batch_attention_masks, dtype=torch.long),
 "labels": torch.tensor(batch_labels, dtype=torch.long),
 }

2.3 构建 `TextClassifierBERT` 模型

得益于 transformers 库的高度封装，从代码实现的角度来看，新的模型结构非常简洁，一个预训练的 BERT 主干网络 + 一个线性分类头。尽管 BERT 模型内部结构极其复杂，但我们只需几行代码便可调用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


from transformers import BertModel

class TextClassifierBERT(nn.Module):
 def __init__(self, model_name, num_classes, freeze_bert=False):
 super(TextClassifierBERT, self).__init__()
 # 1. 加载预训练的BERT模型
 self.bert = BertModel.from_pretrained(model_name)
 # 2. 定义分类头
 self.classifier = nn.Linear(self.bert.config.hidden_size, num_classes)

 # 3. (可选) 冻结BERT参数
 if freeze_bert:
 for param in self.bert.parameters():
 param.requires_grad = False

 def forward(self, input_ids, attention_mask):
 # 将输入传入BERT
 outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)

 # 使用[CLS] token的输出(pooler_output)进行分类
 pooled_output = outputs.pooler_output

 # 传入分类头得到logits
 logits = self.classifier(pooled_output)
 return logits

在 __init__ 方法中，BertModel.from_pretrained(model_name) 会自动下载并加载指定名称的预训练模型权重。分类头的输入维度直接从 self.bert.config.hidden_size 获取，这是一个非常好的实践，避免了硬编码。此外提供了 freeze_bert 选项，如果为 True，则 BERT 部分的参数不会在训练中更新。这被称为“特征提取”模式，训练速度更快，但效果通常不如全量微调。实战中还可以更细粒度地“冻结”部分层（例如仅冻结 Embedding 和前几层 Transformer Block，或按层号前缀选择参数，将其 requires_grad=False），在训练速度 / 显存占用与微调效果之间做折中，这里为了示例清晰，仅展示了“全部冻结 BERT 主干”这一简单形式。而在 forward 函数中，现在接收 input_ids 和 attention_mask。BERT 模型的输出 outputs 中，outputs.pooler_output 是 [CLS] Token 对应的隐藏状态经过进一步处理后得到的向量，专门用于句子级别的任务，我们直接取用这个向量送入分类层即可。

2.4 调整 `Trainer` 与 `Predictor`

Trainer 的 _run_epoch 和 _evaluate 方法需要修改，以将 attention_mask 传递给模型。同时，保存模型的逻辑也应更新为 transformers 推荐的方式。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 在 Trainer._run_epoch 方法中
...
input_ids = batch["input_ids"].to(self.device)
attention_mask = batch["attention_mask"].to(self.device) # 新增
labels = batch["labels"].to(self.device)

outputs = self.model(input_ids=input_ids, attention_mask=attention_mask) # 修改
...

# 在 Trainer._save_checkpoint 方法中
...
# 对于transformers模型，推荐使用save_pretrained来保存
self.model.bert.save_pretrained(self.output_dir)
# 单独保存分类头
classifier_path = os.path.join(self.output_dir, "classifier.pth")
torch.save(self.model.classifier.state_dict(), classifier_path)
...

另外，别忘了在训练脚本中将 tokenizer 一并保存到同一个目录，方便推理阶段直接从该目录恢复分词器配置与词表，例如：

1
2


# 训练脚本中
tokenizer.save_pretrained(hparams["output_dir"])

Predictor 的逻辑与 LSTM 版本非常相似，同样采用分块+投票的策略。主要区别在于，现在需要为每个 chunk 创建对应的 attention_mask。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 在 Predictor.predict 方法中
...
# (分块逻辑不变)...
padded_chunks, attention_masks = [], []
for chunk in chunks:
 padding_len = max_chunk_len - len(chunk)
 padded_chunks.append(chunk + [self.tokenizer.pad_token_id] * padding_len)
 attention_masks.append([1] * len(chunk) + [0] * padding_len) # 新增

input_ids_tensor = torch.tensor(padded_chunks, dtype=torch.long).to(self.device)
attention_mask_tensor = torch.tensor(attention_masks, dtype=torch.long).to(self.device) # 新增

with torch.no_grad():
 # 将input_ids和attention_mask都传入
 outputs = self.model(input_ids=input_ids_tensor, attention_mask=attention_mask_tensor)
 preds = torch.argmax(outputs, dim=1)
...
# (投票逻辑不变)

2.5 更新训练超参数

微调 BERT 时，超参数的选择与从零训练有很大不同。学习率通常设置得非常小，例如 2e-5 到 5e-5 之间，这是因为我们希望在预训练学到的知识基础上做“微小”的调整，过大的学习率会破坏这些知识。至于训练轮次通常只需要 3-5 个轮次就足以收敛。

1
2
3
4
5
6
7
8
9


hparams = {
 "model_name": 'bert-base-uncased',
 "num_classes": len(train_dataset_raw.target_names),
 "freeze_bert": False,
 "epochs": 5, # 减少轮次
 "learning_rate": 2e-5, # 降低学习率
 "device": "cuda" if torch.cuda.is_available() else "cpu",
 "output_dir": "output_bert"
}

2.6 推理阶段资源加载

推理阶段的整体流程与 LSTM 版本保持一致，但在加载推理所需资源时有几个容易忽略的细节。训练时我们使用 save_pretrained 将 BERT 主干和 tokenizer 一并保存到 output_bert 目录，所以推理阶段不需要手动构建或加载词表，可以应该直接从该目录恢复。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


labels_path = os.path.join(hparams["output_dir"], "label_map.json")
with open(labels_path, "r", encoding="utf-8") as f:
 label_map_loaded = json.load(f)

inference_tokenizer = BertTokenizer.from_pretrained(hparams["output_dir"])

inference_model = TextClassifierBERT(
 model_name=hparams["output_dir"],
 num_classes=len(label_map_loaded),
).to(hparams["device"])

classifier_path = os.path.join(hparams["output_dir"], "classifier.pth")
inference_model.classifier.load_state_dict(
 torch.load(classifier_path, map_location=hparams["device"])
)

这里有两个关键点：

通过 BertTokenizer.from_pretrained 从输出目录一次性恢复完整的分词器配置与词表，无需手动加载独立的 vocab 文件；
TextClassifierBERT 的 model_name 也改为输出目录，从而加载微调后的 BERT 权重。

三、实验结果与分析

完成所有改造后，我们启动训练。由于 BERT 模型参数量远大于之前的模型（bert-base-uncased 约有1.1亿参数），每个 epoch 的训练时间会更长，对计算资源（特别是 GPU 显存）的要求也更高。下面是本次实验的训练日志：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


Epoch 1 [训练中]: 100%|██████████| 625/625 [01:53<00:00, 5.53it/s]
Epoch 1 [评估中]: 100%|██████████| 467/467 [00:29<00:00, 16.02it/s]
Epoch 1/5 | 训练损失: 0.4214 | 验证集准确率: 0.8738
新最佳模型已保存! Epoch: 1, 验证集准确率: 0.8738
Epoch 2 [训练中]: 100%|██████████| 625/625 [02:14<00:00, 4.64it/s]
Epoch 2 [评估中]: 100%|██████████| 467/467 [00:31<00:00, 14.84it/s]
Epoch 2/5 | 训练损失: 0.1495 | 验证集准确率: 0.8827
新最佳模型已保存! Epoch: 2, 验证集准确率: 0.8827
Epoch 3 [训练中]: 100%|██████████| 625/625 [02:18<00:00, 4.51it/s]
Epoch 3 [评估中]: 100%|██████████| 467/467 [00:31<00:00, 14.66it/s]
Epoch 3/5 | 训练损失: 0.0698 | 验证集准确率: 0.8915
新最佳模型已保存! Epoch: 3, 验证集准确率: 0.8915
Epoch 4 [训练中]: 100%|██████████| 625/625 [02:20<00:00, 4.46it/s]
Epoch 4 [评估中]: 100%|██████████| 467/467 [00:32<00:00, 14.44it/s]
Epoch 4/5 | 训练损失: 0.0404 | 验证集准确率: 0.8946
新最佳模型已保存! Epoch: 4, 验证集准确率: 0.8946
Epoch 5 [训练中]: 100%|██████████| 625/625 [02:22<00:00, 4.37it/s]
Epoch 5 [评估中]: 100%|██████████| 467/467 [00:32<00:00, 14.48it/s]
Epoch 5/5 | 训练损失: 0.0251 | 验证集准确率: 0.9032
新最佳模型已保存! Epoch: 5, 验证集准确率: 0.9032
训练完成！
Tokenizer 和标签映射 (output_bert\label_map.json) 已保存。

图 7-6 BERT 模型训练损失与验证集准确率变化曲线

我们将三个模型的最佳性能进行对比：

全连接模型 (基线)：最佳验证集准确率 ~0.8469。
LSTM 模型 (正则化后)：最佳验证集准确率 ~0.8415。
BERT 微调模型：最佳验证集准确率 ~0.9032。

结果分析:

通过日志可以看出，BERT 模型的性能远超前两个从零开始训练的模型。具体来看，BERT的优势体现在以下几点：

（1）性能上限更高：BERT 微调模型最终达到了约 90.32% 的准确率，比之前两个模型高出超过 5 个百分点，这是一个显著的提升。

（2）收敛速度快：仅仅在第一个 epoch 结束后，BERT 模型的准确率（87.38%）就已经超过了前两个模型经过 20 个 epoch 充分训练后的最佳水平。

（3）强大的上下文理解能力：BERT 的核心是 Transformer 的自注意力机制，它能够捕捉句子中任意两个词之间的依赖关系，无论它们相隔多远。使得 BERT 能够生成真正“上下文相关”的词向量，深刻理解词语在不同语境下的含义。

（4）海量预训练知识的迁移：BERT 在预训练阶段已经学习了丰富的语法、语义和世界知识。在微调时，这些知识被有效地迁移到了下游的新闻分类任务中。模型不再是一个“新生儿”，而是一个知识渊博的“专家”，只需要少量数据就能学会如何应用已有知识来完成新任务。

（5）成熟的范式：相比于需要精心设计网络结构、调整正则化策略的从零训练，BERT 的“预训练-微调”范式更加成熟和标准化。它为各种 NLP 任务提供了一个更高的起点，通过这种方式我们能够用相对少的代码和调试，就达到了出色的效果。

这个结果初看似乎与上一节“如无必要，勿增实体”的结论有所矛盾。但这并不意味着奥卡姆剃刀原理失效了，而是提醒我们要在正确的维度上应用它。当然，这并不绝对否定简单模型（如全连接或 LSTM）通过更精细的特征工程、算法优化和超参数调优，有可能在特定任务上接近甚至超越 BERT 的效果。但是，那通常需要耗费巨大的精力。相比之下，BERT 的成功揭示了“预训练-微调”范式的巨大优势。一方面它具备强大的预训练知识，BERT 不是从零学习，而是将从海量文本中学到的通用语言知识迁移到了我们的任务中，所以它对词汇和语境的理解深度远超任何从头训练的模型。另一方面它是一条更便捷的路径，我们不再需要为特定任务从头设计复杂的网络或特征，而是可以方便地在一个强大的通用模型基础上进行微调，用更少的努力达到更高的性能上限。

所以，这里的结论并非“模型越复杂越好”，而是“利用高质量的预训练模型进行微调，往往是一种在下游任务中以更少的开发精力和数据量达成更好性能的推荐方式”。与此同时，我们也必须认识到，微调所带来的便捷和高效，是建立在 BERT 等大模型在预训练阶段已经消耗了巨大计算资源和时间的基础之上的。

本章小结

综合三节的实践，我们完成了一次 NLP 文本分类任务的探索之旅。整个过程为我们提供了宝贵的实践经验，并最终指向一个现代 NLP 项目中进行模型选择与迭代的常用流程：

（1）从一个简单、快速的基线模型开始（如第一节的全连接模型）。建立基线有助于我们评估任务的难度，并为后续的优化提供一个比较标准。

（2）审慎地增加模型的复杂性。第二节的实验证明，对于特定任务，更复杂的结构（从零训练的LSTM）未必能带来性能提升，其结果恰好印证了“奥卡姆剃刀原理”。

（3）优先考虑利用高质量的预训练模型进行微调。当基线模型无法满足需求时，与其从零开始构建更复杂的模型，不如优先采用“预训练-微调”的范式。第三节的实验清晰地展示了，采用此范式通常是通往较优性能的高效路径。

整个探索过程也侧面反映了 NLP 技术的发展脉络，也提供了一个更全面、辩证的实践准则，帮助我们在未来的项目中做出更明智的技术选型。

附录——使用BERT实现中文文本情感分类

参考资料：

微调BERT模型实现文本分类

BERT文本处理——Tokenizer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from transformers import BertTokenizer

token = BertTokenizer.from_pretrained('bert-base-chinese')

out = token.batch_encode_plus(
 batch_text_or_text_pairs=['今天我要努力学习自然语言处理', '明天我要认真学习金融学'],
 truncation=True,
 padding='max_length',
 max_length=15,
 return_tensors='pt',
 )

for i in out:
 print(i,out[i].shape)

print(token.decode(out['input_ids'][0]))
print(token.decode(out['input_ids'][1]))

输出结果如下所示：

1
2
3
4
5


input_ids torch.Size([2, 15])
token_type_ids torch.Size([2, 15])
attention_mask torch.Size([2, 15])
[CLS] 今 天 我 要 努 力 学 习 自 然 语 言 处 [SEP]
[CLS] 明 天 我 要 认 真 学 习 金 融 学 [SEP] [PAD] [PAD]

未微调时使用 text-classification pipeline

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from transformers import BertTokenizer, BertForSequenceClassification, pipeline

model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=3)
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

classifier = pipeline('text-classification', model=model, tokenizer=tokenizer)

output = classifier('我今天心情很好')
print(output)

output = classifier('你好，我是AI助手')
print(output)

output = classifier('我今天很生气')
print(output)

输出结果如下所示：

1
2
3
4
5
6


Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-chinese and are newly initialized: ['classifier.bias', 'classifier.weight']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
Device set to use cuda:0
[{'label': 'LABEL_2', 'score': 0.5192456841468811}]
[{'label': 'LABEL_2', 'score': 0.502333402633667}]
[{'label': 'LABEL_2', 'score': 0.47641533613204956}]

微调后使用 text-classification pipeline

首先我们需要通过同样的方法来构建基础模型。然后通过语料样本来进行微调。这里我们使用lansinuote/ChnSentiCorp数据集。

lansinuote/ChnSentiCorp数据集是一个用于中文情感分析的数据集。该数据集汇集了来自网络平台的多样化评论数据，主要覆盖三大领域：酒店住宿体验、笔记本电脑使用评价以及书籍阅读感受。数据集分为训练集、验证集和测试集。其中，训练集包含约 9600 条数据，验证集和测试集各包含约 1200 条数据。每条数据包含一段评论文本和对应的情感标签，情感标签通常为二分类（如好评、差评），部分版本可能包含中性标签。

将lansinuote/ChnSentiCorp数据集下载之后，使用模型的分词器对其进行处理，将处理之后的数据放入模型进行训练，我们仅训练1轮看看效果。训练完之后再测试集上进行预测查看训练效果。并将模型保存。实现代码如下。

模型预训练过程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import re

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
mode = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=3)
dataset = load_dataset('lansinuote/ChnSentiCorp')


def clean_text(text):
 text = re.sub(r'[^\w\s]+', ' ', text)
 text = text.strip()
 return text

dataset = dataset.map(lambda x: {'text': clean_text(x['text']), 'label': x['label']})

def tokenize_function(examples):
 return tokenizer(examples['text'], padding='max_length', truncation=True, max_length=128)

encoded_dataset = dataset.map(tokenize_function, batched=True)

training_args = TrainingArguments(
 output_dir='./results',
 num_train_epochs=1,
 per_device_train_batch_size=32,
 per_device_eval_batch_size=32,
 eval_strategy='epoch',
 logging_dir='./logs'
)

trainer = Trainer(
 model=mode,
 args=training_args,
 train_dataset=encoded_dataset['train'],
 eval_dataset=encoded_dataset['validation'],
)
trainer.train()

trainer.evaluate(encoded_dataset['test'], metric_key_prefix='eval')
mode.save_pretrained('./sentiment_model')
tokenizer.save_pretrained('./sentiment_model')

保存模型后进行情感分类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from transformers import BertTokenizer, BertForSequenceClassification, pipeline

mode_dir = './sentiment_model'

model = BertForSequenceClassification.from_pretrained(mode_dir)
tokenizer = BertTokenizer.from_pretrained(mode_dir)

classifier = pipeline('text-classification', model=model, tokenizer=tokenizer)

output = classifier('我今天心情很好')
print(output)

output = classifier('你好，我是AI助手')
print(output)

output = classifier('我今天很生气')
print(output)

输出结果如下所示：

1
2
3
4


Device set to use cuda:0
[{'label': 'LABEL_1', 'score': 0.7787742614746094}]
[{'label': 'LABEL_0', 'score': 0.5039134621620178}]
[{'label': 'LABEL_0', 'score': 0.9373114109039307}]

效果明显好了很多。

基于 LSTM 的文本分类

Wed, 25 Mar 2026 17:34:25 -0800

基于 LSTM 的文本分类

在上一节，我们实现了一个基于全连接层的文本分类模型。该模型虽然简单有效，但它的核心是将所有词元的特征向量进行平均池化，这本质上是一种“词袋”模型。这种方法的一个显著局限是它忽略了文本中词语的顺序，而语序在多数 NLP 任务中是很重要的。那么，对于文本分类任务，捕捉序列信息是否总能带来性能提升呢？为了验证这一点，我们自然会想到循环神经网络（RNN）及其变体，如LSTM。在第三章第二节中我们已经学习了 LSTM 的原理。理论上，它能够通过处理序列信息来捕捉更丰富的语义。本节将进行一次实验，我们将上一节的全连接模型改造为基于LSTM的模型，来探索在本新闻分类任务上，序列建模是否会比简单的词袋模型更有效。

一、从“词袋”到序列建模

先回顾一下基线模型的主要操作：

（1）词嵌入：将输入的 token_ids ([batch_size, seq_len]) 转换为词向量 embedded ([batch_size, seq_len, embed_dim])。

（2）特征提取：通过几层全连接网络，将每个词向量独立地映射到更高维的特征空间，得到 token_features ([batch_size, seq_len, hidden_dim])。

（3）掩码平均池化：为了处理变长序列，将所有 token_features 沿 seq_len 维度进行求和，再除以真实长度，得到一个代表整句话的向量 pooled_features ([batch_size, hidden_dim])。

（4）分类：将 pooled_features 输入最后的分类层，得到最终预测。

这个流程的瓶颈在第三步。平均池化操作将序列信息压缩成一个向量，这可能导致词序信息的丢失。

与之相对，LSTM 网络通过其内部的循环结构和门控机制，能够逐个处理序列中的词元，并持续更新一个内部状态（记忆）。这个状态在每个时间步都会编码从序列开始到当前位置的所有信息。因此，当 LSTM 处理完整个序列后，它最终的隐藏状态理论上包含了对整个句子序列更丰富的语义表示，这有可能比简单的词向量平均更能捕捉句子的深层含义。

二、代码修改实践

将基线模型改造为 LSTM 模型，主要涉及这三个部分的修改：数据处理、模型结构和推理逻辑。

本节完整代码

2.1 改造 `collate_fn` 以提供序列长度

为了让 LSTM 能够高效地处理被填充（Padding）过的变长序列，需要使用 torch.nn.utils.rnn.pack_padded_sequence 函数。该函数要求在输入批次中明确提供每个样本在填充前的真实长度。所以，我们应该修改 collate_fn 函数，让它在返回 token_ids 和 labels 的同时，也返回一个包含该批次中每个序列真实长度的张量 lengths。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


def collate_fn(batch):
 max_batch_len = max(len(item["token_ids"]) for item in batch)

 batch_token_ids, batch_labels, batch_lengths = [], [], []

 for item in batch:
 token_ids = item["token_ids"]
 # 新增：记录真实长度
 lengths = len(token_ids)
 padding_len = max_batch_len - lengths

 padded_ids = token_ids + [0] * padding_len
 batch_token_ids.append(padded_ids)
 batch_labels.append(item["label"])
 # 新增：将长度加入列表
 batch_lengths.append(lengths)

 return {
 "token_ids": torch.tensor(batch_token_ids, dtype=torch.long),
 "labels": torch.tensor(batch_labels, dtype=torch.long),
 # 新增：返回长度张量
 "lengths": torch.tensor(batch_lengths, dtype=torch.long),
 }

2.2 构建 `TextClassifierLSTM` 模型

这是本次优化的主要内容。我们将原来的 TextClassifier 替换为一个新的 TextClassifierLSTM 模型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class TextClassifierLSTM(nn.Module):
 def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes,
 n_layers=1, dropout=0.3, bidirectional=False):
 super(TextClassifierLSTM, self).__init__()
 self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)

 self.lstm = nn.LSTM(
 input_size=embed_dim,
 hidden_size=hidden_dim,
 num_layers=n_layers,
 dropout=dropout,
 bidirectional=bidirectional,
 batch_first=True # 关键参数：输入和输出张量的维度为 (batch, seq, feature)
 )

 num_directions = 2 if bidirectional else 1
 self.classifier = nn.Linear(hidden_dim * num_directions, num_classes)

 def forward(self, token_ids, lengths):
 embedded = self.embedding(token_ids)

 # 1. 打包序列
 packed_embedded = nn.utils.rnn.pack_padded_sequence(
 embedded,
 lengths.cpu(), # 长度必须在CPU上
 batch_first=True,
 enforce_sorted=False
 )

 # 2. LSTM 前向传播
 # hidden 和 cell 的形状: [n_layers * num_directions, batch_size, hidden_dim]
 packed_output, (hidden, cell) = self.lstm(packed_embedded)

 # 3. 提取最终隐藏状态用于分类
 if self.lstm.bidirectional:
 # 拼接最后一个时间步的前向和后向的隐藏状态
 # hidden[-2,:,:] 是前向的最后一个隐藏状态
 # hidden[-1,:,:] 是后向的最后一个隐藏状态
 hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)
 else:
 # 只取最后一层的最后一个隐藏状态
 hidden = hidden[-1,:,:]

 # 4. 分类
 logits = self.classifier(hidden)
 return logits

模型解析:

（1）__init__：

除了词嵌入层 nn.Embedding 和分类层 nn.Linear，核心是一个 nn.LSTM 层。
增加几个 LSTM 相关的超参数：n_layers (LSTM层数), dropout (层间丢弃率), bidirectional (是否使用双向LSTM)。
batch_first=True 是一个重要的设置，它让 LSTM 接受 [batch_size, seq_len, feature_dim] 形状的输入，与 DataLoader 的输出保持一致，简化了代码。
分类层的输入维度需要根据 bidirectional 的值来动态确定。如果是双向的，隐藏层维度会加倍。
在 PyTorch 的 nn.LSTM 中，dropout 只在 n_layers > 1 时于层间生效；当仅 1 层时该参数不会起作用。若使用单层 LSTM，可将 dropout 设为 0.0（或保留任意值，效果一致），避免造成误解。

（2）forward：

forward 函数现在额外接收 lengths 参数。
打包 (Packing)：pack_padded_sequence 是处理填充序列的关键。它会将一个填充过的批次数据（例如，多个句子被填充到相同长度）压缩成一个更紧凑的表示，LSTM 只需对真实的、非填充部分进行计算，大大提高了效率和准确性。
最终状态提取：LSTM 的输出 hidden 张量包含了所有层在最后一个时间步的隐藏状态。我们通常取最后一层（对于单向 LSTM 是 hidden[-1,:,:]）作为整个序列的语义表示。如果是双向 LSTM，则需要拼接前向和后向的最终隐藏状态。
最后，将这个代表序列的 hidden 向量送入分类器。

2.3 调整 `Trainer` 和 `Predictor`

由于模型 forward 函数的输入签名发生了变化，我们需要对 Trainer 和 Predictor 进行微调，以确保 lengths 张量被正确传递。

1. Trainer 修改: 在 _run_epoch 和 _evaluate 方法中，从 batch 字典中取出 lengths，并将其传递给 self.model。

1
2
3
4
5
6
7
8


# 在 Trainer._run_epoch 方法中
...
token_ids = batch["token_ids"].to(self.device)
labels = batch["labels"].to(self.device)
lengths = batch["lengths"]

outputs = self.model(token_ids, lengths)
...

（_evaluate 方法同理）

2. Predictor 修改: Predictor 在处理单个文本时，也需要模拟批处理的逻辑：对文本分块后，手动计算每个块的长度，并进行填充，然后将 chunk_tensors 和 length_tensors 一同传入模型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# 在 Predictor.predict 方法中
...
# (文本分块逻辑不变) ...
chunks = [...]

# 手动计算长度并进行填充
chunk_lengths = [len(c) for c in chunks]
max_chunk_len = max(chunk_lengths) if chunk_lengths else 0

padded_chunks = []
for chunk in chunks:
 padding_len = max_chunk_len - len(chunk)
 padded_chunks.append(chunk + [0] * padding_len)

if not padded_chunks:
 return "无法预测（文本过短）"

chunk_tensors = torch.tensor(padded_chunks, dtype=torch.long).to(self.device)
length_tensors = torch.tensor(chunk_lengths, dtype=torch.long) # 长度在CPU上

with torch.no_grad():
 outputs = self.model(chunk_tensors, length_tensors)
 preds = torch.argmax(outputs, dim=1)
...

2.4 更新训练入口代码

最后一步，更新用于启动训练的单元格。我们需要：

（1）为 LSTM 添加新的超参数（n_layers, dropout, bidirectional）。

（2）实例化新的 TextClassifierLSTM 模型。

（3）（可选）为新的模型实验设置一个独立的输出目录，如 "output_lstm"。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import torch

hparams = {
 "vocab_size": len(tokenizer),
 "embed_dim": 128,
 "hidden_dim": 256,
 "num_classes": len(train_dataset_raw.target_names),
 "n_layers": 2, # 新增
 "dropout": 0, # 新增：此处显式设为 0，当前不启用 Dropout
 "bidirectional": True, # 新增
 "epochs": 20,
 "learning_rate": 0.001,
 "device": "cuda" if torch.cuda.is_available() else "cpu",
 "output_dir": "output_lstm" # 修改输出目录
}

# 实例化新模型
model = TextClassifierLSTM(
 vocab_size=hparams["vocab_size"],
 embed_dim=hparams["embed_dim"],
 hidden_dim=hparams["hidden_dim"],
 num_classes=hparams["num_classes"],
 n_layers=hparams["n_layers"],
 dropout=hparams["dropout"],
 bidirectional=hparams["bidirectional"]
).to(hparams["device"])

# (后续代码不变)

完成以上修改后，重新运行整个 Notebook，即可训练一个能够处理序列信息的 LSTM 模型。接下来，我们来对比它与基线模型的性能，并分析序列建模在本次任务中的实际效果。

2.5 实验结果与分析

在分别运行了基线的全连接模型和我们新构建的LSTM模型后（均未加正则化策略），我们得到了如下的性能数据：

全连接模型 (基线)：最终验证集最佳准确率约为 0.8469。
LSTM 模型：最终验证集最佳准确率约为 0.8143。

图 7-4 LSTM 模型训练损失与验证集准确率变化曲线

结果分析:

显然结果并不符合我们的预期，理论上更能捕捉序列信息的 LSTM 模型，在本次新闻分类任务上的表现反而劣于简单的全连接模型。这个发现说明模型的复杂性与任务的实际需求应该匹配。值得一提的是，本次对比实验并未严格控制固定随机数种子，所以每次运行的结果会存在细微的差别。然而，一个稳定的现象是，引入序列建模的 LSTM 并未带来性能提升，其结果反而总是比简单的全连接模型低 ~2% 左右，足以让我们得出以下结论。

出现这种结果的可能原因有两点：

（1）任务对语序相对不敏感：在目前的数据规模、从零开始训练模型的前提下，这个新闻分类任务在很大程度上依赖于关键词。例如，看到 “Jesus”、“God” 很可能属于宗教类；看到 “Graphics”、“Monitor” 很可能属于计算机图形类。全连接模型本质上是一个高效的“词袋”模型，非常擅长捕捉这类强特征词的存在与否。对于这个特定实验设置来说，“有哪些词”远比“这些词的顺序”更重要。LSTM 为学习语序付出的额外努力，在这里并没有转化为实际的性能优势。

（2）模型复杂性与过拟合：LSTM 模型比简单的全连接网络复杂得多，拥有更多的参数。虽然它理论上能学习到更复杂的模式，但也更容易在数据量不够大的情况下陷入过拟合。从训练日志中可以看到，普通 LSTM 的训练损失已经非常低，但验证集准确率却不高，这是过拟合症状。模型过于“记住”了训练集中的特定句子结构，而没有学到普适的规律。

三、过拟合解决方案与效果对比

基础 LSTM 模型效果不佳的一个可能原因是 过拟合。在第一节的末尾，我们介绍了三种简单有效的正则化方法分别是提前停止、随机Token遮盖和Dropout。

现在，我们将这三种方法组合应用到新的 LSTM 模型上，观察它们的综合效果。

3.1 随机Token遮盖

这是一种数据增强技术。我们在 TextClassificationDataset 的基础上创建一个子类，在 __getitem__ 方法中，对训练样本的 token_ids 进行随机替换。具体来说，以一定概率（例如10%）将部分词元替换为 <UNK> 对应的 ID。使得模型不能过度依赖个别特征词，而是要从更广的上下文中学习语义，从而增强泛化能力。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import random

class TextClassificationDatasetWithMasking(TextClassificationDataset):
 def __init__(self, texts, labels, tokenizer, max_len=128, is_train=False, mask_prob=0.1):
 super().__init__(texts, labels, tokenizer, max_len)
 self.is_train = is_train
 self.mask_prob = mask_prob
 self.unk_token_id = tokenizer.token_to_id.get("<UNK>", 1)

 def __getitem__(self, idx):
 # 关键：创建副本，避免修改原始数据
 item = super().__getitem__(idx).copy()

 if self.is_train:
 token_ids = item['token_ids']
 masked_token_ids = []
 for token_id in token_ids:
 # 不遮盖PAD (ID=0)
 if token_id != 0 and random.random() < self.mask_prob:
 masked_token_ids.append(self.unk_token_id)
 else:
 masked_token_ids.append(token_id)
 item['token_ids'] = masked_token_ids

 return item

在 TextClassificationDatasetWithMasking 的 __getitem__ 方法中，有一个非常关键的细节，item = super().__getitem__(idx).copy()。必须使用 .copy() 方法来创建数据的副本。

如果没有 .copy()，__getitem__ 中的修改将会永久地改变原始数据集。这会导致在第二个训练周期（Epoch）时，模型看到的是已经被第一次随机遮盖过的数据，并在此基础上进行二次遮盖，如此循环往复，最终导致有效信息完全丢失。数据增强必须保证每一轮都是在干净的原始数据上进行的独立操作。

3.2 提前停止 (Early Stopping)

提前停止是一种简单而高效的正则化策略。其核心思想是在训练过程中持续监控模型在验证集上的性能。如果验证集准确率（或损失）连续 N 个轮次（N 称为“耐心值” patience）没有超过历史最佳水平，就认为模型已经达到了最佳点或开始过拟合，此时应提前终止训练。我们在 Trainer 类的基础上创建一个子类，重写 train 方法以实现该逻辑。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


import os
import json

class TrainerWithEarlyStopping(Trainer):
 def __init__(self, model, optimizer, criterion, train_loader, valid_loader, device, output_dir=".", patience=3):
 super().__init__(model, optimizer, criterion, train_loader, valid_loader, device, output_dir)
 self.patience = patience
 self.epochs_no_improve = 0

 def train(self, epochs, tokenizer, label_map):
 for epoch in range(epochs):
 avg_loss = self._run_epoch(epoch)
 val_accuracy = self._evaluate(epoch)

 print(f"Epoch {epoch+1}/{epochs} | 训练损失: {avg_loss:.4f} | 验证集准确率: {val_accuracy:.4f}")

 current_best = self.best_accuracy
 self._save_checkpoint(epoch, val_accuracy)

 if self.best_accuracy > current_best:
 self.epochs_no_improve = 0
 else:
 self.epochs_no_improve += 1

 if self.epochs_no_improve >= self.patience:
 print(f"\n提前停止于 Epoch {epoch+1}，因为验证集准确率连续 {self.patience} 轮未提升。")
 break

 print("\n训练完成！")
 # ... (保存词典和标签映射)

3.3 实验与对比

最后，我们将所有正则化策略整合起来，实例化相应的数据集、模型和训练器，并启动训练。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# 1. 创建应用了随机遮盖的数据集
train_dataset_reg = TextClassificationDatasetWithMasking(
 ..., is_train=True, mask_prob=0.1
)
train_loader_reg = DataLoader(train_dataset_reg, ..., collate_fn=collate_fn) # 继续使用前面改造过的 collate_fn，以便返回 lengths

# 2. 实例化模型，并启用 Dropout
model_reg = TextClassifierLSTM(
 ...,
 dropout=0.3, # 启用 Dropout
 ...
).to(device)

# 3. 使用带提前停止功能的训练器
trainer_reg = TrainerWithEarlyStopping(
 model_reg,
 ...,
 output_dir="output_lstm_regularized",
 patience=3
)

# 启动训练
trainer_reg.train(...)

完成训练后，可以通过比较两个实验的输出日志，来分析正则化带来的效果：

训练是否提前停止？ 如果是，说明模型可能在更早的阶段就已收敛。
最终验证集准确率：对比 output_lstm 和 output_lstm_regularized 中 best_model.pth 对应的验证集准确率，正则化版本是否取得了更好的泛化性能？
训练损失与验证准确率曲线：观察两个实验的日志，正则化版本的验证集准确率曲线是否更平滑，或者与训练损失的差距是否更小？这些都是过拟合得到缓解的迹象。

3.4 最终效果分析

在应用了这三种策略后，我们的 LSTM 模型取得了约 0.8415 的最佳验证集准确率。从下面的训练日志中可以看到，模型在第16轮达到了最佳性能，并在第19轮成功触发了“提前停止”策略，避免了不必要的训练和潜在的过拟合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


Epoch 16 [训练中]: 100%|██████████| 224/224 [00:06<00:00, 33.60it/s]
Epoch 16 [评估中]: 100%|██████████| 169/169 [00:01<00:00, 97.13it/s]
Epoch 16/20 | 训练损失: 0.0206 | 验证集准确率: 0.8415
新最佳模型已保存! Epoch: 16, 验证集准确率: 0.8415
Epoch 17 [训练中]: 100%|██████████| 224/224 [00:06<00:00, 32.80it/s]
Epoch 17 [评估中]: 100%|██████████| 169/169 [00:01<00:00, 94.98it/s]
Epoch 17/20 | 训练损失: 0.0176 | 验证集准确率: 0.8243
Epoch 18 [训练中]: 100%|██████████| 224/224 [00:07<00:00, 31.27it/s]
Epoch 18 [评估中]: 100%|██████████| 169/169 [00:01<00:00, 96.61it/s]
Epoch 18/20 | 训练损失: 0.0172 | 验证集准确率: 0.8175
Epoch 19 [训练中]: 100%|██████████| 224/224 [00:06<00:00, 33.10it/s]
Epoch 19 [评估中]: 100%|██████████| 169/169 [00:01<00:00, 95.57it/s]
Epoch 19/20 | 训练损失: 0.0136 | 验证集准确率: 0.8066

提前停止于 Epoch 19，因为验证集准确率连续 3 轮未提升。

训练完成！
词典 (output_lstm_regularized\vocab.json) 和标签映射 (output_lstm_regularized\label_map.json) 已保存。

图 7-5 正则化 LSTM 模型训练损失与验证集准确率变化曲线

这个结果展示了正则化策略的价值：

相比于无正则化的LSTM（~0.8143）：性能得到了明显提升。这证明我们之前的判断是正确的——基础 LSTM 模型的一个主要问题就是过拟合。通过数据增强、提前停止和层间Dropout的组合，有效地抑制了模型对训练数据的“死记硬背”，使它学习到了更具泛化能力的模式。
- 随机 Token 遮盖强迫模型不能过度依赖训练集中少数几个“明星”关键词（例如特定作者），而是要学会识别更广泛、更多样化的关键词组合来做出判断，从而提升模型的健壮性和泛化能力。
- 提前停止则像一个“安全阀”，在模型性能达到巅峰并即将开始下滑（过拟合）的时刻及时终止了训练，锁定了最佳的模型状态。
- Dropout在多层 LSTM 中，会对除最后一层外各层的输出施加随机丢弃（dropout），相当于在层与层之间随机“关闭”部分神经元连接，破坏可能形成的“共适应”关系，从而增强模型的独立特征学习能力。
相比于全连接模型（~0.8469）：经过正则化后，LSTM模型的性能已经非常接近，但仍然略逊于更简单的基线模型。再次证明了对于这个特定的、以关键词为驱动的新闻分类任务，一个高效的“词袋”模型已经足够强大。试图用更复杂的序列模型来捕捉此处并不关键的语序信息，即使在组合了多种正则化策略后，也难以带来超越性的优势。

这个系列的实验也印证了著名的“奥卡姆剃刀原理”——如无必要，勿增实体。在模型选择上，我们应该从一个基线开始，逐步增加复杂性，并通过实验去验证每一步改动是否真的带来了收益。

文本分类简单实现

Wed, 25 Mar 2026 16:34:25 -0800

文本分类简单实现

一、文本分类任务概述

文本分类是 NLP 中常见的任务之一，它的目标是将给定的文本自动分配到一个或多个预定义的类别中。这项技术的实际应用广泛，例如情感分析可以判断商品评价或电影评论的情感倾向是正面、负面还是中性；新闻分类能够将新闻报道自动归入体育、财经、科技或娱乐等不同频道；在智能客服或语音助手中，意图识别技术用于判断用户输入的指令属于查询天气还是播放音乐等特定意图；而垃圾邮件过滤则能自动识别并拦截收件箱中的垃圾邮件，净化沟通环境。

在理论篇的第二章中，我们已经学习了如何将文本进行分词，并通过词向量技术将其转换为模型可以理解的数值形式。本节将在此基础上，以一个经典的新闻分类任务为例，详细讲解如何从零开始，一步步构建、训练和评估一个用于文本分类的深度学习模型。这个过程将涵盖数据处理、模型设计、训练循环、推理预测等所有核心环节。

二、NLP 项目通用流程

无论是文本分类，还是其他更复杂的 NLP 任务，深度学习的解决方案通常遵循一个标准化的项目流程。可以概括为以下几个核心模块：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph LR
 A[1. 数据准备] --> B[2. 模型构建]
 B --> C[3. 定义损失与优化器]

 subgraph "训练循环 (Training Loop)"
 D[4. 迭代训练] --> E[5. 模型评估]
 E --> F{6. 是否更优?}
 F -- 是/Yes --> G[7. 保存模型]
 F -- 否/No --> D
 G --> D
 end

 C --> D

这个流程是搭建深度学习应用的通用范式，是一套标准化、可复用的模板。理解并掌握这套流程，比单纯实现某个模型更为重要。在接下来的内容中，我们将按照这个流程，将各个模块封装成独立的类，构建一个更规范、更易于维护和扩展的项目。

三、新闻文本分类代码实践

本节完整代码

本节将使用 scikit-learn 库中的 20 Newsgroups 数据集，这是一个包含约20000篇新闻文档、近似均衡分布在20个不同新闻组（类别）的集合。

3.1 模块化设计思路

在开始编写具体代码之前，更重要的步骤是“设计”。一个原则是，要先想清楚每个模块的输入和输出是什么。

数据模块的输出是什么？ -> 模型需要的“词元ID序列” (token_ids) 张量和“标签ID” (label_ids) 张量。
模型的输入是什么？ -> 数据模块的输出。
模型的输出是什么？ -> 每个类别的置信度。

如果对数据处理感到困惑，不妨先从模型定义开始。一旦我们清晰地定义了模型 forward 函数需要的输入（例如，ID序列），数据处理阶段的目标就变得很明确了，只需要把原始文本处理成模型所需的格式。

3.2 步骤一：数据解析与加载

3.2.1 数据加载

首先，加载scikit-learn提供的原始数据集。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from sklearn.datasets import fetch_20newsgroups

# 为了方便演示，只选择4个类别
categories = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med']
train_dataset_raw = fetch_20newsgroups(subset='train', categories=categories, shuffle=True, random_state=42)
test_dataset_raw = fetch_20newsgroups(subset='test', categories=categories, shuffle=True, random_state=42)

sample = {
 "text_preview": train_dataset_raw.data[0][:200],
 "label": train_dataset_raw.target_names[train_dataset_raw.target[0]],
}
sample

输出如下：

1
2


{'text_preview': 'From: sd345@city.ac.uk (Michael Collier)\nSubject: Converting images to HP LaserJet III?\nNntp-Posting-Host: hampton\nOrganization: The City University\nLines: 14\n\nDoes anyone know of a good way (standard',
 'label': 'comp.graphics'}

3.2.2 数据探索与可视化

在进行任何复杂的预处理之前，对数据进行探索性分析是很重要且必要的。这有助于我们理解数据特性，从而做出更合理的设计决策。

（1）文本长度分布：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


import matplotlib.pyplot as plt
import re

# 为了进行探索，先定义一个简单的分词函数
def basic_tokenize(text):
 text = text.lower()
 text = re.sub(r"[^a-z0-9(),.!?\'`]", " ", text)
 text = re.sub(r"([,.!?\'`])", r" \1 ", text)
 tokens = text.strip().split()
 return tokens

# 计算每篇文档的词元数量
train_text_lengths = [len(basic_tokenize(text)) for text in train_dataset_raw.data]

plt.figure(figsize=(10, 6))
plt.hist(train_text_lengths, bins=50, alpha=0.7, color='blue')
plt.title('Distribution of Text Lengths in Training Data')
plt.xlabel('Number of Tokens')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()

图 7-1 训练集文本长度分布

（2）词频分布：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


from collections import Counter
import numpy as np

# 计算所有词元的频率
word_counts = Counter()
for text in train_dataset_raw.data:
 word_counts.update(basic_tokenize(text))

# 获取频率并按降序排序
frequencies = sorted(word_counts.values(), reverse=True)
# 生成排名
ranks = np.arange(1, len(frequencies) + 1)

# 绘制对数坐标图
plt.figure(figsize=(10, 6))
plt.loglog(ranks, frequencies)
plt.title('Rank vs. Frequency (Log-Log Scale)')
plt.xlabel('Rank (Log)')
plt.ylabel('Frequency (Log)')
plt.grid(True)
plt.show()

图 7-2 词频-排名对数图

通过数据分析可以发现，图 7-1 的文本长度分布直方图显示大部分文本的长度集中在较短的区间，但仍存在少量长度非常长的“异常值”，说明简单的直接截断策略可能会丢失过多信息。除此之外，如图 7-2 的对数坐标图所示，词频分布呈现出自然语言中典型的齐夫定律（Zipf’s Law）现象，即少数高频词占据了绝大多数的出现次数，而大量词汇构成了长长的“尾巴”，其出现频率极低。

3.2.3 Tokenizer 封装

接下来，我们创建一个 Tokenizer（分词器）类来负责所有与分词、词典构建和 ID 转换相关的任务，它封装了与数据探索时相同的分词逻辑并增加了 ID 转换等功能。其中 _tokenize_text 方法实现了一套基于正则表达式的分词策略，先将文本转为小写，通过 re.sub 移除非字母、数字和基本标点之外的字符，为了确保标点符号能被作为独立的词元，在它们周围添加空格，最后按空格切分文本得到词元列表。在词典构建方面，通过遍历所有训练文本统计词频，并过滤掉出现次数过少的低频词以减少词典规模和噪声，同时词典初始化时会预设两个特殊的 Token，即用于填充的 <PAD>（ID 为 0）和用于表示未登录词的 <UNK>（ID 为 1）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Tokenizer:
 def __init__(self, vocab):
 self.vocab = vocab
 self.token_to_id = {token: idx for token, idx in self.vocab.items()}

 @staticmethod
 def _tokenize_text(text):
 text = text.lower()
 text = re.sub(r"[^a-z0-9(),.!?\\'`]", " ", text)
 text = re.sub(r"([,.!?\\'`])", r" \\1 ", text)
 tokens = text.strip().split()
 return tokens

 def convert_tokens_to_ids(self, tokens):
 return [self.token_to_id.get(token, self.vocab["<UNK>"]) for token in tokens]

 def tokenize(self, text):
 return self._tokenize_text(text)

 def __len__(self):
 return len(self.vocab)

3.2.4 Tokenizer 与词典构建

基于前面对数据的分析，现在可以正式构建词典和 Tokenizer。词典将只包含在训练集中出现超过 min_freq 次的词元。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def build_vocab_from_counts(word_counts, min_freq=5):
 vocab = {"<PAD>": 0, "<UNK>": 1}
 for word, count in word_counts.items():
 if count >= min_freq:
 vocab[word] = len(vocab)
 return vocab

# 使用上一步计算出的word_counts来构建词典
vocab = build_vocab_from_counts(word_counts, min_freq=5)
tokenizer = Tokenizer(vocab)

{"vocab_size": len(tokenizer)}

输出如下：

1

{'vocab_size': 10983}

3.2.5 如何处理长文本？

在数据探索中能够发现，20 Newsgroups 数据集中存在大量超长文本，有的甚至超过1万个词元。而大部分深度学习模型（尤其是非 Transformer 模型）都难以处理过长的序列，直接输入会导致内存溢出和计算效率低下。而简单的截断会丢失大量文本末尾的信息，可能会导致关键信息丢失。

一个更好的方法是将一篇长文档切分成多个固定长度、且有部分重叠的“文本块”（Chunks）。例如，一篇 1000 词的文档若按 max_len=128、overlap=26 的方式进行切分，此时第一个块会包含 words[0:128]，第二个块则顺延为 words[102:230]（128-26=102），并以此类推完成整个文档的切分。这样做有两大好处，一方面通过信息保全完整地利用了整篇文章的信息；另一方面则带来了数据增强的效果，将一篇长文档变成了多条训练样本，增加了训练数据量。

3.2.6 封装 `Dataset` 和 `DataLoader`

TextClassificationDataset 负责的核心逻辑是接收原始文本，调用 tokenizer 进行 ID 化，并应用 滑窗分割 策略处理长文本。如果文本超过 max_len，则会进行切分。代码中的 stride 被设置为 max_len 的 80%，意味着每个文本块之间有20%的重叠，这有助于保持上下文信息的连续性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import torch
import torch.nn as nn
from torch.utils.data import Dataset
from tqdm import tqdm

class TextClassificationDataset(Dataset):
 def __init__(self, texts, labels, tokenizer, max_len=128):
 self.tokenizer = tokenizer
 self.max_len = max_len
 self.processed_data = []

 for text, label in tqdm(zip(texts, labels), total=len(labels)):
 token_ids = self.tokenizer.convert_tokens_to_ids(self.tokenizer.tokenize(text))

 # 滑窗分割逻辑
 if len(token_ids) <= self.max_len:
 self.processed_data.append({"token_ids": token_ids, "label": label})
 else:
 stride = max(1, int(self.max_len * 0.8))
 for i in range(0, len(token_ids) - self.max_len + 1, stride):
 chunk = token_ids[i:i+self.max_len]
 self.processed_data.append({"token_ids": chunk, "label": label})

 def __len__(self):
 return len(self.processed_data)

 def __getitem__(self, idx):
 return self.processed_data[idx]

接着，定义 collate_fn 函数，它负责将一个批次内长短不一的样本，通过填充操作（使用 <PAD> 对应的ID 0），打包成形状规整的张量，以便模型进行批处理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


def collate_fn(batch):
 max_batch_len = max(len(item["token_ids"]) for item in batch)

 batch_token_ids, batch_labels = [], []

 for item in batch:
 token_ids = item["token_ids"]
 padding_len = max_batch_len - len(token_ids)

 padded_ids = token_ids + [0] * padding_len
 batch_token_ids.append(padded_ids)
 batch_labels.append(item["label"])

 return {
 "token_ids": torch.tensor(batch_token_ids, dtype=torch.long),
 "labels": torch.tensor(batch_labels, dtype=torch.long),
 }

使用我们创建的 Dataset 和 collate_fn 来实例化训练和验证数据加载器 DataLoader：

1
2
3
4
5
6
7
8
9


from torch.utils.data import DataLoader

train_dataset = TextClassificationDataset(train_dataset_raw.data, train_dataset_raw.target, tokenizer)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, collate_fn=collate_fn)

valid_dataset = TextClassificationDataset(test_dataset_raw.data, test_dataset_raw.target, tokenizer)
valid_loader = DataLoader(valid_dataset, batch_size=32, collate_fn=collate_fn)

{"train_samples": len(train_dataset), "valid_samples": len(valid_dataset), "batch_size": 32}

输出如下：

1

{'train_samples': 7142, 'valid_samples': 5408, 'batch_size': 32}

3.3 步骤二：模型构建

3.3.1 模型结构设计

在编写模型代码前，先梳理清楚数据的“变形记”，也就是张量形状在网络中如何变化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


Input:
 token_ids (词元ID序列): [batch_size, seq_len]
 |
 V
nn.Embedding(padding_idx=0)
 |
 V
 embedded: [batch_size, seq_len, embed_dim]
 |
 V
nn.Linear(embed_dim, hidden_dim*2) -> nn.ReLU -> nn.Linear(hidden_dim*2, hidden_dim*4) -> nn.ReLU
 |
 V
 token_features: [batch_size, seq_len, hidden_dim*4]
 |
 V
Masked Average Pooling (关键操作)
 |
 V
 pooled_features: [batch_size, hidden_dim*4] <-- seq_len维度被聚合掉了
 |
 V
nn.Linear (分类层)
 |
 V
Output:
 logits: [batch_size, num_classes]

3.3.2 掩码平均池化

池化（Pooling）的目的是将一个序列的特征（[seq_len, hidden_dim]）聚合成一个代表整条序列的向量（[hidden_dim]），但简单的平均池化会受到填充 <PAD> 的影响从而导致语义偏差。举例来说，假设一个批次有 2 个句子且最大长度为 4，其中句子 A 的真实长度为 4（表示为 [v_I, v_love, v_NLP, v_too]），而句子 B 的真实长度为 2（表示为 [v_NLP, v_rocks, v_PAD, v_PAD]）。掩码池化的计算过程如下：

（1）创建掩码：mask = [[1, 1, 1, 1], [1, 1, 0, 0]]

（2）向量置零：将句子 B 中 <PAD> 对应的向量 v_PAD 乘以 0，使其变为零向量。

（3）向量求和：句子 A 求和得到 sum_A = v_I + v_love + v_NLP + v_too；句子 B 求和得到 sum_B = v_NLP + v_rocks + 0 + 0。

（4）除以真实长度：句子 A 除以 4 得到 pool_A = sum_A / 4；句子 B 除以 2 得到 pool_B = sum_B / 2。

通过这种方式就得到了不受填充影响的、精确的句子平均向量。而在 forward 方法中，这个过程大致包含四个步骤。首先是创建掩码，即根据输入的词元 ID 序列（token_ids）中不等于 padding_idx 的位置，生成一个值为 0 或 1 的掩码张量；紧接着进行向量置零，利用广播机制将特征向量与掩码相乘，使所有填充位置的特征向量都会变为零向量；随后向量求和，沿序列长度维度对特征向量进行求和；最后除以真实长度，将求和结果除以每个样本的真实长度（即掩码中 1 的数量），得到最终的池化向量。

3.3.3 模型代码

根据上述分析，下面是 TextClassifier 模型的完整实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class TextClassifier(nn.Module):
 def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
 super(TextClassifier, self).__init__()
 self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)

 self.feature_extractor = nn.Sequential(
 nn.Linear(embed_dim, hidden_dim * 2),
 nn.ReLU(),
 nn.Linear(hidden_dim * 2, hidden_dim * 4),
 nn.ReLU()
 )

 self.classifier = nn.Linear(hidden_dim * 4, num_classes)

 def forward(self, token_ids):
 embedded = self.embedding(token_ids)
 token_features = self.feature_extractor(embedded)

 # shapes:
 # token_ids: [batch_size, seq_len]
 # embedded: [batch_size, seq_len, embed_dim]
 # token_features: [batch_size, seq_len, hidden_dim * 4]
 # padding_mask: [batch_size, seq_len]
 # masked_features: [batch_size, seq_len, hidden_dim * 4]
 # summed_features: [batch_size, hidden_dim * 4]
 # pooled_features: [batch_size, hidden_dim * 4]
 # logits: [batch_size, num_classes]

 # --- 掩码平均池化 ---
 padding_mask = (token_ids != self.embedding.padding_idx).float()
 masked_features = token_features * padding_mask.unsqueeze(-1)
 summed_features = torch.sum(masked_features, 1)
 real_lengths = padding_mask.sum(1, keepdim=True)
 pooled_features = summed_features / torch.clamp(real_lengths, min=1e-9)

 logits = self.classifier(pooled_features)

 return logits

3.4 步骤三：训练与评估

将所有与训练、评估、优化和模型保存相关的逻辑都封装到一个Trainer类中。这个类负责协调模型、数据和优化器，完成整个训练流程。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85


import os
import json

class Trainer:
 def __init__(self, model, optimizer, criterion, train_loader, valid_loader, device, output_dir="."):
 self.model = model
 self.optimizer = optimizer
 self.criterion = criterion
 self.train_loader = train_loader
 self.valid_loader = valid_loader
 self.device = device
 self.best_accuracy = 0.0
 self.output_dir = output_dir
 os.makedirs(self.output_dir, exist_ok=True)
 # 用于记录历史数据
 self.train_losses = []
 self.val_accuracies = []

 def _run_epoch(self, epoch):
 self.model.train()
 total_loss = 0
 for batch in tqdm(self.train_loader, desc=f"Epoch {epoch+1} [训练中]"):
 self.optimizer.zero_grad()

 token_ids = batch["token_ids"].to(self.device)
 labels = batch["labels"].to(self.device)

 outputs = self.model(token_ids)
 loss = self.criterion(outputs, labels)
 total_loss += loss.item()

 loss.backward()
 self.optimizer.step()

 return total_loss / len(self.train_loader)

 def _evaluate(self, epoch):
 self.model.eval()
 correct_preds = 0
 total_samples = 0
 with torch.no_grad():
 for batch in tqdm(self.valid_loader, desc=f"Epoch {epoch+1} [评估中]"):
 token_ids = batch["token_ids"].to(self.device)
 labels = batch["labels"].to(self.device)

 outputs = self.model(token_ids)
 _, predicted = torch.max(outputs, 1)

 total_samples += labels.size(0)
 correct_preds += (predicted == labels).sum().item()

 return correct_preds / total_samples

 def _save_checkpoint(self, epoch, val_accuracy):
 if val_accuracy > self.best_accuracy:
 self.best_accuracy = val_accuracy
 save_path = os.path.join(self.output_dir, "best_model.pth")
 torch.save(self.model.state_dict(), save_path)
 print(f"新最佳模型已保存! Epoch: {epoch+1}, 验证集准确率: {val_accuracy:.4f}")

 def train(self, epochs, tokenizer, label_map):
 self.train_losses = []
 self.val_accuracies = []
 for epoch in range(epochs):
 avg_loss = self._run_epoch(epoch)
 val_accuracy = self._evaluate(epoch)

 self.train_losses.append(avg_loss)
 self.val_accuracies.append(val_accuracy)

 print(f"Epoch {epoch+1}/{epochs} | 训练损失: {avg_loss:.4f} | 验证集准确率: {val_accuracy:.4f}")

 self._save_checkpoint(epoch, val_accuracy)

 print("训练完成！")
 # 训练结束后，保存最终的词典和标签映射
 vocab_path = os.path.join(self.output_dir, 'vocab.json')
 with open(vocab_path, 'w', encoding='utf-8') as f:
 json.dump(tokenizer.vocab, f, ensure_ascii=False, indent=4)

 labels_path = os.path.join(self.output_dir, 'label_map.json')
 with open(labels_path, 'w', encoding='utf-8') as f:
 json.dump(label_map, f, ensure_ascii=False, indent=4)
 print(f"词典 ({vocab_path}) 和标签映射 ({labels_path}) 已保存。")
 return self.train_losses, self.val_accuracies

3.5 步骤四：执行训练

通过前面的精心封装，现在执行训练的入口代码变得非常直观和简洁。我们先定义一个超参数字典 hparams 来集中管理所有配置，这是一种良好的工程实践。然后，只需实例化所有需要的“零件”，并将它们交给“训练总管” Trainer 即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# 超参数
hparams = {
 "vocab_size": len(tokenizer),
 "embed_dim": 128,
 "hidden_dim": 256,
 "num_classes": len(train_dataset_raw.target_names),
 "epochs": 20,
 "learning_rate": 0.001,
 "device": "cuda" if torch.cuda.is_available() else "cpu",
 "output_dir": "output"
}

# 实例化
model = TextClassifier(
 hparams["vocab_size"],
 hparams["embed_dim"],
 hparams["hidden_dim"],
 hparams["num_classes"]
).to(hparams["device"])

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=hparams["learning_rate"])

hparams

然后，我们使用这些超参数来实例化模型、损失函数、优化器，并将它们全部交给 Trainer 类进行管理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


trainer = Trainer(
 model,
 optimizer,
 criterion,
 train_loader,
 valid_loader,
 hparams["device"],
 output_dir=hparams["output_dir"]
)

# 创建 标签名 -> ID 的映射，并传入 trainer 以便保存
label_map = {name: i for i, name in enumerate(train_dataset_raw.target_names)}

# 开始训练，并接收返回的历史数据
train_losses, val_accuracies = trainer.train(epochs=hparams["epochs"], tokenizer=tokenizer, label_map=label_map)

输出如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


...
Epoch 14 [训练中]: 100%|██████████| 224/224 [00:00<00:00, 314.05it/s]
Epoch 14 [评估中]: 100%|██████████| 169/169 [00:00<00:00, 788.40it/s]
Epoch 14/20 | 训练损失: 0.0003 | 验证集准确率: 0.8469
...
Epoch 19 [训练中]: 100%|██████████| 224/224 [00:00<00:00, 326.07it/s]
Epoch 19 [评估中]: 100%|██████████| 169/169 [00:00<00:00, 786.61it/s]
Epoch 19/20 | 训练损失: 0.0001 | 验证集准确率: 0.8450
Epoch 20 [训练中]: 100%|██████████| 224/224 [00:00<00:00, 324.01it/s]
Epoch 20 [评估中]: 100%|██████████| 169/169 [00:00<00:00, 792.40it/s]
Epoch 20/20 | 训练损失: 0.0001 | 验证集准确率: 0.8443
训练完成！
词典 (output\vocab.json) 和标签映射 (output\label_map.json) 已保存。

在本次训练中，模型于第14个轮次（Epoch）达到了最佳性能，验证集准确率最高为 84.69%。由于代码并未固定随机数种子，模型初始权重和数据加载顺序在每次运行时都会有所不同，所以每次运行时得到的结果可能会有细微差异。

3.5.1 训练过程可视化

为了更直观地分析模型的训练过程，例如判断是否收敛、是否存在过拟合等，可以将每个周期的训练损失和验证集准确率绘制成图表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


def plot_history(train_losses, val_accuracies, title_prefix=""):
 epochs = range(1, len(train_losses) + 1)

 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))

 # 绘制训练损失曲线
 ax1.plot(epochs, train_losses, 'bo-', label='Training Loss')
 ax1.set_title(f'{title_prefix} Training Loss')
 ax1.set_xlabel('Epochs')
 ax1.set_ylabel('Loss')
 ax1.grid(True)
 ax1.legend()

 # 绘制验证集准确率曲线
 ax2.plot(epochs, val_accuracies, 'ro-', label='Validation Accuracy')
 ax2.set_title(f'{title_prefix} Validation Accuracy')
 ax2.set_xlabel('Epochs')
 ax2.set_ylabel('Accuracy')
 ax2.grid(True)
 ax2.legend()

 plt.suptitle(f'{title_prefix} Training and Validation Metrics', fontsize=16)
 plt.show()

# 调用绘图函数
plot_history(train_losses, val_accuracies, title_prefix="Feed-Forward Network")

图 7-3 训练损失与验证集准确率变化曲线

从图 7-3 中能够看出：

训练损失：随着训练的进行，损失稳步下降并趋于平缓，说明模型在训练数据上得到了有效的学习。
验证集准确率：准确率在前几个轮次（Epochs）中迅速提升，随后在达到一个较高水平后出现小幅波动并趋于饱和。这表明模型在训练早期就快速收敛，并在后续训练中将性能稳定在最佳水平附近。

3.6 步骤五：模型推理

训练完成后，最终的目的是使用模型对全新的、未见过的数据进行预测。一个健壮的推理流程必须确保使用与训练时完全相同的预处理配置（特别是词典）和模型权重。

3.6.1 长文本推理的聚合策略

由于我们对长文本进行了滑窗分割，一篇原始文档在推理时会得到多个文本块的预测结果。那么如何将这些结果聚合成一个最终预测呢？常见的策略主要有两种，第一个是多数投票法，也是最直观的方法，具体做法是分别查看每个文本块被预测成的类别，然后选择得票最多的那个类别作为最终结果，若出现平票则可选择置信度总和最高的类别。第二个是概率累乘/平均法，该方法会计算每个类别在所有文本块上的平均置信度或概率，然后选择平均置信度最高的类别。虽然累乘也是一种选择，但在实践中容易因小概率值导致数值下溢，因此取对数后再求和（等价于累乘）或直接平均更为常用。

下面的 Predictor 类将封装完整的推理流程，并实现了“多数投票法”作为聚合策略。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


class Predictor:
 def __init__(self, model, tokenizer, label_map, device, max_len=128):
 self.model = model.to(device)
 self.model.eval()
 self.tokenizer = tokenizer
 self.label_map = label_map
 self.id_to_label = {idx: label for label, idx in self.label_map.items()}
 self.device = device
 self.max_len = max_len

 def predict(self, text):
 token_ids = self.tokenizer.convert_tokens_to_ids(self.tokenizer.tokenize(text))
 chunks = []
 if len(token_ids) <= self.max_len:
 chunks.append(token_ids)
 else:
 stride = max(1, int(self.max_len * 0.8))
 for i in range(0, len(token_ids) - self.max_len + 1, stride):
 chunks.append(token_ids[i:i + self.max_len])

 chunk_tensors = torch.tensor(chunks, dtype=torch.long).to(self.device)
 with torch.no_grad():
 outputs = self.model(chunk_tensors)
 preds = torch.argmax(outputs, dim=1)

 final_pred_id = torch.bincount(preds).argmax().item()

 final_pred_label = self.id_to_label[final_pred_id]
 return final_pred_label

# 加载资源
vocab_path = os.path.join(hparams["output_dir"], 'vocab.json')
with open(vocab_path, 'r', encoding='utf-8') as f:
 loaded_vocab = json.load(f)

labels_path = os.path.join(hparams["output_dir"], 'label_map.json')
with open(labels_path, 'r', encoding='utf-8') as f:
 label_map_loaded = json.load(f)

# 实例化推理组件
inference_tokenizer = Tokenizer(vocab=loaded_vocab)
inference_model = TextClassifier(
 len(inference_tokenizer),
 hparams["embed_dim"],
 hparams["hidden_dim"],
 len(label_map_loaded)
).to(hparams["device"])

model_path = os.path.join(hparams["output_dir"], "best_model.pth")
inference_model.load_state_dict(torch.load(model_path, map_location=hparams["device"]))

predictor = Predictor(
 inference_model,
 inference_tokenizer,
 label_map_loaded,
 hparams["device"]
)

# 预测
new_text = "The doctor prescribed a new medicine for the patient's illness, focusing on its gpu accelerated healing properties."
predicted_class = predictor.predict(new_text)

{"text": new_text, "pred": predicted_class}

输出如下：

1
2


{'text': "The doctor prescribed a new medicine for the patient's illness, focusing on its gpu accelerated healing properties.",
 'pred': 'sci.med'}

四、过拟合问题

刚刚构建的模型并没有考虑过拟合（Overfitting） 的问题，即模型在训练集上表现优异，但在未见过的验证集或测试集上表现不佳。下面简单介绍三个常用的方案：

（1）提前停止（早停）

这种方法是在Trainer的train方法中，持续监控验证集的准确率（或损失）。如果发现验证集准确率连续N个轮次（N被称为“耐心值”，Patience）都没有超过历史最佳值，就提前终止训练。这可以在Trainer中增加一个patience参数和一个计数器来实现此逻辑。

（2）随机 Token 遮盖

这是一种数据增强方法，具体操作是在训练过程中，随机地将文本中的一部分词元（例如15%）替换为<UNK>。使得模型不能过度依赖个别“明星词汇”，而是要学习更全面的上下文语义来进行判断，继而提升模型的泛化能力。这个修改可以在TextClassificationDataset类的__getitem__方法中，在返回数据前增加一个随机替换的步骤。不过要注意，这个操作只应在训练时进行。

（3）Dropout

它的核心是在训练过程中，以一定的概率p随机地将神经网络中某些神经元的输出置为零。可以防止神经元之间形成过于复杂的共适应关系，迫使网络学习到更鲁棒、更泛化的特征。可以在 TextClassifier 模型的 feature_extractor 模块中，于 nn.Linear 层和 nn.ReLU 激活函数之后加入 nn.Dropout(p) 层。

文本分类 on 酒中仙

微调 BERT 模型进行文本分类

微调 BERT 模型进行文本分类

一、从“序列建模”到“预训练微调”

二、代码修改实践

2.1 替换为 BertTokenizer

2.2 改造 Dataset 与 collate_fn

2.3 构建 TextClassifierBERT 模型

2.4 调整 Trainer 与 Predictor

2.5 更新训练超参数

2.6 推理阶段资源加载

三、实验结果与分析

本章小结

附录——使用BERT实现中文文本情感分类

BERT文本处理——Tokenizer

未微调时使用 text-classification pipeline

微调后使用 text-classification pipeline

基于 LSTM 的文本分类

基于 LSTM 的文本分类

一、从“词袋”到序列建模

二、代码修改实践

2.1 改造 collate_fn 以提供序列长度

2.2 构建 TextClassifierLSTM 模型

2.3 调整 Trainer 和 Predictor

2.4 更新训练入口代码

2.5 实验结果与分析

三、过拟合解决方案与效果对比

3.1 随机Token遮盖

3.2 提前停止 (Early Stopping)

3.3 实验与对比

3.4 最终效果分析

文本分类简单实现

文本分类简单实现

一、文本分类任务概述

二、NLP 项目通用流程

三、新闻文本分类代码实践

3.1 模块化设计思路

3.2 步骤一：数据解析与加载

3.2.1 数据加载

3.2.2 数据探索与可视化

3.2.3 Tokenizer 封装

3.2.4 Tokenizer 与词典构建

3.2.5 如何处理长文本？

3.2.6 封装 Dataset 和 DataLoader

3.3 步骤二：模型构建

3.3.1 模型结构设计

3.3.2 掩码平均池化

3.3.3 模型代码

3.4 步骤三：训练与评估

3.5 步骤四：执行训练

3.5.1 训练过程可视化

3.6 步骤五：模型推理

3.6.1 长文本推理的聚合策略

四、过拟合问题

2.1 替换为 `BertTokenizer`

2.2 改造 `Dataset` 与 `collate_fn`

2.3 构建 `TextClassifierBERT` 模型

2.4 调整 `Trainer` 与 `Predictor`

2.1 改造 `collate_fn` 以提供序列长度

2.2 构建 `TextClassifierLSTM` 模型

2.3 调整 `Trainer` 和 `Predictor`

3.2.6 封装 `Dataset` 和 `DataLoader`