当前位置：首页 > news >正文

NLP之BERT预训练模型详解

news 2026/5/23 1:07:07

摘要：BERT（Bidirectional Encoder Representations from Transformers）是谷歌于2018年提出的革命性自然语言处理模型，首次将基于Transformer的双向编码器架构成功应用于预训练语言模型，在多项NLP基准任务上刷新了最优记录。本文全面介绍了BERT的核心架构、预训练任务设计、主流变体模型以及基于Hugging Face Transformers的实战代码示例，帮助读者快速掌握BERT的原理并进行实际应用开发。

关键词：BERT；预训练模型；Transformer；自然语言处理；Hugging Face；PyTorch

一、引言

在BERT出现之前，NLP领域主要采用监督学习范式，需要大量标注数据才能训练出有效的模型。然而标注数据的获取成本高昂，严重制约了NLP技术的发展。2018年，谷歌发表论文《BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding》，提出了一种全新的预训练+微调（Pre-train + Fine-tune）范式，彻底改变了NLP技术的发展轨迹。

BERT的核心创新在于：利用无监督的大规模文本语料进行预训练，学习通用的语言表示，然后在特定下游任务的标注数据上进行微调。这种迁移学习的思想在计算机视觉领域已经非常成熟，BERT将其成功引入NLP领域，开创了预训练语言模型的新时代。

二、BERT背景与核心思想

2.1 预训练+微调范式

传统的NLP模型需要从头开始训练，而BERT采用两阶段学习策略：

第一阶段：预训练（Pre-training）

在大规模无标注语料（如Wikipedia、BookCorpus）上，通过自监督学习任务训练模型，学习通用的语言知识和语义表示。预训练阶段不需要人工标注数据，可以利用互联网上几乎无限规模的文本资源。

第二阶段：微调（Fine-tuning）

将预训练好的模型参数作为初始化，结合特定下游任务（如文本分类、命名实体识别）的少量标注数据进行有监督微调。由于预训练阶段已经学习了丰富的语言知识，微调阶段通常只需要较少的标注数据就能达到优异性能。

这种范式的优势在于：预训练阶段一次性投入大量计算资源，但预训练模型可以重复用于多个下游任务，大幅降低了每个具体任务的数据和计算需求。

2.2 迁移学习在NLP中的应用

迁移学习的核心思想是将从一个任务（源任务）学习到的知识应用到另一个相关任务（目标任务）。在BERT之前，NLP领域也出现过一些迁移学习尝试，如Word2Vec、GloVe等词向量模型，但这些模型存在以下局限：

静态表示：词向量是静态的，一个词在整个语料中共享相同的向量，无法区分不同上下文中的语义差异
单向建模：无法同时利用上下文左右两侧的信息

BERT通过深度双向Transformer架构和上下文相关的动态表示，成功解决了上述问题，使迁移学习在NLP领域取得了突破性进展。

三、BERT架构详解

3.1 整体架构

BERT基于Transformer编码器（Encoder）构建，其核心结构由多层自注意力（Self-Attention）机制和前馈神经网络交替堆叠而成。论文提出了两个规模的模型：

模型配置	层数（L）	隐藏维度（H）	注意力头数（A）	参数量
BERT-base	12	768	12	110M
BERT-large	24	1024	16	340M

以BERT-base为例，其结构包含：

12层Transformer编码器
768维隐藏状态
12个自注意力头
约1.1亿参数

3.2 词嵌入层

BERT的输入表示由三部分词嵌入拼接而成：

输入表示 = Token Embedding + Position Embedding + Segment Embedding

Token Embedding（词元嵌入）

将输入文本中的每个词转换为固定维度的向量表示。BERT使用WordPiece分词策略，词汇表大小约为30000个词元。对于中文，BERT使用字符级分词。

Position Embedding（位置嵌入）

Transformer本身不具备序列位置信息，需要通过位置嵌入来注入词序信息。BERT采用可学习的位置嵌入，最大支持512个位置的序列。

Segment Embedding（句子段落嵌入）

用于区分输入中的不同句子。Bert支持单句输入和句子对输入（如问答任务），通过句子段落嵌入区分句子A和句子B。

特殊Token

[CLS]：位于输入序列开头，其最终隐藏状态用作分类任务的聚合表示
[SEP]：用于分隔两个句子
[PAD]：填充token，用于批处理时对齐序列长度
[UNK]：未登录词

示例：输入 "[CLS] 今天天气 [SEP] 很好 [SEP]"  Token IDs: [101, 2773, 1921, 1920, ...] # 特殊token对应特定ID Segment IDs: [0, 0, 0, 0, 1, 1, 1] # 0表示第一个句子，1表示第二个句子 Position IDs: [0, 1, 2, 3, 4, 5, 6] # 每个位置的唯一编号

3.3 Transformer编码器层

每一层Transformer编码器包含两个子层：

Multi-Head Self-Attention（多头自注意力）

通过自注意力机制建模输入序列中各个词之间的依赖关系。多头注意力允许模型从不同角度关注序列的不同部分：

MultiHead(Q, K, V) = Concat(head_1, ..., head_h) * W^O  head_i = Attention(Q * W_i^Q, K * W_i^K, V * W_i^V) = softmax(Q * K^T / sqrt(d_k)) * V

Position-wise Feed-Forward Network（前馈网络）

每个位置独立经过相同的两层全连接网络：

FFN(x) = GeLU(x * W_1 + b_1) * W_2 + b_2

每个子层都使用残差连接（Residual Connection）和层归一化（Layer Normalization）：

Output = LayerNorm(x + Sublayer(x))

四、预训练任务设计

BERT的核心创新之一在于其精心设计的两个预训练任务，通过自监督学习的方式从大规模无标注语料中提取语言知识。

4.1 Masked Language Model（MLM）

MLM是一种完形填空式（Cloze）的学习任务，也称为遮蔽语言模型。其核心思想是随机遮蔽输入序列中的一部分词元，然后让模型根据上下文信息预测被遮蔽的词元。

遮蔽策略

随机选择15%的词元作为候选遮蔽位置
对于选中的词元，采用以下策略：
- 80%的概率替换为[MASK]token
- 10%的概率替换为随机词元
- 10%的概率保持不变（但仍计算损失）

这种混合策略的原因：

如果始终使用[MASK]，预训练阶段和微调阶段会存在不匹配（因为微调阶段不会出现[MASK]）
随机替换可以迫使模型对每个词元都有较好的表示，因为有时需要根据上下文推断，有时需要根据表层信息

损失计算

仅对被遮蔽的15%词元计算交叉熵损失：

# MLM损失计算示意 loss = cross_entropy(logits[masked_positions], labels[masked_positions])

4.2 Next Sentence Prediction（NSP）

NSP任务用于训练模型理解句子之间的关系，这对于问答、自然语言推理等任务非常重要。

任务定义

给定句子A和句子B，预测句子B是否是句子A的下一个句子。

正样本：句子B确实是句子A的下一个句子（来自同一文档）
负样本：句子B是从语料中随机选取的句子（与句子A无关）

训练时，50%的样本为正样本，50%为负样本。

任务意义

NSP任务使BERT能够理解句子级别的语义关系，这对于：

问答系统：需要理解问题与答案段落的关系
自然语言推理：判断句子间的蕴含关系
对话系统：理解上下文连贯性

4.3 预训练数据与训练配置

BERT的预训练数据包括：

BooksCorpus：包含约8亿词
English Wikipedia：包含约25亿词（仅提取文本段落，忽略列表、标题等）

训练超参数：

参数	BERT-base	BERT-large
训练Batch Size	256	256
训练步数	1,000,000	1,000,000
学习率	1e-4	1e-4
warmup比例	10%	10%
词元最长长度	512	512

五、BERT变体模型

BERT出现后，研究社区提出了多种改进变体，从不同角度提升了原始BERT的性能和效率。

5.1 RoBERTa（Robustly Optimized BERT Approach）

由Facebook AI提出，对BERT进行了多项关键优化：

去除NSP任务

实验发现NSP任务对模型性能有负面影响，去除NSP后模型在多项任务上表现更好。

更大规模训练数据

使用CC-News、OpenWebText、Stories等更多样化的大规模数据集，总计约160GB。

更长的训练时间和更大的Batch Size

训练步数从100万增加到50万，但Batch Size从256增加到8000（相当于训练数据量增加8倍）。

动态遮蔽策略

每次训练时动态生成遮蔽模式，而不是在预处理时固定遮蔽位置。

5.2 ALBERT（A Lite BERT）

由谷歌提出，主要针对模型参数量过大的问题：

参数共享

所有Transformer层共享相同的权重参数，大幅减少参数量。ALBERT-base参数量从1.1亿减少到1200万。

句子顺序预测（SOP）

用SOP替代NSP作为第二个预训练任务。SOP要求模型区分正常顺序和逆序的句子对，比NSP更具挑战性。

嵌入层分解

将大词汇表的高维嵌入矩阵分解为两个小矩阵，减少参数量。

5.3 DistilBERT（Distilled BERT）

基于知识蒸馏技术，将BERT模型压缩为更小的版本：

蒸馏策略

使用BERT-base作为教师模型，训练一个更小的学生模型（6层）。学生模型学习教师模型的软标签概率分布。

参数量减少

模型大小减少40%，速度提升60%，保留97%的性能。

5.4 SpanBERT

针对span（文本片段）相关任务优化的变体：

随机区间遮蔽

不是遮蔽单个词元，而是遮蔽随机长度的连续文本区间。

Span Boundary Objective（SBO）

利用区间边界词元的表示来预测被遮蔽区间的内容，帮助模型学习区间级别的语义。

六、使用Hugging Face Transformers

Hugging Face Transformers是目前最流行的NLP模型库，提供了丰富的预训练模型和便捷的API。以下介绍如何使用Hugging Face进行BERT模型的加载、分词和微调。

6.1 环境配置

# 安装必要的库 pip install torch transformers datasets scikit-learn

6.2 加载预训练模型与分词器

from transformers import BertTokenizer, BertForSequenceClassification import torch  # 加载预训练的分词器和模型 # 这里使用BERT的中文预训练模型 model_name = "bert-base-chinese"  tokenizer = BertTokenizer.from_pretrained(model_name) model = BertForSequenceClassification.from_pretrained( model_name, num_labels=2 # 二分类任务，如情感分析 )  print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}") # 输出: 模型参数量: 102,267,648  # 单句分词示例 text = "今天天气真好，适合出去游玩" tokens = tokenizer.tokenize(text) token_ids = tokenizer.encode(text)  print(f"原始文本: {text}") print(f"分词结果: {tokens}") print(f"Token IDs: {token_ids}")

输出示例：

原始文本: 今天天气真好，适合出去游玩 分词结果: ['今', '天', '天', '气', '真', '好', '，', '适', '合', '出', '去', '游', '玩'] Token IDs: [101, 791, 1921, 1921, 3698, 4761, 1155, 1415, 6588, 1166, 1099, 2173, 6779, 102]

句子对分词示例：

# 句子对输入（如自然语言推理任务） sentence1 = "今天天气很好" sentence2 = "今天是晴天"  # 返回包含两个句子信息的编码 encoding = tokenizer( sentence1, sentence2, padding=True, truncation=True, max_length=128, return_tensors="pt" )  print(f"Input IDs: {encoding['input_ids']}") print(f"Token Type IDs: {encoding['token_type_ids']}") # 区分句子 print(f"Attention Mask: {encoding['attention_mask']}")

6.3 文本分类微调完整代码

以下是使用BERT进行文本分类（情感分析）的完整微调代码：

import torch from transformers import BertTokenizer, BertForSequenceClassification, AdamW, get_linear_schedule_with_warmup from torch.utils.data import DataLoader, TensorDataset, RandomSampler, SequentialSampler from sklearn.model_selection import train_test_split import numpy as np  # ------------------- 配置参数 ------------------- model_name = "bert-base-chinese" max_length = 128 batch_size = 16 epochs = 3 learning_rate = 2e-5 warmup_ratio = 0.1  # ------------------- 准备数据 ------------------- # 假设我们有以下训练数据（实际应用中从文件或数据库加载） train_texts = [ "这家餐厅的菜品非常好吃，服务也很棒！", "环境很差，噪音很大，不推荐", "性价比很高，会再次光顾", "价格太贵，质量一般", "物流很快，包装完好", "等了很久才送到，有点失望", ]  train_labels = [1, 0, 1, 0, 1, 0] # 1:正面, 0:负面  # 划分训练集和验证集 train_texts, val_texts, train_labels, val_labels = train_test_split( train_texts, train_labels, test_size=0.2, random_state=42 )  # ------------------- 数据编码 ------------------- tokenizer = BertTokenizer.from_pretrained(model_name)  def encode_texts(texts, labels): """将文本编码为模型输入格式""" input_ids = [] attention_masks = [] for text in texts: # encode_plus 返回字典包含 input_ids, attention_mask 等 encoded = tokenizer.encode_plus( text, add_special_tokens=True, # 添加 [CLS] 和 [SEP] max_length=max_length, # 最大长度 padding='max_length', # 填充到最大长度 truncation=True, # 截断超长序列 return_attention_mask=True, # 返回注意力掩码 return_tensors='pt' # 返回PyTorch张量 ) input_ids.append(encoded['input_ids']) attention_masks.append(encoded['attention_mask']) # 将列表中的张量堆叠成一个张量 input_ids = torch.cat(input_ids, dim=0) attention_masks = torch.cat(attention_masks, dim=0) labels = torch.tensor(labels) return TensorDataset(input_ids, attention_masks, labels)  # 创建数据集和数据加载器 train_dataset = encode_texts(train_texts, train_labels) val_dataset = encode_texts(val_texts, val_labels)  train_dataloader = DataLoader( train_dataset, sampler=RandomSampler(train_dataset), # 随机采样 batch_size=batch_size )  val_dataloader = DataLoader( val_dataset, sampler=SequentialSampler(val_dataset), # 顺序采样 batch_size=batch_size )  # ------------------- 加载模型 ------------------- model = BertForSequenceClassification.from_pretrained( model_name, num_labels=2, output_attentions=False, output_hidden_states=False )  # ------------------- 优化器和学习率调度器 ------------------- # 计算总训练步数和warmup步数 total_steps = len(train_dataloader) * epochs warmup_steps = int(total_steps * warmup_ratio)  optimizer = AdamW(model.parameters(), lr=learning_rate, eps=1e-8) scheduler = get_linear_schedule_with_warmup( optimizer, num_warmup_steps=warmup_steps, num_training_steps=total_steps )  # ------------------- 训练函数 ------------------- def train_epoch(model, dataloader, optimizer, scheduler): """训练一个epoch""" model.train() total_loss = 0 for batch in dataloader: # 从batch中取出数据 input_ids, attention_mask, labels = batch # 前向传播 outputs = model( input_ids=input_ids, attention_mask=attention_mask, labels=labels ) loss = outputs.loss total_loss += loss.item() # 反向传播 loss.backward() # 梯度裁剪，防止梯度爆炸 torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() scheduler.step() optimizer.zero_grad() return total_loss / len(dataloader)  def evaluate(model, dataloader): """评估模型""" model.eval() correct = 0 total = 0 with torch.no_grad(): for batch in dataloader: input_ids, attention_mask, labels = batch outputs = model( input_ids=input_ids, attention_mask=attention_mask ) predictions = torch.argmax(outputs.logits, dim=1) correct += (predictions == labels).sum().item() total += labels.size(0) return correct / total  # ------------------- 开始训练 ------------------- print("开始训练...") for epoch in range(epochs): train_loss = train_epoch(model, train_dataloader, optimizer, scheduler) val_accuracy = evaluate(model, val_dataloader) print(f"Epoch {epoch+1}/{epochs}") print(f" 训练损失: {train_loss:.4f}") print(f" 验证准确率: {val_accuracy:.4f}") print()  print("训练完成！")  # ------------------- 模型预测 ------------------- model.eval()  def predict(text): """对新文本进行预测""" encoded = tokenizer.encode_plus( text, add_special_tokens=True, max_length=max_length, padding='max_length', truncation=True, return_tensors='pt' ) with torch.no_grad(): outputs = model( input_ids=encoded['input_ids'], attention_mask=encoded['attention_mask'] ) prediction = torch.argmax(outputs.logits, dim=1).item() return "正面情感" if prediction == 1 else "负面情感"  # 测试预测 test_texts = [ "这家店的东西真不错，强烈推荐", "太失望了，完全不推荐" ]  for text in test_texts: result = predict(text) print(f"文本: {text}") print(f"预测: {result}\n")

6.4 命名实体识别（NER）微调示例

以下代码展示如何使用BERT进行命名实体识别任务：

from transformers import BertTokenizer, BertForTokenClassification, BertConfig import torch from torch.utils.data import DataLoader, TensorDataset import numpy as np  # ------------------- 配置 ------------------- model_name = "bert-base-chinese" max_length = 64 batch_size = 16 num_epochs = 3 learning_rate = 3e-5  # NER标签定义（ BIO标注模式） # B-: 实体的开始 # I-: 实体的延续 # O: 非实体 label_list = ['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', 'B-ORG', 'I-ORG'] label_to_id = {label: i for i, label in enumerate(label_list)} id_to_label = {i: label for i, label in enumerate(label_list)}  # ------------------- 准备数据 ------------------- # 训练数据格式：(token列表, 标签列表) train_data = [ (["北", "京", "是", "中", "国", "的", "首", "都"], ["B-LOC", "I-LOC", "O", "B-LOC", "I-LOC", "O", "B-LOC", "I-LOC"]), (["约", "翰", "在", "纽", "约", "工", "作"], ["B-PER", "I-PER", "O", "B-LOC", "I-LOC", "O", "O"]), ]  # ------------------- 数据编码 ------------------- tokenizer = BertTokenizer.from_pretrained(model_name)  def encode_ner_data(texts_labels, max_length): """编码NER数据，处理词级别到子词级别的对齐""" input_ids_list = [] attention_mask_list = [] labels_list = [] for tokens, labels in texts_labels: # 对每个token进行分词（可能分词成多个子词） token_ids = [] label_ids = [] for token, label in zip(tokens, labels): sub_tokens = tokenizer.tokenize(token) if len(sub_tokens) == 0: sub_tokens = [tokenizer.unk_token] # 第一个子词使用原标签，后续子词使用I-标签（如果原标签是B-） for i, sub_token in enumerate(sub_tokens): token_ids.append(tokenizer.convert_tokens_to_ids(sub_token)) if i == 0: label_ids.append(label_to_id.get(label, 0)) else: # 如果原标签是B-xxx，需要转换为I-xxx if label.startswith('B-'): new_label = 'I-' + label[2:] label_ids.append(label_to_id.get(new_label, 0)) else: label_ids.append(label_to_id.get(label, 0)) # 添加特殊token input_ids = [tokenizer.cls_token_id] + token_ids + [tokenizer.sep_token_id] label_ids = [label_to_id['O']] + label_ids + [label_to_id['O']] # 截断 input_ids = input_ids[:max_length] label_ids = label_ids[:max_length] # 填充 padding_length = max_length - len(input_ids) input_ids = input_ids + [tokenizer.pad_token_id] * padding_length label_ids = label_ids + [label_to_id['O']] * padding_length # 生成attention_mask attention_mask = [1 if token_id != tokenizer.pad_token_id else 0 for token_id in input_ids] input_ids_list.append(input_ids) attention_mask_list.append(attention_mask) labels_list.append(label_ids) return ( torch.tensor(input_ids_list), torch.tensor(attention_mask_list), torch.tensor(labels_list) )  # 编码训练数据 input_ids, attention_masks, labels = encode_ner_data(train_data, max_length) train_dataset = TensorDataset(input_ids, attention_masks, labels) train_dataloader = DataLoader(train_dataset, batch_size=batch_size)  # ------------------- 加载模型 ------------------- model = BertForTokenClassification.from_pretrained( model_name, num_labels=len(label_list), hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1 )  # ------------------- 训练配置 ------------------- optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)  # ------------------- 训练循环 ------------------- print("开始NER任务训练...") for epoch in range(num_epochs): model.train() total_loss = 0 for batch in train_dataloader: input_ids_batch, attention_mask_batch, labels_batch = batch optimizer.zero_grad() outputs = model( input_ids=input_ids_batch, attention_mask=attention_mask_batch, labels=labels_batch ) loss = outputs.loss total_loss += loss.item() loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() print(f"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss/len(train_dataloader):.4f}")  print("训练完成！")  # ------------------- 预测示例 ------------------- def predict_ner(text): """对新文本进行NER预测""" model.eval() # 编码 encoded = tokenizer( text, return_tensors='pt', padding=True, truncation=True, max_length=max_length ) with torch.no_grad(): outputs = model( input_ids=encoded['input_ids'], attention_mask=encoded['attention_mask'] ) predictions = torch.argmax(outputs.logits, dim=2) pred_labels = [id_to_label[p.item()] for p in predictions[0]] # 去掉特殊token tokens = tokenizer.convert_ids_to_tokens(encoded['input_ids'][0]) results = [(t, l) for t, l in zip(tokens, pred_labels) if t not in ['[CLS]', '[SEP]', '[PAD]']] return results  # 测试 text = "约翰在北京工作" results = predict_ner(text) print(f"\n文本: {text}") print("实体识别结果:") for token, label in results: if label != 'O': print(f" {token}: {label}")

七、BERT的使用场景

BERT及其变体模型在NLP领域有着广泛的应用场景，下面详细介绍几个典型应用。

7.1 文本分类

文本分类是最基础也是最广泛的应用场景，包括：

情感分析：判断文本的情感倾向（正面/负面/中性）
主题分类：将新闻、文档等分类到预定义的类别
垃圾邮件检测：识别垃圾邮件
意图识别：理解用户 query 的意图

典型流程：

将待分类文本输入BERT
取[CLS]token的隐藏状态作为句子表示
连接一个分类层（Linear）进行分类

7.2 命名实体识别（NER）

NER用于从文本中识别出特定类型的实体，如人名、地名、机构名等。

应用场景：

医疗领域：识别疾病名称、药物名称
金融领域：识别公司名称、股票代码
搜索引擎：增强搜索的语义理解能力

技术要点：

采用Token Classification方式，每个token输出一个标签
使用BIO或BIOES标注模式
需要处理词级别到子词级别的对齐

7.3 问答系统

BERT在问答系统中有两种主要应用方式：

抽取式问答：从给定文档中抽取答案片段

将问题-文档对作为输入
学习预测答案的起始和结束位置
使用BertForQuestionAnswering模型

多选式问答：从多个选项中选择正确答案

将问题和每个选项组合
选择得分最高的选项

7.4 句子相似度计算

应用场景：

语义匹配：判断两个句子的语义是否相似
paraphrase检测：检测文本是否表达相同含义
信息检索：匹配 query 与文档的语义相关性

实现方法：

from transformers import BertModel import torch import torch.nn as nn  class SentenceSimilarityModel(nn.Module): def __init__(self, model_name): super().__init__() self.bert = BertModel.from_pretrained(model_name) self.cosine_sim = nn.CosineSimilarity() def forward(self, sent1_ids, sent2_ids): # 获取[CLS]token的表示 output1 = self.bert(sent1_ids) output2 = self.bert(sent2_ids) cls1 = output1.last_hidden_state[:, 0, :] # [CLS] token cls2 = output2.last_hidden_state[:, 0, :] # 计算余弦相似度 similarity = self.cosine_sim(cls1, cls2) return similarity