把 Transformer 拼起来

这一课在哪

零件都齐了:注意力、前馈、LayerNorm、位置编码、编码器层、解码器层。

这一课自己手写一遍完整的模型, 然后再看 PyTorch 官方那个现成的怎么用。

手写:完整模型

import math import torch import torch.nn as nn class Transformer(nn.Module): def __init__(self, src_vocab, tgt_vocab, d_model=512, n_heads=8, n_layers=6, d_ff=2048, max_len=512, dropout=0.1): super().__init__() self.d_model = d_model # 词嵌入 self.src_embed = nn.Embedding(src_vocab, d_model, padding_idx=0) self.tgt_embed = nn.Embedding(tgt_vocab, d_model, padding_idx=0) # 位置编码(37.4 课写过) self.pos = SinusoidalPE(d_model, max_len) # 六层编码器 + 六层解码器 self.encoder = nn.ModuleList([ EncoderLayer(d_model, n_heads, d_ff) for _ in range(n_layers) ]) self.decoder = nn.ModuleList([ DecoderLayer(d_model, n_heads, d_ff) for _ in range(n_layers) ]) # 输出层:把 d_model 维映射到词表大小 self.fc_out = nn.Linear(d_model, tgt_vocab) def encode(self, src, src_mask=None): # 嵌入后乘 sqrt(d_model),原因见下面 x = self.src_embed(src) * math.sqrt(self.d_model) x = self.pos(x) for layer in self.encoder: x = layer(x, src_mask) return x # (B, T_src, d) def decode(self, tgt, enc_out, tgt_mask=None, src_mask=None): y = self.tgt_embed(tgt) * math.sqrt(self.d_model) y = self.pos(y) for layer in self.decoder: y = layer(y, enc_out, tgt_mask, src_mask) return y # (B, T_tgt, d) def forward(self, src, tgt, tgt_mask=None, src_mask=None): enc_out = self.encode(src, src_mask) dec_out = self.decode(tgt, enc_out, tgt_mask, src_mask) return self.fc_out(dec_out) # (B, T_tgt, tgt_vocab)

整个模型就这些。拆开看是八个零件,装起来一百来行。

拆开看三块

块

做什么

形状变化

encode

源句 → 一串向量

(B, T_src) → (B, T_src, d)

decode

目标句 + 编码结果 → 一串向量

(B, T_tgt) → (B, T_tgt, d)

fc_out

每一维映射到词表

(B, T_tgt, d) → (B, T_tgt, 词表大小)

注意中间那个 d 从头到尾没变—— 512 进,512 出,一路到底。这就是前面反复说的「所有子层维度必须一致」。

一个容易被忽略的细节:乘 √d_model

x = self.src_embed(src) * math.sqrt(self.d_model)

为什么要乘这个数?

量

数值范围

词嵌入

初始化时很小,每个维度大约 ±1

位置编码

sin/cos,严格在 ±1 之间

两者直接相加,位置编码会占掉一半的份量。

乘上 512≈22.6\sqrt{512} \approx 22.6 之后,词嵌入变成 ±22, 位置编码的 ±1 就只是微小扰动——刚好。

不乘会怎样

位置信息会盖过词义。模型看到的主要是「这是第几个位置」, 而不是「这个词是什么意思」。

这个细节很多教程不讲,但它是原论文里明确写了的。

跑一遍

model = Transformer(src_vocab=6083, tgt_vocab=2343) src = torch.randint(4, 6083, (2, 10)) # 2 句,10 个词 tgt = torch.randint(4, 2343, (2, 7)) # 2 句,7 个词 tgt_mask = nn.Transformer.generate_square_subsequent_mask(7) logits = model(src, tgt, tgt_mask=tgt_mask) print(logits.shape) # torch.Size([2, 7, 2343])

输出 (2, 7, 2343):2 句、7 个位置、每个位置 2343 个词的分数。

和普通分类一样,拿它和正确答案算交叉熵就得到损失。

PyTorch 里有现成的

上面那套东西 PyTorch 已经写好了,叫 nn.Transformer。

import torch.nn as nn model = nn.Transformer( d_model=512, # 维度 nhead=8, # 每层几个头 num_encoder_layers=6, # 编码器层数 num_decoder_layers=6, # 解码器层数 dim_feedforward=2048, # 前馈网络中间层 dropout=0.1, batch_first=True, # 输入是 (batch, 长度, 维度) ) out = model(src, tgt, tgt_mask=tgt_mask)

逐个对照我们手写的那份:

参数

对应手写版的哪

d_model

到处都在用的 512

nhead

MultiHeadAttention(..., 8)

num_encoder_layers

range(6) 里那个 6

num_decoder_layers

同上

dim_feedforward

PositionWiseFFN(d_model, 2048)

batch_first

默认 False,和注意力那个坑一样

最大的坑:它不含嵌入和输出层

nn.Transformer 只有编码器和解码器本体。

forward(src, tgt) 直接吃已经嵌入好的 (B, T, 512),吐出来的也是 (B, T, 512)。

词嵌入、位置编码、最后的 fc_out 都要你自己加。

实测一下:

m = nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, batch_first=True) print(sum(p.numel() for p in m.parameters())) # 44,140,544 src = torch.randn(2, 10, 512) # 已经是向量了,不是词 id tgt = torch.randn(2, 7, 512) out = m(src, tgt) print(out.shape) # torch.Size([2, 7, 512])

44,140,544——这 12 层的钱。加上嵌入和输出层才是完整的翻译模型。

因果掩码不用自己造

mask = nn.Transformer.generate_square_subsequent_mask(4) print(mask)
tensor([[0., -inf, -inf, -inf], [0., 0., -inf, -inf], [0., 0., 0., -inf], [0., 0., 0., 0.]])

和 37.5 课手推的那个一模一样,只是把 0 换成了 -inf—— softmax 之后同样是 0。

还有两个现成的零件

有时候不想用整个 Transformer,只想拿一部分:

类

是什么

nn.TransformerEncoderLayer

编码器一层

nn.TransformerDecoderLayer

解码器一层

nn.TransformerEncoder

编码器(N 层 + 最后那个 LayerNorm)

nn.TransformerDecoder

解码器

做分类任务时通常只用编码器(BERT 就是这样), 所以 nn.TransformerEncoder 单独用得上。

norm_first 就是 37.3 讲的 Pre-LN

nn.Transformer 有个参数 norm_first,默认 False—— 就是论文原文的 Post-LN。

设成 True 就是 Pre-LN,今天的大模型普遍用这个。

这一课留下的三个数

数

值

含义

嵌入缩放

d\sqrt{d} = 22.6

让位置编码只做扰动

nn.Transformer 参数

44,140,544

不含嵌入和输出层

层数

6 + 6

编码器 + 解码器

下一课

模型写完了,但还跑不起来。

下一课讲训练细节——尤其是那个绕不开的问题: 训练时整句一起算,推理时却只能一个一个来, 这两件事对不上,PyTorch 那个封好的 Transformer 因此不能直接拿来推理。