企业官网建设流程全解析

这次我们来看 Cohere 自己的技术博客对 Transformer 论文的复盘。

如果从 2017 年《Attention Is All You Need》发布算起，Transformer 已经从一篇论文变成了整个大模型时代的地基。Cohere 作为最早把大模型能力商业化落地的公司之一，它的创始团队与 Transformer 论文有直接的技术渊源。这篇回顾不是常见的科普鸡汤，而是从论文原文出发，把 Transformer 的架构拆开、把架构演变路径踩出来，顺带解释了为什么这篇论文能从最初的“期待几百次引用”一路涨到现在的 28 万多次引用。

对于正在做 NLP、CV、多模态或者大模型训练的开发者来说，这篇回顾的价值在于：它把 Transformer 里的编码器-解码器结构、自注意力机制、位置编码、多头注意力这些“你听过但不一定细想过”的概念，用工程视角重新串了一遍。

本篇文章会根据 Cohere 对 Transformer 论文的回顾内容，结合论文原文和主流实现方式，做一次完整技术拆解。我们会聊架构、聊注意力机制、聊位置编码，也会给出 PyTorch 代码、选型建议、训练/推理的踩坑清单和常见问题排查。不是只讲概念，而是把“从论文到工程”的每一步拉通。

如果你打算重新理解 Transformer，或者正在为面试、论文阅读、模型复现做准备，这篇文章可以直接收藏。

1. Transformer 论文值得关注的核心能力

从 Cohere 的回顾看，真正值得开发者注意的点有三个：

一是 Transformer 的并行化能力让它天然适配 GPU 计算。RNN 必须按时间步展开，Transformer 不需要，这让训练时间大幅缩短。

二是自注意力机制让模型可以直接建模任意两个位置之间的关系。长距离依赖问题从架构层面被解决了，而不是靠门控机制或者梯度裁剪硬撑。

三是这个架构可以被“拆装组合”。编码器可以单独拿出来做理解任务，解码器可以单独拿出来做生成任务，编码器-解码器可以做翻译、摘要、多模态任务。ViT 把编码器搬到了图像上，GPT 把解码器做成了生成引擎，Swin Transformer 又把窗口注意力引入了视觉领域。

2. 适用场景与使用边界

2.1 适合谁

• 做 NLP 模型训练和微调的开发者。Transformer 是 BERT、GPT、T5 等模型的底座，理解它能帮助你调试模型结构。
• 做多模态模型和跨模态对齐的工程师。CLIP、ViT、Flamingo 都依赖 Transformer 编码器。
• 做模型架构创新的研究工程师。不管是窗口注意力、稀疏注意力还是线性注意力，都是在 Transformer 基础上的改进。
• 做模型部署和推理优化的同学。理解 KV Cache、自回归解码、序列长度与显存的关系，是优化推理性能的前提。
• 准备面试或系统阅读论文的算法工程师。Transformer 是当前大模型面试里几乎必问的核心内容。

2.2 能解决什么问题

• 序列建模问题：文本、语音、视频、点云、高光谱图像都可以先转成 token/embedding，再用 Transformer 建模。
• 并行训练问题：多头注意力和前馈网络都支持 batch 维度的并行计算。
• 长距离依赖问题：自注意力直接计算所有位置之间的相关性，信息不会随着时间步递减。
• 迁移学习问题：预训练 + 微调范式是 Transformer 时代的标准做法。

2.3 不适合什么场景

• 低延迟、低功耗的边缘设备端实时推理，直接上完整 Transformer 会非常吃力，一般需要量化或蒸馏。
• 超长序列（百万级 token）场景，原生全量注意力复杂度是 O(n²)，需要窗口注意力、FlashAttention、线性注意力等优化方案。
• 数据量非常小的场景，Transformer 的容量大，容易过拟合，简单任务可以先用线性模型或树模型。
• 需要严格单步顺序依赖的任务，Transformer 对时间顺序的建模需要通过位置编码实现，本身并不天然包含时序信号。

2.4 版权、隐私与安全边界

Transformer 论文本身是公开学术文献，可以放心阅读和学习。复现和使用 Transformer 时要注意：

• 如果使用公开代码仓库，确认开源许可证是否允许商用。
• 如果使用预训练权重，确认模型的 License 是否限制商用、是否限制下游领域。
• 如果自己训练模型，训练数据的版权和隐私合规也要确认。
• 论文阅读笔记、博客总结如果引用了原文图表，建议标明参考来源。
• 涉及人脸、声音、医疗数据、金融数据等敏感内容时，必须先完成必要的授权和数据脱敏。

3. Transformer 架构全景：从论文到核心拆解

3.1 整体结构

Transformer 论文提出的架构是一个 Encoder-Decoder 结构：

• 编码器（Encoder）负责把输入序列编码成语义表征。
• 解码器（Decoder）负责根据编码结果和此前已生成的 token 逐步生成目标序列。
• 编码器部分由多个相同层堆叠而成，每层包含多头自注意力子层和位置逐前馈网络子层。
• 解码器部分每层包含掩码多头自注意力子层、编码器-解码器注意力子层和位置逐前馈网络子层。
• 每个子层后面都接了残差连接，然后做 LayerNorm。

这个结构的意义在于：编码器可以一次性看到全部输入序列，解码器生成时只能看到已生成的 token，通过掩码机制阻止未来信息泄漏。

3.2 多头自注意力机制

自注意力机制的核心公式是：

Attention(Q, K, V) = softmax(Q * K^T / sqrt(d_k)) * V

Q 是查询向量，K 是键向量，V 是值向量。Q 和 K 的点积表示两个位置之间的相关程度，除以 sqrt(d_k) 是为了防止点积结果过大导致 softmax 梯度消失。

多头注意力就是把 Q、K、V 投影成多组子空间，分别计算注意力，再拼接起来：

MultiHead(Q, K, V) = Concat(head_1, ..., head_h) * W_O

多头机制的价值在于：每个头可以关注不同位置的关系类型。一个头可能关注语法依赖，一个头可能关注指代关系，一个头可能关注局部共现。在视觉任务里，不同的头可能关注纹理、颜色、轮廓或者远处上下文。

3.3 位置编码

Transformer 没有循环结构，所以必须通过位置编码把位置信息注入序列：

• 论文使用正弦和余弦函数生成位置编码。
• 位置编码与 token embedding 相加后送入编码器。
• 后续很多模型改用可学习位置编码，例如 BERT。
• 再后来的模型引入了 RoPE（旋转位置编码），例如 LLaMA，它对长度外推更友好。
• 窗口注意力、Point Transformer、Swin Transformer 等模型也会针对任务重新设计位置编码。

正弦位置编码的特点是不需要额外参数，可以直接推导出任意位置的编码向量。但它不包含相对位置信息，所以后续的超长文本模型大多会换成 RoPE 或 ALiBi。

3.4 残差连接与 LayerNorm

残差连接解决深层网络梯度消失问题：

x = x + Sublayer(x)

LayerNorm 在特征维度方向做归一化，让每一层的输出分布更稳定。在 Transformer 原始实现中，LayerNorm 放在残差连接后的子层输出位置，也就是 Post-Norm。GPT-2 之后很多模型改用 Pre-Norm，把 LayerNorm 放到子层输入之前，结构更稳定，更适合大模型训练。

3.5 前馈网络

每个注意力子层后面接一个两层全连接网络：

FFN(x) = ReLU(x * W1 + b1) * W2 + b2

第一层把维度从 d_model 映射到 4 * d_model，第二层映射回 d_model。后面的模型大多把 ReLU 换成了 GELU 或 SwiGLU。

前馈网络是 Transformer 中参数量占比最大的部分，它做的事情就是对注意力输出做非线性变换和特征映射。

4. Transformer 复现环境准备

4.1 硬件建议

Transformer 是典型的可并行计算模型。

• 阅读代码、跑小规模实验：CPU 足够，PyTorch 的 CPU 版本即可。
• 训练小模型（几千万参数级别）：建议 6GB 以上显存的 GPU。
• 训练亿级参数模型：建议 24GB 以上显存，或者使用多卡 + 梯度累积。
• 推理部署：如果只做 CPU 推理，可以配合 INT8/INT4 量化来降低显存和内存占用。
• 显存占用主要由序列长度、batch size、模型维度、层数决定，实际占用需要根据自己的配置实测。

4.2 Python 环境

建议使用 Python 3.9 或 3.10，创建独立虚拟环境：

conda create -n transformer-lab python=3.10 conda activate transformer-lab pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 pip install numpy matplotlib tqdm tensorboard

如果没有 GPU，直接安装 CPU 版：

pip install torch --index-url https://download.pytorch.org/whl/cpu

4.3 项目目录规划

复现和实验时建议按下面结构组织文件：

transformer-lab/ ├── configs/ # 配置参数 ├── data/ # 训练数据 ├── models/ # 模型结构代码 ├── tokenizers/ # 分词器 ├── checkpoints/ # 模型权重 ├── logs/ # 训练日志 ├── outputs/ # 生成结果 └── scripts/ # 启动脚本

把输入、输出、权重、代码分开，批量实验时不会把目录搞乱。

5. Transformer 最小实现：代码级拆解

这一节给出一个可用于学习和验证的 PyTorch 最小实现。它不是一个生产级大模型代码库，而是帮助你理解每个组件的结构和形状变化。

5.1 多头自注意力实现

import torch import torch.nn as nn import math class MultiHeadAttention(nn.Module): def __init__(self, d_model, n_head, dropout=0.1): super().__init__() assert d_model % n_head == 0, "d_model must be divisible by n_head" self.d_model = d_model self.n_head = n_head self.d_k = d_model // n_head 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) self.dropout = nn.Dropout(dropout) def forward(self, query, key, value, mask=None): batch_size = query.size(0) Q = self.w_q(query).view(batch_size, -1, self.n_head, self.d_k).transpose(1, 2) K = self.w_k(key).view(batch_size, -1, self.n_head, self.d_k).transpose(1, 2) V = self.w_v(value).view(batch_size, -1, self.n_head, self.d_k).transpose(1, 2) scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn = torch.softmax(scores, dim=-1) attn = self.dropout(attn) context = torch.matmul(attn, V) context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) output = self.w_o(context) return output

这里的重点是理解维度变化：

• Q、K、V 经过线性层后 shape 为[batch, seq_len, d_model]。
• 拆成多头后变成[batch, n_head, seq_len, d_k]。
• attention scores 的 shape 是[batch, n_head, seq_len, seq_len]。
• 最后拼回[batch, seq_len, d_model]。

mask 的作用是让某些位置的注意力分数变成负无穷，softmax 后这些位置的概率趋近于 0，从而实现掩码效果。解码器训练时用来掩盖未来位置。

5.2 位置编码实现

class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=512, dropout=0.1): super().__init__() self.dropout = nn.Dropout(dropout) pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.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) pe = pe.unsqueeze(0) # shape: [1, max_len, d_model] self.register_buffer("pe", pe) def forward(self, x): x = x + self.pe[:, : x.size(1), :] return self.dropout(x)

这段代码的问题在于：pe[:, 0::2]要求d_model是偶数，因为position * div_term的 shape 是[max_len, d_model/2]。如果d_model是奇数，就需要额外处理。大多数实现默认d_model是偶数，实际使用时要留意。

5.3 编码器层实现

class FeedForward(nn.Module): def __init__(self, d_model, d_ff, dropout=0.1): super().__init__() self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x): return self.linear2(self.dropout(torch.relu(self.linear1(x)))) class EncoderLayer(nn.Module): def __init__(self, d_model, n_head, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, n_head, dropout) self.feed_forward = FeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) def forward(self, x, mask=None): # Post-Norm 结构，和原始论文一致 x = self.norm1(x + self.dropout1(self.self_attn(x, x, x, mask))) x = self.norm2(x + self.dropout2(self.feed_forward(x))) return x

注意这里的 Post-Norm 顺序是x + dropout(attn(x))之后再norm，和原始论文一致。Pre-Norm 的写法是先把 LayerNorm 放在子层输入之前。

5.4 编码器完整实现

class Encoder(nn.Module): def __init__(self, vocab_size, d_model, n_head, d_ff, n_layer, max_len, dropout=0.1): super().__init__() self.embedding = nn.Embedding(vocab_size, d_model) self.positional_encoding = PositionalEncoding(d_model, max_len, dropout) self.layers = nn.ModuleList([ EncoderLayer(d_model, n_head, d_ff, dropout) for _ in range(n_layer) ]) self.norm = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, src, mask=None): x = self.dropout(self.positional_encoding(self.embedding(src))) for layer in self.layers: x = layer(x, mask) return self.norm(x)

5.5 解码器层实现

解码器和编码器的区别在于：

• 第一层是掩码自注意力。
• 第二层是编码器-解码器注意力，其中 Q 来自解码器，K、V 来自编码器输出。
• 第三层是前馈网络。
• 每组子层后面也带残差连接和 LayerNorm。

class DecoderLayer(nn.Module): def __init__(self, d_model, n_head, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, n_head, dropout) self.cross_attn = MultiHeadAttention(d_model, n_head, dropout) self.feed_forward = FeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.norm3 = nn.LayerNorm(d_model) self.dropout1 = nn.Dropout(dropout) self.dropout2 = nn.Dropout(dropout) self.dropout3 = nn.Dropout(dropout) def forward(self, x, encoder_output, src_mask=None, tgt_mask=None): x = self.norm1(x + self.dropout1(self.self_attn(x, x, x, tgt_mask))) x = self.norm2(x + self.dropout2(self.cross_attn(x, encoder_output, encoder_output, src_mask))) x = self.norm3(x + self.dropout3(self.feed_forward(x))) return x

5.6 完整 Transformer 模型

class Transformer(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model=512, n_head=8, d_ff=2048, n_layer=6, max_len=512, dropout=0.1): super().__init__() self.encoder = Encoder(src_vocab_size, d_model, n_head, d_ff, n_layer, max_len, dropout) self.decoder = Decoder(tgt_vocab_size, d_model, n_head, d_ff, n_layer, max_len, dropout) self.output_proj = nn.Linear(d_model, tgt_vocab_size) def forward(self, src, tgt, src_mask=None, tgt_mask=None): encoder_output = self.encoder(src, src_mask) decoder_output = self.decoder(tgt, encoder_output, src_mask, tgt_mask) return self.output_proj(decoder_output)

这段代码包含了 Transformer 论文的全部核心结构。src_vocab_size和tgt_vocab_size根据数据集确定，d_model、n_head、d_ff、n_layer都是超参数。

5.7 生成函数

训练时模型以 teacher forcing 方式并行输入目标序列。推理时是自回归生成，每步只能输入上一步生成的结果：

@torch.no_grad() def greedy_decode(model, src, src_vocab_size, tgt_vocab_size, max_len, start_token, end_token, device): model.eval() src = src.to(device) encoder_output = model.encoder(src) tgt = torch.full((src.size(0), 1), start_token, dtype=torch.long, device=device) for _ in range(max_len): tgt_mask = generate_square_subsequent_mask(tgt.size(1)).to(device) decoder_output = model.decoder(tgt, encoder_output, tgt_mask=tgt_mask) logits = model.output_proj(decoder_output[:, -1, :]) next_token = logits.argmax(dim=-1, keepdim=True) tgt = torch.cat([tgt, next_token], dim=1) if (next_token == end_token).all(): break return tgt

自回归生成的瓶颈在于：每步都要重新跑一遍解码器，前面 token 的中间计算结果不会自动缓存。生产环境里一般会用 KV Cache 缓存上一次的 K 和 V，避免重复计算。

6. 训练效果与验证流程

6.1 测试目的

跑通一个最小 Transformer，验证以下能力：

• 前向传播和损失函数是否正常。
• 多头注意力、位置编码、掩码机制的形状是否正确。
• 模型在简单任务上能否收敛。
• 推理时自回归生成是否可用。

6.2 输入示例与数据准备

这里以最简单的“句子复制”任务为例：输入一串 token，输出与输入相同的 token 序列。用复制任务验证模型是否具备基础的序列建模能力。

def generate_copy_task(num_samples, vocab_size, max_len): src = [] tgt = [] for _ in range(num_samples): length = torch.randint(2, max_len - 1, (1,)).item() seq = torch.randint(1, vocab_size - 2, (length,)) src.append(torch.cat([torch.tensor([2]), seq, torch.tensor([3])])) # 2: BOS, 3: EOS tgt.append(torch.cat([torch.tensor([2]), seq, torch.tensor([3])])) return src, tgt

注意：tgt在训练时需要拆成tgt_input和tgt_output，前者去掉最后一个 token，后者去掉开头的BOS，这样才能对齐到 next token prediction。

6.3 训练与损失判断

def train_step(model, optimizer, criterion, src_batch, tgt_batch, device): model.train() optimizer.zero_grad() src = torch.nn.utils.rnn.pad_sequence(src_batch, batch_first=True).to(device) tgt = torch.nn.utils.rnn.pad_sequence(tgt_batch, batch_first=True).to(device) tgt_input = tgt[:, :-1] tgt_output = tgt[:, 1:] tgt_mask = generate_square_subsequent_mask(tgt_input.size(1)).to(device) logits = model(src, tgt_input, tgt_mask=tgt_mask) loss = criterion(logits.reshape(-1, logits.size(-1)), tgt_output.reshape(-1)) loss.backward() optimizer.step() return loss.item()

训练时观察三个信号：

• 第一个 batch 的 loss 是否在下降。
• 预测序列的 token 是否逐渐从随机变成有意义的片段。
• 验证集 loss 是否持续降低，如果验证 loss 不再下降但训练 loss 继续降，说明已经过拟合。

6.4 判断标准

• 复制任务准确率达到 95% 以上，说明模型已经具备基础序列能力。
• 翻译或摘要任务要关注 BLEU、ROUGE 指标，但小模型跑下来主要看 loss 曲线和数据拟合能力。
• 如果 loss 爆炸或峰值很久不降，先检查学习率和 learning rate scheduler。

6.5 常见的失败现象

7. Transformer 资源占用与性能观察

7.1 序列长度是最大变量

Transformer 训练时的显存占用主要来自注意力矩阵。注意力分数的 shape 是[batch, n_head, seq_len, seq_len]。

序列长度翻倍，注意力矩阵的计算量和显存占用约翻 4 倍。这也是为什么常见实现里都有限制max_len的原因。长文本训练通常要配合 FlashAttention、稀疏注意力或者序列切分策略。

7.2 显存占用观察方法

使用 PyTorch 可以实时查看显存占用：

import torch def print_memory_usage(): if torch.cuda.is_available(): print(f"allocated: {torch.cuda.memory_allocated() / 1024**2:.2f} MB") print(f"reserved: {torch.cuda.memory_reserved() / 1024**2:.2f} MB") print(f"max allocated: {torch.cuda.max_memory_allocated() / 1024**2:.2f} MB") print_memory_usage()

常见判断逻辑：

• 如果out of memory，优先降低 batch size。
• 如果 batch size 已经降到 1，再尝试降低序列长度。
• 也可以开启torch.utils.checkpoint（梯度检查点），用计算换显存：

model = torch.utils.checkpoint.checkpoint_sequential(model.layers, chunks=2, input=x)

7.3 CPU 与 GPU 推理差异

• CPU 推理：延迟高，吞吐低，适合本地验证和超小模型。
• GPU 推理：注意力矩阵可以在 GPU 上并行计算，生成速度大幅提升。
• 推理时 KV Cache 能显著减少重复计算量，尤其是在长文本生成场景。

具体快多少和模型规模、序列长度、硬件配置强相关，没有统一的倍数关系，建议在自己机器上实测。

7.4 如何降低显存占用

• 降低 batch size。
• 降低序列长度。
• 使用 AMP 混合精度训练。
• 使用梯度累积。
• 使用梯度检查点。
• 使用 8bit 优化器（如 bitsandbytes）。
• 推理场景用 INT8/INT4 量化。

8. Transformer 架构演进与衍生模型

Cohere 的回顾文章重点提到了 Transformer 的“可组合性”。这里做一张主流演进路线表：

Cohere 在回顾中也特别提到，当年Attention Is All You Need刚投稿时，作者们预期论文受到的关注有限。实际情况是，Transformer 不仅自己没有过时，还催生了整个大模型技术栈：从 BERT 到 GPT，从 ViT 到多模态大模型，全部都能在原始论文中找到对应结构。

9. 常见问题与排查方法

10. Transformer 代码调试与最佳实践

10.1 第一次先小参数测试

复现 Transformer 时，不要一开始就按d_model=512, n_layer=6跑。先从最小配置跑通：

# 最小可运行配置 d_model = 64 n_head = 4 d_ff = 128 n_layer = 2 max_len = 64

跑通后再逐步增加规模。不要直接复现论文原版超参数，除非你的显存和训练时间都足够。

10.2 保存最小可运行配置

把上面的最小配置保存为configs/mini.yaml：

model: d_model: 64 n_head: 4 d_ff: 128 n_layer: 2 max_len: 64 dropout: 0.1 training: batch_size: 32 learning_rate: 0.001 epochs: 10 warmup_steps: 100

以后排查问题时，先用这个配置复现，再逐渐还原到目标配置。

10.3 模型文件、输入、输出分目录管理

实际训练时，建议这样做：

• 把训练代码和模型定义放在models/。
• 把数据预处理脚本放在scripts/。
• 把每个实验的 checkpoint、日志、生成结果单独存一个experiments/exp_001/目录。
• checkpoint 命名里带上 step 和 loss，例如model_5000_loss1.23.pt。

10.4 批量训练要加日志和失败重试

大规模实验时，每一步都可能因为显存上限、数据损坏、断电等原因中断。建议：

• 定期保存 checkpoint。
• 每个 batch 后写日志到train.log。
• 使用 try-except 捕获单条数据异常，不要让坏数据拖垮整个训练。

10.5 接口服务要限制访问范围

如果你把 Transformer 封装成推理 API，不要默认监听0.0.0.0。

建议：

# 只允许本机访问 python serve.py --host 127.0.0.1 --port 8000

需要对外开放时，务必加上鉴权、限流和请求体大小限制。部署到公网时，需要额外确认模型返回的内容不涉及敏感信息。

10.6 涉及人脸、声音和版权数据必须确认授权

论文阅读和复现本身没有合规问题。但如果你要把 Transformer 用在人脸识别、声音合成、医疗辅助等场景，必须先确认数据来源合法，确认模型的使用范围和可商用性，避免侵犯个人隐私和版权。

11. 总结与下一步

Cohere 的这篇 Transformer 论文回顾值得一读的原因，不只是它回顾了历史，而是它把论文里的每个模块重新放回了工程语境。对于开发者来说，理解 Transformer 的最好方式就是把代码写出来，把 shape 打出来，跑一个最小任务，看它能不能收敛。

最先应该验证的功能是：多头注意力模块能否正确计算注意力矩阵，位置编码是否对序列顺序产生有效影响，解码器掩码是否阻止了未来信息的泄漏。

最容易踩的坑有三个：

• 第一，d_model没有被n_head整除，导致多头拆分时报错。
• 第二，解码器训练时没有将目标序列拆成tgt_input和tgt_output，导致标签错位。
• 第三，推理时忘记加序列掩码，模型会在解码阶段偷看未来 token，训练和推理行为不一致。

后续可以继续扩展的方向很多：把注意力换成 FlashAttention 做长文本加速，把位置编码换成 RoPE 提升长度外推能力，把编码器搬去做 ViT，把解码器搬去做 GPT 风格生成模型。每条路线的地基，都是 2017 年的这篇Attention Is All You Need。

建议把代码仓库保存好，作为一个长期维护的动手实验室。先跑通，再调优，最后再扩展到自己的业务场景。