BERT动态词嵌入模型入门指南：从原理到实战应用

1次阅读

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

传统静态词嵌入（如 Word2Vec）为每个单词分配固定向量，无法解决一词多义问题。例如：

# Word2Vec 中 "bank" 的向量固定
vec_bank1 = model.wv['bank']  # 河岸
vec_bank2 = model.wv['bank']  # 银行
assert np.allclose(vec_bank1, vec_bank2)  # 永远为 True

而 BERT 基于 Transformer 架构，通过 self-attention 机制动态生成词向量。其核心公式：

$$
\text{Attention}(Q,K,V)=\text{softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

其中 $Q$（Query）、$K$（Key）、$V$（Value）是同一输入的不同线性变换，$d_k$ 为向量维度。这种机制使每个词的向量会根据上下文动态调整。

pip install transformers torch

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

# 示例文本处理
text = "The cat sat on the mat"
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
print(inputs)
# 输出: {'input_ids': tensor([[  101,  1996,  4937,  2038,  2006,  1996,  4818,   102]]), 
#        'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1]])}

import torch
from transformers import BertForSequenceClassification

model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)

# 模拟训练循环
for epoch in range(3):
    outputs = model(**inputs, labels=torch.tensor([1]))
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
    print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

# 保存模型
model.save_pretrained("./saved_model")

# 加载模型进行推理
loaded_model = BertForSequenceClassification.from_pretrained("./saved_model")
with torch.no_grad():
    outputs = loaded_model(**inputs)
    logits = outputs.logits
    pred = torch.argmax(logits, dim=1)
    print(f"Predicted class: {pred.item()}")

解决方案：
减小 batch_size（通常从 32 开始尝试）
使用梯度累积（见性能优化章节）
启用混合精度训练

# 分段处理长文本
def process_long_text(text, max_length=512):
    chunks = [text[i:i+max_length] for i in range(0, len(text), max_length)]
    return [tokenizer(chunk, return_tensors="pt") for chunk in chunks]

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()
for input_data in dataloader:
    with autocast():
        outputs = model(**input_data)
        loss = outputs.loss
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

accumulation_steps = 4
for i, input_data in enumerate(dataloader):
    outputs = model(**input_data)
    loss = outputs.loss / accumulation_steps
    loss.backward()

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