BERT预训练模型公式解析：从数学原理到实践应用

1次阅读

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

BERT（Bidirectional Encoder Representations from Transformers）是 2018 年由 Google 提出的预训练语言模型，其核心创新在于双向 Transformer 架构。相比传统单向语言模型（如 GPT），BERT 通过同时考虑上下文信息，显著提升了自然语言理解任务的性能。

突破性进展：在 11 项 NLP 任务上刷新 SOTA
核心优势：
上下文感知的词向量表示
通过预训练 + 微调范式适配多种下游任务
支持并行化计算

基础注意力计算公式：

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

其中：
– $Q$（Query）、$K$（Key）、$V$（Value）分别由输入向量线性变换得到
– $d_k$ 为 key 向量的维度，缩放因子防止点积结果过大

多头注意力扩展公式：

MultiHead(Q,K,V) = Concat(head_1,...,head_h)W^O

每个注意力头的计算：

head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)

解决 Transformer 缺少位置信息的问题：

PE_{(pos,2i)} = sin(pos/10000^{2i/d_{model}})
PE_{(pos,2i+1)} = cos(pos/10000^{2i/d_{model}})

预训练阶段的损失函数：

L = -\sum_{i=1}^N log P(x_i|x_{\backslash i})

特性	BERT	传统模型（如 LSTM）
上下文理解	双向	单向 / 浅层双向
长程依赖	全局注意力	逐步衰减
训练效率	预训练 + 微调	端到端训练
并行计算	完全支持	序列依赖

import torch
import torch.nn as nn
import math

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=512, h=8):
        super().__init__()
        self.d_k = d_model // h
        self.h = h

        # 线性变换矩阵
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x):
        batch_size = x.size(0)

        # 线性变换得到 Q /K/V [batch, seq_len, d_model]
        Q = self.W_q(x)
        K = self.W_k(x)
        V = self.W_v(x)

        # 分割多头 [batch, seq_len, h, d_k]
        Q = Q.view(batch_size, -1, self.h, self.d_k).transpose(1, 2)
        K = K.view(batch_size, -1, self.h, self.d_k).transpose(1, 2)
        V = V.view(batch_size, -1, self.h, self.d_k).transpose(1, 2)

        # 注意力得分 [batch, h, seq_len, seq_len]
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        attention = torch.softmax(scores, dim=-1)

        # 上下文向量 [batch, h, seq_len, d_k]
        context = torch.matmul(attention, V)

        # 合并多头 [batch, seq_len, d_model]
        context = context.transpose(1, 2).contiguous() \
                 .view(batch_size, -1, self.h * self.d_k)

        return self.W_o(context)