BERT模型微调实战：从原理到生产环境避坑指南

1次阅读

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

直接使用预训练 BERT 处理下游任务时，开发者常遇到两个核心问题：

领域鸿沟 ：预训练语料（如 Wikipedia）与医疗 / 金融等垂直领域文本分布差异显著
资源瓶颈 ：12 层 Transformer 的 base 版 BERT 在训练时显存占用常超过 10GB

有趣的是，即使像情感分析这样的简单任务，直接使用 BERT 的 CLS 向量分类，效果可能不如精心设计的 LSTM 模型——这说明预训练与微调之间存在关键的技术断层。

from transformers import BertModel
bert = BertModel.from_pretrained('bert-base-uncased', output_hidden_states=True)
# 冻结所有参数
for param in bert.parameters():
    param.requires_grad = False 
# 只使用最后四层隐藏状态的均值作为特征
hidden_states = bert(input_ids)[2][-4:]  # 获取最后 4 层输出
features = torch.mean(torch.stack(hidden_states), dim=0)  # [batch, seq_len, hid_dim]

适用场景 ：
– 标注数据少于 1000 条
– 需要快速原型验证
– 硬件资源极度受限（如单张 T4 显卡）

from transformers import BertForSequenceClassification
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased', 
    num_labels=2,
    output_attentions=True  # 可视化注意力时需要
)
# ** 学习率推荐 **：# 分类头：5e-4 
# 底层 Transformer：2e-5
optimizer = AdamW([{'params': model.bert.parameters(), 'lr': 2e-5},
    {'params': model.classifier.parameters(), 'lr': 5e-4}
])

决策树 ：

graph TD
    A[数据量 >10K?] -->|Yes| B[全参数微调]
    A -->|No| C{GPU 显存 >16GB?}
    C -->|Yes| D[尝试最后一层微调]
    C -->|No| E[特征提取模式]

数学原理：
$$\eta_l = \eta_{base} \times \alpha^{L-l+1}$$
其中 $l$ 为层数（顶层为 1），$\alpha$ 常取 0.95

PyTorch 实现：

from torch.optim import AdamW

# 分层设置学习率
optimizer_grouped_parameters = []
for layer_idx in range(12):  # BERT-base 共 12 层
    lr = 2e-5 * (0.95 ** (12 - layer_idx))  # 底层学习率最小
    optimizer_grouped_parameters.append({"params": [p for n,p in model.named_parameters() 
                  if f"encoder.layer.{layer_idx}." in n],
        "lr": lr
    })
# 分类头单独设置
optimizer_grouped_parameters.append({"params": [p for n,p in model.named_parameters() 
              if "classifier" in n or "pooler" in n],
    "lr": 5e-4
})
optimizer = AdamW(optimizer_grouped_parameters)

梯度累积 （模拟更大 batch_size）：

for step, batch in enumerate(train_loader):
    batch = {k:v.to(device) for k,v in batch.items()}
    outputs = model(**batch)
    loss = outputs.loss
    # 累加 4 个 batch 的梯度再更新
    loss = loss / 4  # 梯度归一化
    loss.backward()

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

混合精度训练 （FP16+FP32）：

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()
for batch in train_loader:
    with autocast():  # 自动选择精度
        outputs = model(**batch)
    scaler.scale(outputs.loss).backward()
    scaler.step(optimizer)
    scaler.update()

from sklearn.utils.class_weight import compute_class_weight

# 计算类别权重
class_weights = compute_class_weight(
    class_weight='balanced',
    classes=np.unique(train_labels),
    y=train_labels
)
# ** 关键参数 **：# weight=torch.tensor([0.7, 1.3], device=device)
criterion = nn.CrossEntropyLoss(weight=class_weights)

梯度检查点 （时间换空间）：

model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased', 
    num_labels=2,
    gradient_checkpointing=True  # 减少 30% 显存占用
)

动态 padding（避免统一填充到最大长度）

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(
    tokenizer=tokenizer,
    padding='longest',  # 按 batch 内最长文本填充
    max_length=512  # 硬限制
)

LoRA 微调 （仅训练低秩矩阵）

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=8,  # 秩大小
    target_modules=["query", "value"],  # 只微调注意力部分
)
model = get_peft_model(model, config)  # 可训练参数减少 90%