大模型原理与训练 / 系统课时

组装完整模型

组装完整模型

本课把前面实现的各个模块连接成一个可训练的序列到序列 Transformer。你将完成嵌入缩放、正弦位置编码、编码器与解码器调用、因果掩码和输出投影,并用一组批次张量验证网络输入输出形状。

学习目标

  • 理解完整 Transformer 中各组件的连接顺序与张量形状
  • 正确组合填充掩码和解码器因果掩码
  • 运行一次前向传播并验证输出可用于交叉熵训练

模型连接关系

完整模型包含源词嵌入、目标词嵌入、位置编码、编码器、解码器和词表输出层。源序列先被编码为上下文表示 memory;目标序列在因果掩码约束下逐位置读取 memory,最后通过线性层得到每个位置对目标词表的 logits。

嵌入向量通常乘以 dmodel\sqrt{d_{model}},用于补偿嵌入初始化尺度。位置编码与嵌入相加后形状不变,因此编码器和解码器始终接收 [batch, sequence, d_model] 张量。

完整 Transformer 的组件连接与数据流

完整实现

下面使用 PyTorch 的 nn.Transformer 组装最小可运行模型。示例采用 batch_first=True,使所有主要张量都按 [batch, sequence, feature] 排列,能直接接收上一课 DataLoader 生成的批次。

python
import math

import torch
from torch import nn

class PositionalEncoding(nn.Module):
    def __init__(self, d_model: int, max_len: int = 128) -> None:
        super().__init__()
        position = torch.arange(max_len).unsqueeze(1)
        div_term = torch.exp(
            torch.arange(0, d_model, 2)
            * (-math.log(10000.0) / d_model)
        )

        pe = torch.zeros(max_len, d_model)
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        self.register_buffer("pe", pe.unsqueeze(0))

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return x + self.pe[:, : x.size(1)]

class Seq2SeqTransformer(nn.Module):
    def __init__(
        self,
        src_vocab_size: int,
        tgt_vocab_size: int,
        d_model: int = 32,
        nhead: int = 4,
        num_layers: int = 2,
        dim_feedforward: int = 64,
        dropout: float = 0.0,
    ) -> None:
        super().__init__()
        self.d_model = d_model
        self.src_embedding = nn.Embedding(src_vocab_size, d_model)
        self.tgt_embedding = nn.Embedding(tgt_vocab_size, d_model)
        self.position = PositionalEncoding(d_model)
        self.transformer = nn.Transformer(
            d_model=d_model,
            nhead=nhead,
            num_encoder_layers=num_layers,
            num_decoder_layers=num_layers,
            dim_feedforward=dim_feedforward,
            dropout=dropout,
            batch_first=True,
        )
        self.output = nn.Linear(d_model, tgt_vocab_size)

    def forward(
        self,
        src: torch.Tensor,
        tgt_input: torch.Tensor,
        src_padding_mask: torch.Tensor,
        tgt_padding_mask: torch.Tensor,
    ) -> torch.Tensor:
        src_emb = self.position(
            self.src_embedding(src) * math.sqrt(self.d_model)
        )
        tgt_emb = self.position(
            self.tgt_embedding(tgt_input) * math.sqrt(self.d_model)
        )

        # 上三角 True 表示禁止当前位置关注未来词元。
        tgt_len = tgt_input.size(1)
        causal_mask = torch.triu(
            torch.ones(tgt_len, tgt_len, dtype=torch.bool, device=src.device),
            diagonal=1,
        )

        hidden = self.transformer(
            src=src_emb,
            tgt=tgt_emb,
            tgt_mask=causal_mask,
            src_key_padding_mask=src_padding_mask,
            tgt_key_padding_mask=tgt_padding_mask,
            memory_key_padding_mask=src_padding_mask,
        )
        return self.output(hidden)

def main() -> None:
    torch.manual_seed(7)
    model = Seq2SeqTransformer(
        src_vocab_size=20,
        tgt_vocab_size=30,
    )

    src = torch.tensor([
        [1, 5, 6, 2, 0],
        [1, 7, 8, 9, 2],
    ])
    tgt_input = torch.tensor([
        [1, 11, 12, 0],
        [1, 13, 14, 15],
    ])
    src_padding_mask = src.eq(0)
    tgt_padding_mask = tgt_input.eq(0)

    logits = model(
        src,
        tgt_input,
        src_padding_mask,
        tgt_padding_mask,
    )

    print("logits shape:", tuple(logits.shape))
    print("finite:", bool(torch.isfinite(logits).all()))
    print("target vocabulary size:", logits.size(-1))

if __name__ == "__main__":
    main()

预期输出如下。具体 logits 数值会受 PyTorch 版本和硬件影响,因此只验证稳定的结构属性。

text
logits shape: (2, 4, 30)
finite: True
target vocabulary size: 30

前向传播过程

源词编号先经过 src_embedding,目标词编号经过 tgt_embedding。两路嵌入都乘以 dmodel\sqrt{d_{model}} 并加上位置编码,随后分别进入 Transformer 的编码器和解码器。

编码器把源序列转换为 memory。解码器内部包含两类注意力:目标序列的自注意力只能查看当前位置及之前的位置;交叉注意力则读取完整 memory,使每个目标位置能够结合源句上下文。

输出层把解码器隐藏状态从 d_model 维映射到 tgt_vocab_size 维。对于形状 [2, 4, 30] 的结果,含义是批次有 2 个样本,每个目标序列有 4 个位置,每个位置都给出 30 个词元的未归一化分数。

掩码与训练接口

tgt_mask 是形状 [target_length, target_length] 的上三角布尔矩阵,负责阻止模型看到未来标签。src_key_padding_mask 与 tgt_key_padding_mask 则按样本屏蔽 <pad>;交叉注意力还要通过 memory_key_padding_mask 忽略源序列中的填充位置。

模型输出可直接交给交叉熵损失。下面是片段示例,依赖前文的 logits、目标标签 label 和目标填充值 tgt_pad_id。

python
criterion = nn.CrossEntropyLoss(ignore_index=tgt_pad_id)
loss = criterion(
    logits.reshape(-1, logits.size(-1)),
    label.reshape(-1),
)
loss.backward()

生效行为:损失只统计非填充标签,并把梯度传回输出层、解码器、编码器和两套嵌入。验证时应检查 loss.isfinite(),再确认至少一个可训练参数的 grad 不为 None。

常见边界

d_model 必须能被 nhead 整除,否则多头注意力无法平均划分特征维度。位置编码的 max_len 也必须覆盖数据中的最长序列;超出后会发生形状不匹配,应根据数据上限提前设置。

训练与推理使用的目标掩码逻辑相同,但输入来源不同。训练时一次传入右移后的完整目标序列;自回归推理时从 <bos> 开始,每次把已生成词元重新送入模型,并只取最后一个位置的 logits 选择下一个词。

本课总结

  • 完整 Transformer 按“嵌入与位置编码 → 编码器/解码器 → 输出投影”连接
  • 因果掩码防止目标位置读取未来信息,填充掩码防止模型关注 <pad>
  • 输出最后一维必须等于目标词表大小,才能与标签一起计算交叉熵损失

下一课预告

下一课将补齐训练循环,把数据批次、模型、优化器和损失函数连接起来,并观察损失是否能够稳定下降。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

组装完整模型

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通