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

编码器解码器模型

编码器解码器模型

编码器解码器模型把“理解输入序列”和“生成目标序列”分成两个协作模块。本课将连接自注意力、交叉注意力和输出映射,并用 PyTorch 构建一个可训练、可自回归生成的最小完整模型。

学习目标

  • 说明编码器、解码器和交叉注意力各自承担的职责
  • 跟踪源序列、目标序列与编码记忆之间的张量流向
  • 使用 PyTorch 完成训练前向计算和贪心生成

完整模型如何连接

编码器先读取整个源序列,通过多层自注意力生成上下文表示,通常称为 memory。解码器一边查看已经生成的目标前缀,一边通过交叉注意力查询 memory,最后将隐藏状态映射到目标词表。

编码器解码器模型数据流

解码器包含两类注意力。带因果掩码的自注意力负责建模目标前缀,交叉注意力则使用解码器状态作为查询,把编码器输出作为键和值。正是这条跨模块连接,让生成结果能够持续对齐输入内容。

张量如何在模型中流动

设批量大小为 B,源长度为 S,目标长度为 T,隐藏维度为 D,目标词表大小为 V。主要张量形状如下:

张量 形状 作用
源词元 src [B, S] 编码器输入
目标前缀 tgt_in [B, T] 解码器输入
编码记忆 memory [B, S, D] 供交叉注意力读取
输出 logits [B, T, V] 每个位置的词表分数

训练时,目标序列要右移:tgt_in 去掉最后一个词,标签去掉第一个词。推理时只有 <BOS> 和已生成前缀,模型每轮只取最后一个位置的 logits 选择下一个词。

PyTorch 最小实现

下面示例使用 nn.Transformer 组装编码器和解码器。模型包含词嵌入、可学习位置嵌入、词表输出层以及贪心解码方法,可直接运行。

python
import torch
from torch import nn

class EncoderDecoderTransformer(nn.Module):
    def __init__(
        self,
        src_vocab_size: int,
        tgt_vocab_size: int,
        d_model: int = 32,
        nhead: int = 4,
        num_layers: int = 1,
        max_len: int = 64,
    ) -> None:
        super().__init__()
        self.src_embedding = nn.Embedding(src_vocab_size, d_model)
        self.tgt_embedding = nn.Embedding(tgt_vocab_size, d_model)
        self.position_embedding = nn.Embedding(max_len, d_model)

        # nn.Transformer 内部已经包含编码器、解码器和交叉注意力
        self.transformer = nn.Transformer(
            d_model=d_model,
            nhead=nhead,
            num_encoder_layers=num_layers,
            num_decoder_layers=num_layers,
            batch_first=True,
        )
        self.output_layer = nn.Linear(d_model, tgt_vocab_size)

    def _add_position(self, tokens: torch.Tensor, embedding: nn.Embedding) -> torch.Tensor:
        positions = torch.arange(tokens.size(1), device=tokens.device)
        return embedding(tokens) + self.position_embedding(positions).unsqueeze(0)

    def forward(self, src: torch.Tensor, tgt_in: torch.Tensor) -> torch.Tensor:
        src_hidden = self._add_position(src, self.src_embedding)
        tgt_hidden = self._add_position(tgt_in, self.tgt_embedding)

        # 上三角负无穷掩码确保目标位置不能访问未来词元
        tgt_len = tgt_in.size(1)
        tgt_mask = torch.triu(
            torch.full((tgt_len, tgt_len), float("-inf"), device=tgt_in.device),
            diagonal=1,
        )
        hidden = self.transformer(
            src=src_hidden,
            tgt=tgt_hidden,
            tgt_mask=tgt_mask,
        )
        return self.output_layer(hidden)

    @torch.no_grad()
    def generate(
        self,
        src: torch.Tensor,
        bos_id: int,
        max_new_tokens: int,
    ) -> torch.Tensor:
        generated = torch.full(
            (src.size(0), 1),
            bos_id,
            dtype=torch.long,
            device=src.device,
        )

        # 每轮只使用最后一个位置的分数选择下一个词
        for _ in range(max_new_tokens):
            logits = self(src, generated)
            next_token = logits[:, -1].argmax(dim=-1, keepdim=True)
            generated = torch.cat([generated, next_token], dim=1)
        return generated

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

    src = torch.tensor([
        [4, 9, 12, 6, 3],
        [8, 5, 11, 7, 2],
    ])
    target = torch.tensor([
        [1, 10, 14, 18, 2],
        [1, 13, 16, 19, 2],
    ])

    tgt_in = target[:, :-1]
    labels = target[:, 1:]
    logits = model(src, tgt_in)

    loss_fn = nn.CrossEntropyLoss()
    loss = loss_fn(logits.reshape(-1, 30), labels.reshape(-1))
    generated = model.generate(src, bos_id=1, max_new_tokens=5)

    print("train logits:", tuple(logits.shape))
    print("loss finite:", torch.isfinite(loss).item())
    print("generated is matrix:", generated.ndim == 2)
    print("starts with BOS:", generated[:, 0].eq(1).all().item())

if __name__ == "__main__":
    main()

预期输出:

text
train logits: (2, 4, 30)
loss finite: True
generated is matrix: True
starts with BOS: True

示例中的模型尚未训练,因此生成的具体词元编号没有语义,且可能随 PyTorch 版本而变化。可验证的重点是训练输出形状、损失可计算,以及生成序列以 <BOS> 开始并按时间步扩展。

从教学模型走向真实任务

真实翻译或摘要系统还要补充源端与目标端填充掩码、分词器、词表、优化器、验证集和保存加载逻辑。推理阶段通常加入 <EOS> 提前停止、KV Cache、束搜索或采样策略。

训练数据必须成对组织,例如“源语言句子—目标语言句子”或“原文—摘要”。损失只计算有效目标词元,填充位置应通过 ignore_index 排除,否则模型会浪费容量学习 <PAD>。

验收模型连接是否正确

先检查 logits 是否为 [B, T, V],再确认目标输入已经右移。随后打乱源序列进行对比:如果模型训练后输出完全不受源输入影响,通常意味着交叉注意力、编码记忆或相关掩码连接有误。

还要确认推理阶段只把已生成词元送入解码器,不能把完整目标答案作为输入。训练可并行计算全部目标位置,生成则必须从 <BOS> 开始逐步展开。

本课总结

  • 编码器负责生成源序列记忆,解码器通过交叉注意力读取该记忆并生成目标序列
  • 训练使用右移目标序列计算 [B, T, V] 词表分数,推理则循环选择下一个词
  • 完整工程还需补充填充掩码、停止条件、数据管道和模型保存等能力

下一课预告

下一课将进一步讨论贪心搜索、束搜索与随机采样,比较不同解码策略对生成质量、速度和多样性的影响。

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

目录与阅读设置

阅读设置

17

记录一个想法

编码器解码器模型

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

登录哪都通