BERT Embedding模型微调实战：从零开始构建高效语义表示

1次阅读

没有评论

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

BERT 作为自然语言处理领域的里程碑模型，其生成的 Embedding 能够捕捉丰富的语义信息。但在实际业务场景中，直接使用预训练 BERT 的 Embedding 往往效果不佳，原因在于：

预训练任务（MLM/NSP）与下游任务目标不一致
领域术语和业务特定语义未被充分学习
长文本建模方式需要调整

微调 BERT Embedding 的核心价值在于：让模型输出的向量表示更适配具体业务需求。比如在电商搜索场景，经过微调的 Embedding 能让 ” 手机 ” 和 ” 智能手机 ” 的向量更接近，而与 ” 手环 ” 保持距离。

优点：训练速度快，资源消耗低
缺点：无法适应领域差异，表征能力受限

优点：模型容量全开，适应性强
缺点：需要更多数据，容易过拟合

实践建议：
– 数据量 <1 万条：先尝试冻结 BERT+ 分类头
– 数据量 1 -10 万：仅微调最后 3 - 4 层
– 数据量 >10 万：全参数微调 + 正则化

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# 文本规范化示例
def preprocess(text):
    # 特殊字符处理
    text = text.replace('\n', ' ').strip()
    # 最大长度根据业务场景调整
    return tokenizer(text, padding='max_length', 
                    max_length=128, 
                    truncation=True,
                    return_tensors='pt')

关键点：
– 中文文本需注意分词一致性
– 长文本建议采用滑动窗口分段处理
– 实际 max_length 应覆盖 95% 样本即可

import torch
from transformers import BertModel

class BertEmbedder(torch.nn.Module):
    def __init__(self, pooling='mean'):
        super().__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.pooling = pooling

    def forward(self, input_ids, attention_mask):
        outputs = self.bert(input_ids, attention_mask=attention_mask)

        # Pooling 策略选择
        if self.pooling == 'cls':
            embeddings = outputs.last_hidden_state[:, 0, :]
        elif self.pooling == 'mean':
            embeddings = (outputs.last_hidden_state * 
                         attention_mask.unsqueeze(-1)).sum(1) \
                         / attention_mask.sum(-1).unsqueeze(-1)
        return embeddings

Pooling 策略对比：
– cls：适合分类任务，直接使用 [CLS] 标签
– mean：通用性最好，考虑所有 token 贡献
– max：突出显著特征，适合短文本

import torch.nn.functional as F

def contrastive_loss(emb1, emb2, label, margin=1.0):
    distance = F.pairwise_distance(emb1, emb2)
    loss = (1-label) * distance.pow(2) + \
           label * F.relu(margin - distance).pow(2)
    return loss.mean()

def triplet_loss(anchor, positive, negative, margin=0.5):
    pos_dist = F.pairwise_distance(anchor, positive)
    neg_dist = F.pairwise_distance(anchor, negative)
    return F.relu(pos_dist - neg_dist + margin).mean()

选择依据：
– 有明确正负样本对：对比损失
– 能构建三元组：三元组损失
– 监督信号弱：可尝试 ArcFace 等度量学习方法

from torch.utils.data import DataLoader
from transformers import AdamW

# 初始化
model = BertEmbedder(pooling='mean')
optimizer = AdamW(model.parameters(), lr=2e-5)

def train_epoch(dataloader):
    model.train()
    total_loss = 0

    for batch in dataloader:
        optimizer.zero_grad()

        # 获取 batch 数据
        input_ids = batch['input_ids']
        attention_mask = batch['attention_mask']
        emb1 = model(input_ids, attention_mask)

        # 假设是对比学习任务
        emb2 = model(batch['input_ids2'], batch['attention_mask2'])
        loss = contrastive_loss(emb1, emb2, batch['label'])

        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

        total_loss += loss.item()

    return total_loss / len(dataloader)

文本层面：
同义词替换（WordNet/ 领域词典）
随机删除非关键实体
回译增强（中 -> 英 -> 中）
Embedding 层面：
MixUp：λ*emb1 + (1-λ)*emb2
对抗训练：FGSM 扰动输入

from transformers import get_linear_schedule_with_warmup

# 训练前添加
num_training_steps = len(dataloader) * epochs
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=100,
    num_training_steps=num_training_steps
)

# 每个 batch step 后调用
scheduler.step()

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

with autocast():
    embeddings = model(input_ids, attention_mask)
    loss = contrastive_loss(emb1, emb2, labels)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()