NLP之BERT预训练模型详解

初心未改HD2026-05-23 11:33

摘要： 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 的意图

典型流程：

  1. 将待分类文本输入BERT

  2. 取 [CLS] token的隐藏状态作为句子表示

  3. 连接一个分类层（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

八、BERT的局限性与未来发展

尽管BERT取得了巨大成功，但也存在一些局限性：

计算成本高昂

  • BERT-base有1.1亿参数，BERT-large有3.4亿参数

  • 预训练需要大量计算资源（BERT-base约需4个TPU，16块云计算实例）

  • 对硬件要求高，推理速度相对较慢

长文本处理受限

  • 最大序列长度为512 token

  • 对于需要处理长文档的场景不友好

  • 后续有Longformer、BigBird等模型尝试解决

预训练-微调不一致

  • 预训练使用[MASK] token，但微调阶段没有mask

  • 可能导致预训练和微调阶段的行为差异

缺乏可解释性

  • Transformer结构的注意力机制难以直观解释

  • 对于需要高度可解释性的应用场景不够友好

九、总结

BERT作为预训练语言模型的里程碑式工作，彻底改变了NLP领域的研究范式和应用格局。其核心贡献包括：

  1. 创新性的双向上下文建模：通过MLM任务实现真正的双向编码，捕捉更丰富的语义信息

  2. 统一的预训练-微调框架：一次预训练，多任务复用，大幅降低下游任务的数据需求

  3. 开源的预训练模型：Hugging Face Transformers等库使得BERT的使用变得极为便捷

  4. 丰富的模型变体：RoBERTa、ALBERT、DistilBERT等针对不同需求的优化版本

  5. 广泛的应用场景：文本分类、NER、问答、语义匹配等，几乎涵盖了NLP的主要任务

随着大语言模型（LLM）的发展，BERT作为encoder-only架构的代表，在特定场景（如需要同时理解输入两侧信息的任务）仍有其独特价值。理解BERT的原理和实现，对于深入学习NLP和深度学习技术具有重要的基础意义。

参考资料

相关推荐
蓦然回首却已人去楼空5 小时前
深度学习进阶：自然语言处理｜3.4 QA｜用 SimpleCBOW 讲清楚 backward 为什么有的 return，有的不 return
人工智能·深度学习·自然语言处理
初心未改HD6 小时前
NLP之GPT生成式模型详解
人工智能·自然语言处理
kcuwu.7 小时前
FastText技术博客：从原理到实战
自然语言处理·nlp
财经资讯数据_灵砚智能8 小时前
基于全球经济类多源新闻的NLP情感分析与数据可视化（夜间-次晨）2026年5月21日
大数据·人工智能·python·信息可视化·自然语言处理
放下华子我只抽RuiKe520 小时前
React 从入门到生产（四）：自定义 Hook
前端·javascript·人工智能·深度学习·react.js·自然语言处理·前端框架
Yingjun Mo1 天前
(二) LLM探索能力-1. 大语言模型能够进行上下文探索吗？
人工智能·语言模型·自然语言处理
财经资讯数据_灵砚智能1 天前
基于全球经济类多源新闻的NLP情感分析与数据可视化（夜间-次晨）2026年5月20日
人工智能·python·信息可视化·自然语言处理·ai编程·灵砚智能
tzc_fly1 天前
LLaDA2.0-Uni：基于扩散语言模型的统一多模态理解和生成
人工智能·语言模型·自然语言处理
Loo国昌1 天前
从 Agent 编排到 Skill Runtime：企业 AI 工程化的下一层抽象
大数据·人工智能·后端·python·自然语言处理
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法04装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？05裂开！ChatGPT 居然开始要手机号验证，附详细解决方法06CC-Switch & Claude 基于 Linux 服务器安装使用指南07【AI】2026 年具身智能模型和世界模型总结08几个好用的ip纯净度检测网站09codex app每次打开重连5次Reconnecting问题解决10用了半年 OpenRouter，我换到了 Ofox.ai — 两个 AI API 聚合平台的真实对比