BERT 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}]

效果明显好了很多。

BERT 结构及应用

Mon, 23 Mar 2026 12:34:25 -0800

BERT 结构及应用

我们在前面的章节中探讨了 Transformer 架构，它的结构是由一个编码器和一个解码器组成，而这两部分内部又分别由 N 个相同的层堆叠而成。Transformer 的提出催生了许多强大的预训练模型。有趣的是，这些后续模型往往只采用了 Transformer 架构的一部分。其中，以 GPT 为代表的模型采用解码器结构，主要任务是预测下一个词元，这种特性使其天然适用于文本生成任务。而本章的主角 BERT（Bidirectional Encoder Representations from Transformers），则完全基于编码器结构构建 ¹。

正如其名，BERT 的核心优势在于其双向性。通过 Transformer 编码器中自注意力机制能够同时关注上下文的特性，BERT 在理解语言的深层语义方面取得了突破性进展。这一设计也决定了 BERT 的核心应用场景，它是一个强大的语言理解模型，但在不进行结构改造的前提下，不适用于文本生成。这是因为它在预测时能够“看到”整个输入序列，而以 GPT 为代表的生成模型在预测下一个词时，必须严格遵守“只能看到过去”的单向规则。

一、BERT 的设计原理与预训练策略

在 BERT 出现之前，像 Word2Vec 这样的模型能够为词语生成一个固定的向量表示（静态词向量），但无法解决一词多义的问题。例如，“破防”在“我出了一件破防装备”和“NLP 算法给我学破防了”中的含义完全不同，但在 Word2Vec 中它们的向量是相同的。BERT 的设计初衷就是为了解决这个问题，它的目标是生成动态的、与上下文相关的词向量。它不仅仅是一个词向量生成工具，更是一个强大的预训练语言模型。其工作范式可以分为两个主要阶段，如图 5-1 所示：

图 5-1 BERT 的预训练 (Pre-training) 与微调 (Fine-tuning) 流程

预训练 (Pre-training)
- 在一个庞大的、通用的文本语料库（如维基百科、书籍）上，通过特定的无监督任务来训练一个深度神经网络模型。
- 这个阶段的目标不是为了完成某个具体的 NLP 任务，而是让模型学习语言本身的规律，比如语法结构、词语间的语义关系、上下文依赖等。
- 训练完成后，就得到了一个包含了丰富语言知识的、参数已经训练好的预训练模型。
微调 (Fine-tuning)
- 当面临一个具体的下游任务时（如文本分类、命名实体识别），我们不再从头开始训练模型。而是把预训练好的 BERT 模型作为任务模型的基础结构。加载它已经学习到的所有参数作为初始值。
- 接着根据具体任务，在 BERT 模型之上增加一个小的、任务相关的输出层（例如，一个用于分类的全连接层）。
- 最后在自己的任务数据集上对整个模型（或仅仅是顶部的输出层）进行训练。由于模型已经具备了强大的语言理解能力，这个微调过程通常非常快速，并且只需要相对较少的数据就能达到很好的效果。

这种 “预训练 + 微调” 的训练范式，属于迁移学习的一种实现，也是 BERT 的训练框架。它能够从海量数据中学到的通用语言知识，迁移到数据量有限的特定任务中。

与 RNN/LSTM 的区别

你可能会有疑问：像 Bi-LSTM 这样的循环神经网络不是也能捕捉上下文信息，生成动态词向量吗，为什么还需要 BERT？

虽然目标相似，但实现方式和效果却有很大的差别。Bi-LSTM 的“双向”本质上是两个独立的单向 RNN（一个正向，一个反向）的浅层拼接。在计算过程中，正向 RNN 并不知道未来的信息，反向 RNN 也不知道过去的信息。

而 BERT 基于 Transformer 的自注意力机制，实现了真正的“深度双向”。也就是上一节中所学到的，自注意力机制使模型的每一层，计算任何一个词的表示时，都能同时与序列中的所有其他词直接交互。这种全局视野让 BERT 能够捕捉到比 RNN 更复杂、更长距离的依赖关系，并且其并行计算的特性也远比 RNN 的串行结构高效。可以说，BERT 实现了 RNN 想要达到但未能完美实现的目标。

二、BERT 架构详解

2.1 BERT 的模型规模

与 Transformer 论文中 N=6 不同，BERT 提供了几种不同规模的预训练模型，以适应不同的计算资源和性能需求。其中最常见的两个是如表 5-1 所示的 BERT Base 与 BERT Large。

模型	层数 (L)	隐藏层大小 (H)	注意力头数 (A)	总参数量
`BERT-Base`	12	768	12	~1.1 亿
`BERT-Large`	24	1024	16	~3.4 亿

表 5-1 BERT Base 与 BERT Large 模型规模对比

通过加深、加宽网络，BERT 拥有了比原始 Transformer 更强大的特征提取和表示能力。

2.2 BERT 的输入表示

为了让模型能够处理各种复杂的输入，BERT 的输入表示由三个部分的嵌入向量逐元素相加而成：

$$ Input_{embedding} = Token_{embedding} + Position_{embedding} + Segment_{embedding} $$

对应的结构示意见图 5-2。

图 5-2 BERT 输入表示

（1）词元嵌入:

与之前模型类似，这是每个词元（Token）自身的向量表示。
BERT 使用一种称为 WordPiece 的分词方法 ²。它能够将不常见的词拆分成更小的子词单元（如 “studying” -> “study”, “##ing”），有效处理了未登录词问题。对于 bert-base-chinese 模型，其词表以单字为主，也包含少量常用词，因此在处理中文时，其效果接近于按字分词，但更准确的描述是子词切分。

（2）片段嵌入:

这是 BERT 为了处理句子对任务（如判断两个句子是否是连续的）而引入的，用于区分输入中的不同句子。
例如，对于一个由句子 A 和句子 B 拼接而成的输入，所有属于句子 A 的词元都会加上一个相同的“句子A嵌入”，而所有属于句子 B 的词元则会加上另一个“句子B嵌入”。

（3）位置嵌入:

Transformer 的自注意力机制本身不包含位置信息，必须额外引入位置编码来告诉模型每个词元在序列中的位置。
与原始 Transformer 使用固定的正余弦函数不同，BERT 采用的是可学习的位置嵌入。即创建一个大小为 [max_position_embeddings, hidden_size] 的嵌入表，让模型在预训练过程中自己学习每个位置的最佳向量表示。
BERT 的最大长度限制：正是这个可学习的位置嵌入表，决定了 BERT 的最大输入长度。例如，在 BERT-Base 模型中，这个嵌入表的大小通常是 [512, 768]，这意味着模型最多只能处理 512 个词元的序列。这并非 Transformer 架构本身的限制，而是 BERT 预训练时设定的一个参数。

最终，每个输入词元的表示向量，是上述三种嵌入向量相加的结果。

2.3 特殊词元

BERT 在输入序列中引入了几个特殊的词元，它们在预训练和微调阶段扮演着重要的角色：

[CLS] (Classification):
- 这个词元被添加到 每个输入序列的开头。
- BERT 的一个特殊设计是，这个 [CLS] 词元在经过整个编码器网络后的最终输出向量，被视为整个输入序列的 聚合表示。
- 因此，在进行文本分类、情感分析等句子级别的任务时，通常只取用 [CLS] 对应的输出向量，然后将其送入一个分类器。
[SEP] (Separator):
- 这个词元用于 分隔不同的句子。
- 例如，在输入是单个句子时，它被添加在句子的末尾。
- 在输入是句子对时，它被用在两个句子之间，以及整个序列的末尾。
[MASK]:
- 这个词元仅在 预训练阶段 使用，用于“掩盖”掉输入序列中的某些词元，是“掩码语言模型”任务的核心。
[PAD] (Padding):
- 用于将不同长度的输入序列补齐到相同的长度（例如 512），以便进行批量处理。
- 在计算注意力时，这些位置会被 Attention Mask 屏蔽，不参与计算。
[UNK] (Unknown):
- 当分词器遇到词表中不存在的字符或词汇时，会将其替换为该特殊词元。

三、BERT 的预训练任务

为了让 BERT 真正理解语言，研究人员在其训练过程中引入了两项全新的预训练任务（如图 5-3 所示），这也是它成功的关键。

图 5-3 BERT 预训练任务图示 (MLM 和 NSP)

3.1 任务一：掩码语言模型 (Masked Language Model, MLM)

传统的语言模型（如 GPT）是单向的，只能根据前面的词预测下一个词。如果我们想让模型同时利用上下文信息，简单地将左右两侧的词都作为输入来预测当前词，会导致一个问题，在多层网络中，模型会“间接地看到自己”，预测任务将变得毫无意义。

为了解决这个问题，BERT 引入了 MLM。它的思路是在输入文本中随机遮盖掉一部分词元（Token），然后训练模型去根据上下文预测这些被遮盖的词元。这就像在做“完形填空”一样，迫使模型学习词元之间深层次的语义关系和句法结构。

MLM 的执行策略如下：

（1）随机选择：在每一个训练序列中，随机挑选 15% 的词元作为预测目标。

（2）特殊替换策略：为了缓解预训练（有 [MASK] 标记）与微调（没有 [MASK] 标记）阶段的数据差异，对于这 15% 被选中的词元，采用如下“80/10/10”的替换方法。假设如图 5-3 中 My son is a good stu 的 son 词元被选中：

80% 的情况：将选中的词元替换为 [MASK] 标记。
- 示例：My [MASK] is a good stu
- 目的：这是最核心的操作，强制模型利用上下文信息来预测被“挖空”的词。
10% 的情况：将选中的词元替换成一个随机的其他词元。
- 示例：My apple is a good stu (将 son 随机替换为 apple)
- 目的：相当于为模型引入了噪声。一方面，它要求模型不仅要理解上下文，还要具备识别并纠正错误词元的能力，从而增强模型的健壮性；另一方面，它也促使模型去学习每一个输入词元的分布式特征表示，而不是仅仅“依赖”[MASK]标记去触发预测。
10% 的情况：保持词元不变。
- 示例：My son is a good stu
- 目的：这是为了让模型在看到真实词元时也去预测它自己，从而使得模型更好地学习每一个真实词元的上下文表示，减轻预训练和微调阶段的数据不匹配问题。

通过这种方式，MLM 任务促使 BERT 学习到一种动态的、与上下文深度融合的词向量表示。

MLM 的局限

由于 MLM 是随机 Mask 单个字或子词，可能会割裂一个完整词语的内部语义联系。例如，对于 “菩提老祖” 这个词，模型可能会只 Mask “菩” 或 “提”，而无法在词的层面上进行学习。为了解决这个问题，后续的研究提出了 WWM (Whole Word Masking, 全词掩码) 的策略 ³。即如果一个词的一部分被选中进行 Mask，那么这个词的所有部分都会被一起 Mask。这项技术在中英文任务上都取得了效果提升。

3.2 任务二：下一句预测 (Next Sentence Prediction, NSP)

NSP 任务的目标是让模型理解句子与句子之间的逻辑关系。在训练时，模型会接收一对句子 A 和 B，并判断句子 B 是否是句子 A 在原文中的下一句。

（1）构造句子对: 在预训练时，为模型准备句子对 (A, B)。其中，50% 的情况下，B 是 A 的真实下一句；另外 50% 的情况下，B 是从语料库中随机选择的一个句子。

（2）二分类任务: 模型需要预测 B 是否是 A 的下一句。

这个任务的预测，正是通过 2.3 节中提到的 [CLS] 词元的输出来完成的。将 [CLS] 的最终隐藏状态送入一个二分类器，来判断 IsNext 还是 NotNext，从而训练 [CLS] 向量学习句子级别的聚合特征。

NSP 的有效性讨论

后续研究（如 RoBERTa ⁴, ALBERT ⁵）对 NSP 的有效性提出了质疑，发现在更大规模的预训练下，移除它或用 other 任务替代（如句子顺序预测）会带来更好的效果。

但是，在 BERT 的原始论文中，消融实验证明，在当时的训练设置下，移除 NSP 会导致在问答（QNLI）和自然语言推断（MNLI）等任务上性能明显下降。这说明 NSP 任务确实帮助原始 BERT 模型学习到了句子级别的关系，在特定场景下依然有其价值。

四、BERT 的应用与实践

预训练完成后，我们就得到了一个强大的 BERT 模型。接下来，可以根据具体的任务来释放它的能力。

4.1 微调下游任务

（1）文本分类任务

对于文本分类任务（如情感分析、意图识别），主要利用 [CLS] 词元的聚合表示能力（见 2.3 节）。

输入构造: 将单个句子或句子对按照 BERT 的要求格式化（添加 [CLS] 和 [SEP]）。
获取表示: 提取 [CLS] 词元对应的最终输出向量。
添加分类头: 在这个向量之上，添加一个简单的全连接层作为分类器，其输出维度等于任务的类别数量。
微调: 在任务数据上，训练这个新添加的分类器，同时对 BERT 模型的参数进行微调（通常使用比预训练时小得多的学习率）。

（2）词元分类任务

对于词元级别的任务（如命名实体识别、分词、词性标注），需要为输入序列中的每一个词元进行分类。

输入构造: 与文本分类类似，将序列格式化。
获取表示: 将输入送入 BERT 模型，但这次提取 所有词元 对应的最终输出向量序列。输出的形状为 (batch_size, sequence_length, hidden_size)。
添加分类头: 在这个序列之上，添加一个全连接层（可以看作是在时间维度上共享权重），将每个词元的 hidden_size 维向量映射到类别数量的维度。
微调: 在任务数据上进行端到端的训练和微调。

（3）其他任务

BERT 的应用非常广泛，几乎可以适配所有的 NLP 任务。例如，在问答任务中，可以将问题和段落作为两个句子输入 BERT，然后训练模型去预测答案在段落中的起始和结束位置。

4.2 实践技巧与生态

4.2.1 输入处理与限制

在进行 BERT 微调时，有两点需要特别注意，这直接关系到模型能否正常运行和发挥效果：

（1）最大长度限制:

标准的 BERT 模型（如 bert-base-chinese）通常设定的最大输入长度为 512 个 Token。虽然这个长度并非架构本身的限制（可以修改位置嵌入表大小来调整），但大多数预训练模型都遵循这一设定。
这 512 个位置中包含了特殊 Token。所以，实际输入文本的有效长度最多为 510 个 Token（512 - [CLS] - [SEP]）。如果是句子对任务，则两个句子的总长度加上 3 个特殊 Token（[CLS], [SEP], [SEP]）不能超过 512。

（2）特殊 Token 的添加:

输入序列的开头必须添加 [CLS]，结尾必须添加 [SEP]。
虽然现在的 Tokenizer（如 tokenizer(text, ...)）通常会自动处理这些特殊 Token 的添加，但在手动构建输入或分析数据时，务必牢记这一要求。

4.2.2 特征提取策略

虽然我们通常使用最后一层的输出作为词元或句子的特征表示，但这并非唯一选择。研究和实践表明，BERT 的不同层级学习到的特征有所侧重：

底层更偏向于捕捉 词法、语法 等表层信息。
高层更偏向于捕捉 语义、语境 等深层信息。

在某些任务（如命名实体识别）中，将最后几层（例如，最后四层）的向量进行拼接（Concatenate）或相加（Sum），有时能获得比单独使用最后一层更好的效果。这提供了一种简单有效的性能提升技巧。

4.2.3 Hugging Face Transformers 生态

如今，从头实现或手动管理 BERT 模型已无必要。Hugging Face 公司开源的 transformers 库 ⁶已经成为 NLP 领域的标准工具。

模型中心: 它提供了一个庞大的模型仓库，包含了几乎所有主流的预训练模型（包括各种语言、各种规模的 BERT）。用户可以在 Hugging Face 官网或其国内镜像上查找、下载和试用这些模型。
统一的 API: 开发者可以使用简洁、统一的接口，轻松地加载、使用和微调这些模型。
社区支持: 拥有活跃的社区和丰富的文档，是学习和应用 BERT 等预训练模型的最佳起点。

五、BERT 代码实战

在了解了 BERT 的理论知识后，下面来通过一个完整的代码示例，展示如何使用 transformers 库加载预训练的 BERT 模型，并从中提取文本特征向量。

本节完整代码

5.1 环境准备

首先，确保已经安装了 transformers：

1

pip install transformers

如果在国内下载模型遇到网络问题，可以设置环境变量来使用 Hugging Face 的国内镜像：

1
2


import os
os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'

5.2 代码示例

以下代码涵盖了从加载模型到提取特征的完整流程：

 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


import torch
import os
from transformers import AutoTokenizer, AutoModel

# 1. 环境和模型配置
# os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com' # 可选：设置镜像
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_name = "bert-base-chinese"
texts = ["我来自中国南方", "我喜欢自然语言处理课程"]

# 2. 加载模型和分词器
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name).to(device)
model.eval()

print("\n--- BERT 模型结构 ---")
print(model)

# 3. 文本预处理
inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(device)

# 打印 Tokenizer 的完整输出，以理解其内部结构
print("\n--- Tokenizer 输出 ---")
for key, value in inputs.items():
 print(f"{key}: \n{value}\n")

# 4. 模型推理
with torch.no_grad():
 outputs = model(**inputs)

# 5. 提取特征
last_hidden_state = outputs.last_hidden_state

print(last_hidden_state.shape)

sentence_features_pooler = getattr(outputs, "pooler_output", None)

# (1) 提取句子级别的特征向量 ([CLS] token)
sentence_features = last_hidden_state[:, 0, :]

# (2) 提取第一个句子的词元级别特征
first_sentence_tokens = last_hidden_state[0, 1:6, :]


print("\n--- 特征提取结果 ---")
print(f"句子特征 shape: {sentence_features.shape}")
if sentence_features_pooler is not None:
 print(f"pooler_output shape: {sentence_features_pooler.shape}")
print(f"第一个句子的词元特征 shape: {first_sentence_tokens.shape}")

（1）加载模型和分词器：使用 AutoTokenizer.from_pretrained(model_name) 和 AutoModel.from_pretrained(model_name) 来自动下载并加载指定的预训练模型。

（2）文本预处理：tokenizer(...) 函数的输出是一个字典，其中包含了模型所需的全部输入信息。

input_ids: 这是文本被转换为的 token ID 序列。Tokenizer 会在合适的位置自动添加 101 ([CLS]) 和 102 ([SEP]) 等特殊标记；批次中较短的句子会被 0 ([PAD]) 填充到与最长序列等长（或到指定的 max_length）。
token_type_ids: 片段嵌入 的体现（见 2.2 节），用于区分不同句子。
attention_mask: 一个非常重要的参数，它告诉模型在进行自注意力计算时，哪些 token 是真实的（值为 1），哪些是填充的（值为 0），模型会忽略填充 token。

Attention Mask 如何工作？

attention_mask 张量中的 0 会被转换为一个非常大的负数（如 -10000），然后加到注意力得分上。这样，在经过 Softmax 计算后，这些位置的注意力权重会趋近于 0，从而在计算中被忽略。

（3）模型推理:

将预处理好的 inputs 字典通过 **inputs 解包后送入模型。
with torch.no_grad(): 上下文管理器会禁用梯度计算，用于在推理阶段减少内存消耗并加速计算。

（4）解析与提取:

outputs.last_hidden_state: 它的形状是 (batch_size, sequence_length, hidden_size)，包含了序列中每一个词元在最高层的向量表示。
句子特征提取: 通过索引 [:, 0, :]，可以轻松获得整个批次的 [CLS] 位置的隐藏状态；此外，outputs.pooler_output（若存在）是对该隐藏状态再经过一层全连接+Tanh 的结果（BERT 原用于 NSP 任务）。具体使用哪一种，建议以验证集效果为准，平均池化或拼接最后几层在实践中也常见。
词元特征提取: 通过对特定范围进行切片可以获得具体某个句子的所有非特殊词元的特征向量。例如，对于第一个句子 “我来自中国”，Tokenizer 会将其转换为 ['[CLS]', '我', '来', '自', '中', '国', '[SEP]']。因此，我们使用 [0, 1:6, :] 来提取索引从 1 到 5 的词元向量，这对应了 “我” 到 “国” 这五个汉字。这些特征可以用于命名实体识别等词元级任务。

输出结果如下所示：

 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



--- BERT 模型结构 ---
BertModel(
 (embeddings): BertEmbeddings(
 (word_embeddings): Embedding(21128, 768, padding_idx=0)
 (position_embeddings): Embedding(512, 768)
 (token_type_embeddings): Embedding(2, 768)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 (encoder): BertEncoder(
 (layer): ModuleList(
 (0-11): 12 x BertLayer(
 (attention): BertAttention(
 (self): BertSdpaSelfAttention(
 (query): Linear(in_features=768, out_features=768, bias=True)
 (key): Linear(in_features=768, out_features=768, bias=True)
 (value): Linear(in_features=768, out_features=768, bias=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 (output): BertSelfOutput(
 (dense): Linear(in_features=768, out_features=768, bias=True)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 )
 (intermediate): BertIntermediate(
 (dense): Linear(in_features=768, out_features=3072, bias=True)
 (intermediate_act_fn): GELUActivation()
 )
 (output): BertOutput(
 (dense): Linear(in_features=3072, out_features=768, bias=True)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 )
 )
 )
 (pooler): BertPooler(
 (dense): Linear(in_features=768, out_features=768, bias=True)
 (activation): Tanh()
 )
)

--- Tokenizer 输出 ---
input_ids:
tensor([[ 101, 2769, 3341, 5632, 704, 1744, 1298, 3175, 102, 0, 0, 0,
 0],
 [ 101, 2769, 1599, 3614, 5632, 4197, 6427, 6241, 1905, 4415, 6440, 4923,
 102]], device='cuda:0')

token_type_ids:
tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], device='cuda:0')

attention_mask:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], device='cuda:0')

torch.Size([2, 13, 768])

--- 特征提取结果 ---
句子特征 shape: torch.Size([2, 768])
pooler_output shape: torch.Size([2, 768])
第一个句子的词元特征 shape: torch.Size([5, 768])

5.3 模型结构分解

当运行 print(model) 时，会得到一个详细的、树状的 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


BertModel(
 (embeddings): BertEmbeddings(
 (word_embeddings): Embedding(21128, 768, padding_idx=0)
 (position_embeddings): Embedding(512, 768)
 (token_type_embeddings): Embedding(2, 768)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 (encoder): BertEncoder(
 (layer): ModuleList(
 (0-11): 12 x BertLayer(
 (attention): BertAttention(
 (self): BertSdpaSelfAttention(
 (query): Linear(in_features=768, out_features=768, bias=True)
 (key): Linear(in_features=768, out_features=768, bias=True)
 (value): Linear(in_features=768, out_features=768, bias=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 (output): BertSelfOutput(
 (dense): Linear(in_features=768, out_features=768, bias=True)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 )
 (intermediate): BertIntermediate(
 (dense): Linear(in_features=768, out_features=3072, bias=True)
 (intermediate_act_fn): GELUActivation()
 )
 (output): BertOutput(
 (dense): Linear(in_features=3072, out_features=768, bias=True)
 (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
 (dropout): Dropout(p=0.1, inplace=False)
 )
 )
 )
 )
 (pooler): BertPooler(
 (dense): Linear(in_features=768, out_features=768, bias=True)
 (activation): Tanh()
 )
)

这给我们提供了一个直观的方式来理解它的内部组件，并将其与理论知识对应起来。下面来结合这个结构，对 bert--base-chinese 模型的核心部分进行分解：

（1）embeddings (嵌入层): 此模块是上文 BERT 输入表示理论的具体实现。它负责将输入的 token ID 序列，通过组合 词元、位置和片段 三种嵌入向量，转换为模型真正的输入。

(word_embeddings): Embedding(21128, 768): 词元嵌入。这里的 21128 是 bert-base-chinese 模型的词汇表大小，768 则是 BERT-Base 模型的隐藏层维度 H。
(position_embeddings): Embedding(512, 768): 位置嵌入。这就是在理论部分提到的可学习的位置嵌入，其 [512, 768] 的大小也直接解释了为什么 BERT-Base 模型的最大输入长度是 512 个词元。
(token_type_embeddings): Embedding(2, 768): 片段嵌入。它用于区分输入的两个不同句子（句子 A 和 B），这对于 NSP 这样的预训练任务非常重要。
(LayerNorm) 和 (dropout): 在将上述三种嵌入向量相加后，会进行层归一化和 Dropout 操作，以稳定训练过程并增强模型的泛化能力。

可以打开 bert-base-chinese 的 vocab.txt 词汇表文件验证一下。该文件共有 21128 行，每一行代表一个词元，词汇表大小正好是 21128。

直接浏览器查看可能会导致浏览器卡死，别问笔者怎么知道的🫠

（2）encoder (编码器): 这是 BERT 的核心主体，正是由前面提到的 12 层 Transformer 编码器堆叠而成。

(layer): ModuleList((0-11): 12 x BertLayer): ModuleList 中包含了 12 个完全相同的 BertLayer。模型的“深度”就体现在这里，每一层的输出都会作为下一层的输入，逐层提取更深层次的特征。
在每一个 BertLayer 内部，都包含了 2 节中所述的两个核心子层：
- (attention): 多头自注意力模块，其内部的 query, key, value 线性层和 output.dense 层分别对应 $W^Q, W^K, W^V$ 和 $W^O$ 矩阵。
- (intermediate) 和 (output): 位置前馈网络模块，它通过一个 768 -> 3072 -> 768 的升维再降维结构来提取特征。

（3）pooler (池化层):

该层功能与前面介绍的特殊词元 [CLS] 紧密相关。
它的作用是处理 [CLS] 词元在经过 12 层 Encoder 后的最终输出向量（即 last_hidden_state[:, 0]），通过一个全连接层和 Tanh 激活函数，将其转换为一个代表整个序列的“池化”后的特征向量。
这个经过特殊处理的 [CLS] 向量，在预训练阶段专门用于完成 NSP 任务，从而使其学习到了整个输入序列的聚合信息。

通过这个结构，可以清晰地看到 BERT 是如何将 Transformer 编码器的思想付诸实践的，从输入处理到多层特征提取，再到最终的输出，每一步都清晰可见。

练习

总结 BERT 和 Transformer(Encoder) 区别

BERT 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

BERT 结构及应用

BERT 结构及应用

一、BERT 的设计原理与预训练策略

二、BERT 架构详解

2.1 BERT 的模型规模

2.2 BERT 的输入表示

2.3 特殊词元

三、BERT 的预训练任务

3.1 任务一：掩码语言模型 (Masked Language Model, MLM)

3.2 任务二：下一句预测 (Next Sentence Prediction, NSP)

四、BERT 的应用与实践

4.1 微调下游任务

4.2 实践技巧与生态

4.2.1 输入处理与限制

4.2.2 特征提取策略

4.2.3 Hugging Face Transformers 生态

五、BERT 代码实战

5.1 环境准备

5.2 代码示例

5.3 模型结构分解

练习

参考文献

2.1 替换为 `BertTokenizer`

2.2 改造 `Dataset` 与 `collate_fn`

2.3 构建 `TextClassifierBERT` 模型

2.4 调整 `Trainer` 与 `Predictor`