深入解析BERT预训练模型结构图：从原理到实现细节

1次阅读

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

BERT（Bidirectional Encoder Representations from Transformers）是 Google 在 2018 年提出的预训练语言模型，通过掩码语言建模（MLM）和下一句预测（NSP）任务，实现了上下文相关的词向量表示。其核心创新在于：

首次实现真正意义上的双向 Transformer 结构
通过预训练 + 微调范式解决多种 NLP 任务
在 11 项自然语言处理任务上刷新记录

典型应用场景包括：文本分类、问答系统、命名实体识别等。相比传统 Word2Vec 等静态词向量，BERT 能根据上下文动态调整词义表示。

BERT 的基础单元是 Transformer 编码器堆叠，每个编码器包含：

多头自注意力层（Multi-Head Attention）
前馈神经网络层（Feed Forward）
残差连接（Residual Connection）
层归一化（Layer Normalization）

以 BERT-base 为例，共 12 层这样的结构堆叠。每层参数独立，但结构完全相同。

自注意力的核心公式：

Attention(Q,K,V) = softmax(QK^T/√d_k)V

实际计算分为三步：

将输入向量分别乘以 W_q、W_k、W_v 矩阵得到 Q、K、V
计算注意力分数并 scale
通过 softmax 归一化后加权求和

关键优势：任意两个词的距离都是 1，有效解决长距离依赖问题。

由于 Transformer 没有循环结构，需要显式加入位置信息。BERT 使用固定位置编码：

# 位置编码公式实现示例
position = torch.arange(0, max_len).float().unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)

将 Q、K、V 分割到多个头（BERT-base 为 12 个头）并行计算：

线性投影到 h 个不同子空间
各自计算注意力
结果拼接后再次线性变换

多头设计使模型能同时关注不同位置的语义信息。

class SelfAttention(nn.Module):
    def __init__(self, hidden_size, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = hidden_size // num_heads

        self.query = nn.Linear(hidden_size, hidden_size)
        self.key = nn.Linear(hidden_size, hidden_size)
        self.value = nn.Linear(hidden_size, hidden_size)

    def forward(self, x):
        # x shape: [batch, seq_len, hidden_size]
        batch_size = x.shape[0]

        Q = self.query(x)
        K = self.key(x)
        V = self.value(x)

        # 分头处理 [batch, seq_len, num_heads, head_dim]
        Q = Q.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        K = K.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        V = V.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)

        # 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)
        attention = torch.softmax(scores, dim=-1)

        # 加权求和
        context = torch.matmul(attention, V)
        context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.head_dim)

        return context