在实际深度学习项目中Transformer 架构早已超越了其在自然语言处理NLP领域的起源成为驱动大语言模型、多模态理解和时间序列预测等众多前沿任务的核心引擎。然而对于许多开发者而言从“知道Transformer很重要”到“能动手实现并调优一个Transformer模型”之间依然存在巨大的鸿沟。理论论文中的矩阵运算令人望而生畏而网上零散的代码片段又难以串联成完整的知识体系。本文旨在为希望彻底掌握Transformer的开发者提供一条清晰的路径。我们将避开空洞的理论堆砌直接切入核心从最基础的注意力机制开始逐步拆解Encoder-Decoder的每一层结构并用PyTorch实现一个可运行的、用于机器翻译任务的完整Transformer模型。过程中我们会解释每一个设计选择背后的动机例如为什么需要位置编码、层归一化放在哪里、以及训练时的各种技巧。最终你将不仅理解Transformer的“为什么”更能获得一个可以修改、调试并应用于自己任务的“怎么做”的坚实代码基础。1. 理解Transformer的核心自注意力机制在循环神经网络RNN处理序列时当前时刻的状态严重依赖于前一时刻的输出这种串行特性导致了训练缓慢和难以捕捉长距离依赖。Transformer的革命性在于完全摒弃了递归转而使用自注意力机制让序列中的任意两个位置都能直接建立联系从而实现了高效的并行计算。1.1 注意力机制的基本思想你可以将注意力机制想象成一次信息检索过程。假设你有一系列查询Query 你需要从一个键值对Key-Value仓库中找到最相关的信息。注意力机制的核心是计算Query和所有Key的相似度通常通过点积然后将相似度归一化Softmax得到权重最后用这些权重对Value进行加权求和得到输出。用公式表示缩放点积注意力Scaled Dot-Product Attention就是 [ \text{Attention}(Q, K, V) \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V ] 其中(d_k) 是Key向量的维度。除以 (\sqrt{d_k}) 是为了防止点积结果过大导致Softmax函数梯度消失。1.2 自注意力Self-Attention在Transformer的语境下“自”意味着Query, Key, Value都来自同一个输入序列。假设输入是一个单词嵌入矩阵 (X \in \mathbb{R}^{n \times d_{\text{model}}}) 我们通过三个不同的线性变换矩阵 (W^Q, W^K, W^V) 将其投影到不同的空间分别得到Q, K, V [ Q X W^Q, \quad K X W^K, \quad V X W^V ] 然后应用上述注意力公式。这个过程允许序列中的每个单词例如“it”同时关注到序列中所有其他单词如“The”, “animal”, “street”, “because”, “was”, “tired”从而更好地确定“it”指代的是“animal”还是“street”。1.3 多头注意力Multi-Head Attention这是Transformer性能强大的关键。与其只做一次注意力计算不如将模型划分为多个“头”让每个头在不同的子空间通过不同的投影矩阵实现学习关注不同的信息。最后将所有头的输出拼接起来再经过一次线性变换。import torch import torch.nn as nn import torch.nn.functional as F class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() assert d_model % num_heads 0, “d_model must be divisible by num_heads” self.d_model d_model self.num_heads num_heads self.d_k d_model // num_heads # 定义线性变换层用于生成Q, K, V以及最后的输出 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 scaled_dot_product_attention(self, Q, K, V, maskNone): # Q, K, V shape: (batch_size, num_heads, seq_len, d_k) attn_scores torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5) if mask is not None: attn_scores attn_scores.masked_fill(mask 0, -1e9) attn_probs F.softmax(attn_scores, dim-1) output torch.matmul(attn_probs, V) return output, attn_probs def split_heads(self, x): # x shape: (batch_size, seq_len, d_model) batch_size, seq_len, d_model x.size() return x.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) def combine_heads(self, x): # x shape: (batch_size, num_heads, seq_len, d_k) batch_size, _, seq_len, d_k x.size() return x.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) def forward(self, Q, K, V, maskNone): # 1. 线性变换并分头 Q self.split_heads(self.W_q(Q)) K self.split_heads(self.W_k(K)) V self.split_heads(self.W_v(V)) # 2. 计算缩放点积注意力 attn_output, attn_probs self.scaled_dot_product_attention(Q, K, V, mask) # 3. 合并多头输出并做最终线性变换 output self.W_o(self.combine_heads(attn_output)) return output, attn_probs关键解释mask参数至关重要在解码器自注意力中用于防止当前位置关注到未来的词因果掩码在编码器中用于处理变长序列的填充部分填充掩码。split_heads和combine_heads操作通过view和transpose实现是高效并行计算多头的关键。最终输出的维度与输入Q的维度一致均为(batch_size, seq_len, d_model)。2. 构建Transformer的基础模块编码器与解码器层理解了多头注意力我们就可以搭建Transformer的基石——编码器层和解码器层。每个层都遵循“注意力/前馈网络 残差连接 层归一化”的模式这是训练深层网络稳定性的关键。2.1 前馈网络Position-wise Feed-Forward Network这是一个应用于序列中每个位置上的独立全连接网络。它由两个线性变换和一个ReLU激活函数组成 [ \text{FFN}(x) \max(0, xW_1 b_1)W_2 b_2 ] 通常中间层的维度d_ff会比d_model大得多例如4倍以增加模型的表达能力。class PositionWiseFFN(nn.Module): def __init__(self, d_model, d_ff): super(PositionWiseFFN, self).__init__() self.fc1 nn.Linear(d_model, d_ff) self.fc2 nn.Linear(d_ff, d_model) self.relu nn.ReLU() def forward(self, x): return self.fc2(self.relu(self.fc1(x)))2.2 层归一化与残差连接残差连接Residual Connection将子层如注意力或前馈网络的输入直接加到其输出上output LayerNorm(x Sublayer(x))。这里有一个重要细节原始论文《Attention Is All You Need》中层归一化LayerNorm在残差相加之后。但后续研究和实践如Tensor2Tensor库、许多现代实现发现将层归一化放在子层输入之前即Pre-Norm通常能使训练更稳定。我们采用更常见的Pre-Norm结构。class SublayerConnection(nn.Module): 残差连接后接层归一化。 def __init__(self, d_model, dropout): super(SublayerConnection, self).__init__() self.norm nn.LayerNorm(d_model) self.dropout nn.Dropout(dropout) def forward(self, x, sublayer): # Pre-Norm: 先对输入进行归一化再传入子层然后dropout最后残差连接 return x self.dropout(sublayer(self.norm(x)))2.3 编码器层Encoder Layer一个编码器层包含两个子层多头自注意力层和前馈网络层。class EncoderLayer(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout): super(EncoderLayer, self).__init__() self.self_attn MultiHeadAttention(d_model, num_heads) self.feed_forward PositionWiseFFN(d_model, d_ff) self.sublayer1 SublayerConnection(d_model, dropout) self.sublayer2 SublayerConnection(d_model, dropout) def forward(self, x, mask): # 第一个子层多头自注意力。Q, K, V 都来自编码器自身输入x。 x self.sublayer1(x, lambda x: self.self_attn(x, x, x, mask)[0]) # 第二个子层前馈网络。 x self.sublayer2(x, self.feed_forward) return x2.4 解码器层Decoder Layer解码器层更复杂一些包含三个子层带掩码的多头自注意力层确保解码时当前位置只能关注到已生成的词及起始符。编码器-解码器注意力层让解码器关注编码器的最终输出这是信息从源语言传递到目标语言的关键。前馈网络层。class DecoderLayer(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout): super(DecoderLayer, self).__init__() self.self_attn MultiHeadAttention(d_model, num_heads) self.cross_attn MultiHeadAttention(d_model, num_heads) self.feed_forward PositionWiseFFN(d_model, d_ff) self.sublayer1 SublayerConnection(d_model, dropout) self.sublayer2 SublayerConnection(d_model, dropout) self.sublayer3 SublayerConnection(d_model, dropout) def forward(self, x, encoder_output, src_mask, tgt_mask): # 第一子层带掩码的自注意力关注已生成部分 x self.sublayer1(x, lambda x: self.self_attn(x, x, x, tgt_mask)[0]) # 第二子层编码器-解码器注意力。Q来自解码器K、V来自编码器输出。 x self.sublayer2(x, lambda x: self.cross_attn(x, encoder_output, encoder_output, src_mask)[0]) # 第三子层前馈网络 x self.sublayer3(x, self.feed_forward) return x3. 组装完整Transformer模型有了层我们就可以堆叠它们并加上嵌入层、位置编码和最后的线性输出层构成完整的Transformer模型。3.1 位置编码Positional Encoding由于Transformer没有循环或卷积结构它本身无法感知序列中单词的顺序。位置编码将单词在序列中的位置信息注入到输入嵌入中。原始论文使用正弦和余弦函数 [ PE_{(pos, 2i)} \sin(pos / 10000^{2i/d_{\text{model}}}) ] [ PE_{(pos, 2i1)} \cos(pos / 10000^{2i/d_{\text{model}}}) ] 其中pos是位置i是维度。这种编码方式能让模型轻松学习到相对位置关系。class PositionalEncoding(nn.Module): def __init__(self, d_model, max_seq_len5000, dropout0.1): super(PositionalEncoding, self).__init__() self.dropout nn.Dropout(pdropout) pe torch.zeros(max_seq_len, d_model) position torch.arange(0, max_seq_len, dtypetorch.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) # (1, max_seq_len, d_model) self.register_buffer(‘pe’, pe) # 不是模型参数但会随模型保存/加载 def forward(self, x): # x shape: (batch_size, seq_len, d_model) x x self.pe[:, :x.size(1), :] return self.dropout(x)3.2 编码器与解码器堆叠class Encoder(nn.Module): def __init__(self, vocab_size, d_model, num_layers, num_heads, d_ff, max_seq_len, dropout): super(Encoder, self).__init__() self.embedding nn.Embedding(vocab_size, d_model) self.pos_encoding PositionalEncoding(d_model, max_seq_len, dropout) self.layers nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]) self.norm nn.LayerNorm(d_model) def forward(self, src, src_mask): # 1. 词嵌入 位置编码 x self.embedding(src) x self.pos_encoding(x) # 2. 通过N个编码器层 for layer in self.layers: x layer(x, src_mask) # 3. 最终层归一化 (Pre-Norm结构中最后一层输出后通常再加一次Norm) return self.norm(x) class Decoder(nn.Module): def __init__(self, vocab_size, d_model, num_layers, num_heads, d_ff, max_seq_len, dropout): super(Decoder, self).__init__() self.embedding nn.Embedding(vocab_size, d_model) self.pos_encoding PositionalEncoding(d_model, max_seq_len, dropout) self.layers nn.ModuleList([DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]) self.norm nn.LayerNorm(d_model) def forward(self, tgt, encoder_output, src_mask, tgt_mask): x self.embedding(tgt) x self.pos_encoding(x) for layer in self.layers: x layer(x, encoder_output, src_mask, tgt_mask) return self.norm(x)3.3 最终的Transformer模型class Transformer(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model512, num_layers6, num_heads8, d_ff2048, max_seq_len5000, dropout0.1): super(Transformer, self).__init__() self.encoder Encoder(src_vocab_size, d_model, num_layers, num_heads, d_ff, max_seq_len, dropout) self.decoder Decoder(tgt_vocab_size, d_model, num_layers, num_heads, d_ff, max_seq_len, dropout) self.final_linear nn.Linear(d_model, tgt_vocab_size) def forward(self, src, tgt, src_mask, tgt_mask): encoder_output self.encoder(src, src_mask) decoder_output self.decoder(tgt, encoder_output, src_mask, tgt_mask) output self.final_linear(decoder_output) return output def generate_mask(self, src, tgt): # 生成源序列填充掩码 (src_mask): (batch_size, 1, 1, src_len) src_mask (src ! 0).unsqueeze(1).unsqueeze(2) # 生成目标序列填充掩码和因果掩码 tgt_pad_mask (tgt ! 0).unsqueeze(1).unsqueeze(2) # (batch_size, 1, 1, tgt_len) tgt_len tgt.size(1) tgt_sub_mask torch.tril(torch.ones((tgt_len, tgt_len), devicetgt.device)).bool() tgt_mask tgt_pad_mask tgt_sub_mask # 结合填充掩码和因果掩码 return src_mask, tgt_mask模型参数说明参数名典型值含义与影响d_model512模型的主维度也是词嵌入和所有层输出的维度。增大可提升模型容量但增加计算量。num_layers6编码器和解码器堆叠的层数。层数越多模型越深表征能力越强但也越难训练。num_heads8多头注意力的头数。通常d_model需能被num_heads整除。多头允许模型在不同表示子空间学习信息。d_ff2048前馈网络中间层的维度通常是d_model的4倍。dropout0.1丢弃率用于防止过拟合。在嵌入、位置编码和每个子层输出后都可能应用。max_seq_len5000位置编码支持的最大序列长度。若实际序列更长需调整或使用其他位置编码。4. 实战训练一个英德翻译模型现在我们将使用上面构建的Transformer模型在一个小规模的IWSLT英德翻译数据集上进行训练和推理。4.1 环境准备与数据预处理首先确保环境已安装PyTorch和Torchtext。我们将使用Torchtext内置的数据集和分词器。import torch import torch.nn as nn from torchtext.data import Field, BucketIterator from torchtext.datasets import Multi30k # IWSLT 2016 英德数据集 # 定义字段Field SRC Field(tokenize“spacy”, tokenizer_language“en”, init_token‘sos’, eos_token‘eos’, lowerTrue) TRG Field(tokenize“spacy”, tokenizer_language“de”, init_token‘sos’, eos_token‘eos’, lowerTrue) # 加载数据集 train_data, valid_data, test_data Multi30k.splits(exts(‘.en’, ‘.de’), fields(SRC, TRG)) # 构建词汇表 SRC.build_vocab(train_data, min_freq2) TRG.build_vocab(train_data, min_freq2) # 创建数据迭代器 BATCH_SIZE 128 device torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’) train_iterator, valid_iterator, test_iterator BucketIterator.splits( (train_data, valid_data, test_data), batch_sizeBATCH_SIZE, devicedevice )4.2 初始化模型、优化器与损失函数# 超参数 INPUT_DIM len(SRC.vocab) OUTPUT_DIM len(TRG.vocab) D_MODEL 256 # 为了快速演示使用较小维度 N_LAYERS 3 N_HEADS 8 D_FF 512 DROPOUT 0.1 MAX_SEQ_LEN 100 # 初始化模型 model Transformer(src_vocab_sizeINPUT_DIM, tgt_vocab_sizeOUTPUT_DIM, d_modelD_MODEL, num_layersN_LAYERS, num_headsN_HEADS, d_ffD_FF, max_seq_lenMAX_SEQ_LEN, dropoutDROPOUT).to(device) # 定义优化器和损失函数 optimizer torch.optim.Adam(model.parameters(), lr0.0005, betas(0.9, 0.98), eps1e-9) criterion nn.CrossEntropyLoss(ignore_indexTRG.vocab.stoi[TRG.pad_token]) # 忽略填充符的损失4.3 训练循环训练Transformer时一个重要的技巧是学习率预热Learning Rate Warm-up。在训练初期使用较小的学习率然后线性增加到设定值之后再按步数平方根的倒数衰减。这有助于模型在训练初期稳定。def train_epoch(model, iterator, optimizer, criterion, clip): model.train() epoch_loss 0 for i, batch in enumerate(iterator): src batch.src trg batch.trg optimizer.zero_grad() # 生成掩码 src_mask, tgt_mask model.generate_mask(src, trg[:, :-1]) # 解码器输入是trg去掉eos # 前向传播 output model(src, trg[:, :-1], src_mask, tgt_mask) # output: (batch_size, tgt_len-1, vocab_size) # 计算损失 output_dim output.shape[-1] output output.contiguous().view(-1, output_dim) trg trg[:, 1:].contiguous().view(-1) # 解码器目标是trg去掉sos loss criterion(output, trg) # 反向传播 loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), clip) # 梯度裁剪防止梯度爆炸 optimizer.step() epoch_loss loss.item() return epoch_loss / len(iterator) # 学习率调度函数简化版预热 def get_lr(step, d_model, warmup_steps4000): return d_model ** (-0.5) * min(step ** (-0.5), step * warmup_steps ** (-1.5)) # 训练循环 N_EPOCHS 20 CLIP 1 best_valid_loss float(‘inf’) for epoch in range(N_EPOCHS): # 可以在这里动态调整学习率 # lr get_lr(epoch_step, D_MODEL) # for param_group in optimizer.param_groups: # param_group[‘lr’] lr train_loss train_epoch(model, train_iterator, optimizer, criterion, CLIP) # 验证步骤略... print(f’Epoch: {epoch1:02} | Train Loss: {train_loss:.3f}‘)4.4 推理贪婪解码训练完成后我们可以用训练好的模型进行翻译。最简单的解码策略是贪婪解码每一步都选择概率最高的词作为输出。def translate_sentence(sentence, src_field, trg_field, model, device, max_len50): model.eval() # 分词并转换为索引 tokens [token.lower() for token in src_field.tokenize(sentence)] tokens [src_field.init_token] tokens [src_field.eos_token] src_indexes [src_field.vocab.stoi[token] for token in tokens] src_tensor torch.LongTensor(src_indexes).unsqueeze(0).to(device) # 生成源序列掩码 src_mask (src_tensor ! 0).unsqueeze(1).unsqueeze(2) # 编码 with torch.no_grad(): encoder_output model.encoder(src_tensor, src_mask) # 解码器初始输入sos trg_indexes [trg_field.vocab.stoi[trg_field.init_token]] for i in range(max_len): trg_tensor torch.LongTensor(trg_indexes).unsqueeze(0).to(device) tgt_mask model.generate_mask(src_tensor, trg_tensor)[1] # 只取目标掩码 with torch.no_grad(): output model.decoder(trg_tensor, encoder_output, src_mask, tgt_mask) output model.final_linear(output) # 取最后一步的输出并选择概率最高的词 pred_token output.argmax(2)[:, -1].item() trg_indexes.append(pred_token) if pred_token trg_field.vocab.stoi[trg_field.eos_token]: break # 将索引转换回单词 trg_tokens [trg_field.vocab.itos[i] for i in trg_indexes] return trg_tokens[1:] # 去掉开头的sos # 示例翻译 example_sentence “A group of people standing in front of an igloo .” translation translate_sentence(example_sentence, SRC, TRG, model, device) print(‘ ‘.join(translation))5. 关键问题排查与调优指南在实际训练和部署Transformer时你会遇到各种问题。以下是几个最常见的问题及其排查路径。5.1 训练不收敛或损失为NaN这是初期最常见的问题。可能原因及排查学习率过高Transformer对学习率非常敏感。尝试大幅降低学习率例如从1e-3降到1e-4或1e-5并务必使用学习率预热。梯度爆炸检查梯度范数。在训练循环中加入梯度裁剪torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm1.0)。数据或掩码错误确保输入序列的填充符通常是0被正确掩码。检查src_mask和tgt_mask的生成逻辑确保形状为(batch, 1, 1, seq_len)且需要被掩码的位置值为False或0。损失函数忽略索引确保nn.CrossEntropyLoss的ignore_index参数设置为目标词汇表中填充符的索引。数值稳定性在自定义Softmax或注意力计算时确保做了数值稳定处理如减去最大值。5.2 模型过拟合现象训练损失持续下降但验证损失很早就开始上升。解决方案增加Dropout适当提高模型各处的Dropout率如从0.1到0.2或0.3。数据增强对于NLP任务可以使用回译、随机删除、交换等文本增强技术。权重衰减L2正则化在优化器中加入weight_decay参数。早停Early Stopping监控验证集损失当其在连续多个epoch不再下降时停止训练。减少模型规模如果数据量有限减少d_model、num_layers或num_heads。5.3 推理结果重复或质量差现象模型生成的翻译重复单词或句子或者语法完全不通。排查与解决检查解码策略贪婪解码容易导致重复。可以尝试束搜索Beam Search保留多个候选序列。长度惩罚在束搜索中引入长度惩罚避免模型生成过短或过长的句子。重复惩罚在生成时对已出现的词进行惩罚减少重复。检查训练数据目标语料中是否存在大量重复或低质量句子。验证集性能如果验证集上的BLEU等指标也很低说明模型本身能力不足需要检查模型架构、超参或数据量。5.4 显存溢出OOMTransformer尤其是大模型非常消耗显存。优化策略减小批次大小这是最直接有效的方法。梯度累积如果硬件限制批次大小必须很小可以使用梯度累积。每N个小批次才更新一次参数相当于增大了有效批次大小。混合精度训练使用torch.cuda.amp进行自动混合精度训练可以显著减少显存占用并加速训练。检查序列长度过长的序列是显存杀手。可以设置最大长度对超长序列进行截断或过滤。激活检查点对于极深的模型可以使用torch.utils.checkpoint来用计算时间换显存空间。6. 从零基础到进阶扩展方向与最佳实践掌握了基础Transformer的实现和训练后你可以从以下几个方向深化理解和提升实践能力。6.1 模型架构变体仅编码器模型如BERT移除解码器专注于理解任务。常用于文本分类、命名实体识别。关键改动是使用双向自注意力并设计如掩码语言模型MLM的预训练任务。仅解码器模型如GPT移除编码器专注于生成任务。使用带因果掩码的自注意力层堆叠。这是当前大语言模型的主流架构。视觉TransformerViT将图像分割成块patch视为一个序列然后输入标准Transformer编码器。需要移除位置编码改为可学习的1D或2D位置嵌入。Swin Transformer引入层次化设计和滑动窗口注意力更高效地处理图像等高维数据。6.2 效率优化稀疏注意力如Longformer、BigBird的注意力模式将 (O(n^2)) 的计算复杂度降低到 (O(n)) 或 (O(n log n))以处理超长序列。线性注意力通过核函数近似将注意力计算转化为线性复杂度。模型量化与蒸馏将浮点模型转换为低精度如INT8以减小模型体积、加速推理或用大模型教师指导小模型学生训练在保持性能的同时提升速度。6.3 生产环境部署考量当模型准备上线时需考虑以下方面序列化与加载使用torch.jit.script或torch.jit.trace将模型转换为TorchScript或使用ONNX格式以便在不同框架和环境中部署。动态批处理推理服务中请求的序列长度各异。需要实现动态批处理将多个不同长度的请求高效地打包成一个张量进行计算。缓存KV Cache对于自回归生成如GPT解码时当前步的Key和Value向量在后续步骤中会被重复计算。实现KV缓存可以避免重复计算极大提升生成速度。监控与日志记录推理延迟、吞吐量、显存占用以及输入输出的分布便于性能分析和问题排查。6.4 持续学习资源经典论文精读《Attention Is All You Need》是起点后续应阅读BERT、GPT、T5、ViT等里程碑论文。开源代码库研究Hugging Face Transformers提供了数千个预训练模型和统一的API是学习现代Transformer应用的最佳实践库。FairseqFacebook的序列建模工具包包含大量先进的机器翻译、文本生成模型实现。Megatron-LM / DeepSpeedNVIDIA和微软推出的用于训练超大模型的框架学习其分布式训练、混合精度、梯度 checkpointing 等高级技术。动手项目尝试在更多任务上应用Transformer如文本摘要、对话生成、时间序列预测、甚至音频或视频处理。通过从零实现、调试、训练一个小型Transformer模型你获得的对架构细节和训练动态的理解是直接调用高级API无法比拟的。这份理解将成为你后续探索更复杂模型和应用场景的坚实基础。当你再看到“Transformer”、“Attention”、“BERT”、“GPT”这些词时脑海中浮现的不再是黑盒而是清晰的张量流动路径和可修改的代码逻辑。