BERT基础教程：从Transformer原理到实战避坑指南

1次阅读

共计 3441 个字符，预计需要花费 9 分钟才能阅读完成。

Transformer 彻底改变了 NLP 领域的游戏规则，它通过 Self-Attention（自注意力）机制解决了 RNN/LSTM 难以并行化和长距离依赖捕捉的痛点。与传统序列模型相比，Transformer 能够同时处理整个输入序列，并通过多头注意力（Multi-Head Attention）实现不同位置间的直接交互。这种架构突破使得模型在保持高效训练的同时，显著提升了语义理解能力。

传统语言模型（如 GPT）采用单向上下文编码，而 BERT 通过同时考虑左右上下文实现真正的双向理解。这种设计在处理歧义词时效果显著，例如在句子 ” 银行的存款利率 ” 中，” 银行 ” 的语义可以同时参考前后文确定。

BERT 在预训练时随机遮盖 15% 的输入 token（其中 80% 替换为[MASK]，10% 随机替换，10% 保持不变），迫使模型通过上下文预测原始词汇。这种训练目标让模型学会深层次的语义关系，而非简单的词共现统计。

为理解句子间关系，BERT 引入二分类任务判断两个句子是否连续。例如输入([CLS] 今天天气很好 [SEP] 我去了公园 [SEP])，模型需要判断第二句是否为第一句的合理后续。虽然后续研究发现 NSP 效果有限，但在原始 BERT 中仍是重要组成部分。

（示意图说明：左侧为 Transformer Encoder 堆叠，右侧展示 MLM 和 NSP 任务）

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import Dataset, DataLoader
import numpy as np

# 确保使用 GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len=512):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len

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

    def __getitem__(self, idx):
        text = str(self.texts[idx])
        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_len,
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt'
        )
        return {'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(self.labels[idx], dtype=torch.long)
        }

def collate_fn(batch):
    # 动态 padding 到批次内最大长度
    input_ids = [item['input_ids'] for item in batch]
    attention_mask = [item['attention_mask'] for item in batch]
    labels = [item['labels'] for item in batch]

    input_ids = torch.nn.utils.rnn.pad_sequence(input_ids, batch_first=True)
    attention_mask = torch.nn.utils.rnn.pad_sequence(attention_mask, batch_first=True)

    return {
        'input_ids': input_ids,
        'attention_mask': attention_mask,
        'labels': torch.stack(labels)
    }

model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=2).to(device)
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

# 假设已有 train_dataset
batch_size = 8
accum_steps = 4  # 每 4 个 batch 更新一次梯度
train_loader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=collate_fn)

model.train()
for epoch in range(3):
    total_loss = 0
    optimizer.zero_grad()

    for step, batch in enumerate(train_loader):
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss / accum_steps  # 损失按累积步数平均
        loss.backward()

        if (step + 1) % accum_steps == 0:
            optimizer.step()
            optimizer.zero_grad()

        total_loss += loss.item() * accum_steps

    print(f'Epoch {epoch}, Loss: {total_loss / len(train_loader)}')

max_seq_length	显存占用(GB)	备注
128	3.2	适合大多数分类任务
256	5.1	平衡选择
512	9.8	接近 BERT 上限

测试环境：NVIDIA V100 32GB, batch_size=8

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()

with autocast():
    outputs = model(**batch)
    loss = outputs.loss / accum_steps

scaler.scale(loss).backward()
if (step + 1) % accum_steps == 0:
    scaler.step(optimizer)
    scaler.update()
    optimizer.zero_grad()

实测加速比：1.7 倍（V100 FP16 vs FP32）