Transformer架构核心原理与PyTorch实现：从自注意力到编码器-解码器

1. 从序列到理解：Transformer为何重塑了深度学习格局

几年前，当我第一次尝试用RNN处理一个长文本分类任务时，被梯度消失和缓慢的训练速度折磨得够呛。那时就在想，有没有一种模型，既能捕捉长距离依赖，又能像CNN处理图像那样高度并行化？直到Transformer的出现，这个想法才真正落地。它不仅仅是一个模型，更像是一个设计范式的转变，彻底改变了我们处理序列数据的方式。从最初的机器翻译到如今横扫NLP、CV乃至多模态领域，Transformer架构已经成为深度学习的基石。无论你是刚入门的新手，还是想深入理解其精髓的从业者，这份笔记都将带你拆解Transformer的每一个齿轮，弄懂它为何如此强大，以及如何亲手实现它。我们会避开枯燥的公式堆砌，用最直白的语言和类比，把注意力机制、编码器-解码器结构这些核心概念讲透，并附上可运行的代码和实操中踩过的坑。

2. Transformer核心架构全景拆解

2.1 抛弃循环与卷积：自注意力机制的崛起

Transformer最革命性的设计在于完全摒弃了RNN的循环结构和CNN的卷积操作，转而完全依赖自注意力机制来处理序列。为什么这么做？核心是为了解决并行化和长程依赖的难题。

想象一下，你正在阅读一段话。RNN的工作方式就像你一个字一个字地读，必须读完前一个字才能理解后一个字，这导致了训练时无法并行，速度慢。而且，如果这段话很长，开头的信息在传递到末尾时可能已经“衰减”或“遗忘”得差不多了，这就是长程依赖问题。CNN通过卷积核滑动，能并行处理，但它的感受野受限于核大小，要捕捉全局关系需要堆叠很多层。

自注意力机制则不同。它让序列中的每一个元素（例如一个词）直接与序列中的所有其他元素进行交互和计算关联度。这个过程是一次性、并行完成的。就好比你在读一句话时，不是线性地看，而是瞬间扫视全句，同时判断句中每个词与其他词的相关性。例如，“苹果”这个词，在“我吃了一个苹果”和“苹果公司发布了新产品”中，它与句中其他词的关系权重分布是完全不同的。这种动态的、根据内容计算出的权重，就是注意力分数的精髓。

这种设计的优势立竿见影：

1. 极高的并行度：序列所有位置的注意力计算可以同时进行，充分利用GPU等硬件加速，极大提升了训练效率。
2. 无敌的长程依赖建模能力：无论两个词在序列中相隔多远，它们都可以直接建立联系，一步到位，避免了信息在多层传递中的损耗。

2.2 编码器-解码器结构详解

Transformer采用了经典的编码器-解码器框架，但内部组件全部换新。

编码器：由N个（原论文中N=6）完全相同的层堆叠而成。每一层都包含两个核心子层：

1. 多头自注意力层：让输入序列自己看自己，捕捉内部元素间的依赖关系。
2. 前馈神经网络层：一个简单的全连接网络，对每个位置的表示进行独立变换（注意是“独立”的，位置之间在此层不交互）。

每个子层外面都套着一个“残差连接”和“层归一化”。可以把这个结构想象成：输出 = LayerNorm(子层输入 + 子层函数(子层输入))。残差连接确保了梯度流动，缓解了深层网络训练中的梯度消失问题；层归一化则稳定了每一层的输入分布，加速训练收敛。

解码器：同样由N个相同的层堆叠。它在编码器两层的基础上，额外插入了一个编码器-解码器注意力层（或称交叉注意力层）。 解码器每一层的三个子层依次为：

1. 掩码多头自注意力层：与编码器自注意力类似，但加上了掩码，确保在预测第t个位置时，只能看到t时刻之前（及t时刻）的输出，防止信息泄露，这是自回归生成的关键。
2. 多头交叉注意力层：这是解码器“询问”编码器结果的地方。它的Query来自解码器上一层的输出，而Key和Value来自编码器的最终输出。这样，解码器在生成每一个词时，都能有选择地聚焦于输入序列最相关的部分。
3. 前馈神经网络层：与编码器中的一样。

注意：解码器在训练和推理时的行为有细微差别。训练时，我们通常使用“教师强制”，将整个目标序列右移一位后作为输入，并行计算所有位置的输出。而推理时，是逐个词自回归生成的，这要求模型缓存之前步骤的Key和Value以提升效率，这是实现推理优化的关键点。

3. 核心组件深度解析与实现要点

3.1 自注意力机制：从Scaled Dot-Product到多头

自注意力机制的计算是Transformer的心脏，其公式为：Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V。

我们来拆解每一步：

1. Q, K, V矩阵：对于输入序列X（形状为[序列长度, 模型维度d_model]），我们通过三个不同的线性变换矩阵W_q, W_k, W_v，将其分别投影为查询矩阵Q、键矩阵K和值矩阵V。你可以把Q理解为“我要找什么”，K是“我有什么标签”，V是“标签对应的实际内容”。
2. QK^T：计算查询和所有键的点积，得到一个注意力分数矩阵。分数越高，表示对应位置的键与当前查询越相关。
3. 缩放（除以sqrt(d_k)）：这是一个非常关键但容易被忽略的trick。点积的结果会随着维度d_k的增大而变得非常大，这将softmax函数推入梯度极小的区域，导致训练不稳定。除以sqrt(d_k)是为了将分数缩放回一个方差更稳定的范围。
4. Softmax：对每一行（对应一个查询）进行softmax归一化，得到权重分布，所有权重和为1。
5. 加权求和：用得到的权重对V矩阵进行加权求和，得到最终的注意力输出。这个输出包含了全局信息。

多头注意力是另一个神来之笔。与其只做一次注意力，不如把模型维度d_model拆分成h个头（例如d_model=512, h=8，则每个头维度d_k = d_v = 512/8 = 64）。每个头独立进行上述的注意力计算，可以理解为让模型从不同的“表示子空间”或不同角度去关注信息。有的头可能更关注语法结构，有的头更关注语义关联，有的头可能关注位置信息。最后，将h个头的输出拼接起来，再经过一个线性变换WO，融合不同视角的信息。

实操心得：在实现时，为了并行计算所有头的注意力，一个高效的技巧是使用reshape和transpose操作，将[batch_size, seq_len, d_model]的输入，转换为[batch_size, num_heads, seq_len, depth_per_head]，然后利用矩阵运算一次性计算所有头的注意力。这比用循环逐个头计算要快得多。

3.2 位置编码：让模型感知顺序

既然Transformer没有循环和卷积，它如何知道序列中元素的顺序呢？答案是位置编码。原论文使用了正弦和余弦函数来生成绝对位置编码：PE(pos, 2i) = sin(pos / 10000^(2i/d_model))PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))其中，pos是位置，i是维度索引。

这种编码方式有几个精妙之处：

1. 周期性：sin/cos函数是周期性的，可以让模型轻松学习到相对位置信息。因为对于固定的偏移量k，PE(pos+k)可以表示为PE(pos)的线性函数。
2. 值域有界：值在[-1, 1]之间，与词嵌入向量的范围匹配。
3. 可扩展性：可以处理比训练时见过的更长的序列（虽然效果会下降）。

除了正弦编码，也有可学习的位置编码（直接训练一个位置嵌入矩阵）和相对位置编码（如Transformer-XL、T5等模型中使用的，直接建模元素间的相对距离关系）。在视觉Transformer中，由于图像patch是二维的，通常需要使用二维位置编码。

注意事项：位置编码是在输入嵌入之后直接相加，而不是拼接。相加操作意味着模型需要自己学习如何将位置信息与语义信息融合。在实现时，务必确保位置编码的维度与词嵌入维度一致。

3.3 前馈网络与残差连接

前馈网络层非常简单，就是一个两层全连接网络，中间有一个ReLU激活函数：FFN(x) = max(0, xW1 + b1)W2 + b2。在原论文中，内层维度是d_model的4倍（例如d_model=512，则内层为2048）。它的作用是对每个位置的表示进行独立的、非线性的特征变换。

为什么需要它？自注意力层本质上是线性加权求和（softmax是线性分类器，加权求和是线性操作），缺乏非线性变换能力。前馈网络就引入了至关重要的非线性，增强了模型的表达能力。

残差连接和层归一化是训练深层模型的稳定器。其操作顺序通常是：子层输出 = LayerNorm(x + Sublayer(x))。这里有一个细节争议：原论文描述的是LayerNorm(x + Sublayer(x))，但后续很多实现（如Tensor2Tensor，早期的PyTorch官方教程）采用了x + Sublayer(LayerNorm(x))，即先归一化再进入子层。现在更普遍的做法是采用Pre-Norm（先LayerNorm），因为它在训练更深的模型时表现更稳定。而原论文的Post-Norm（后LayerNorm）有时会导致训练初期不稳定。

4. 动手实现一个简易Transformer

理论说了这么多，不写代码都是空谈。下面我们用PyTorch实现一个简化版的Transformer，用于机器翻译任务。我们会聚焦于核心架构，省略一些工程优化细节。

4.1 环境准备与数据预处理

首先，确保你的环境安装了PyTorch。我们使用一个玩具级的双语数据集（例如IWSLT的德英小数据集）进行演示。

import torch import torch.nn as nn import torch.optim as optim import numpy as np from torch.utils.data import Dataset, DataLoader import math # 假设我们已经有了构建好的词汇表和预处理函数 # src_vocab: 源语言（德语）词汇表 # tgt_vocab: 目标语言（英语）词汇表 # train_data: 包含(tokenized_src, tokenized_tgt)对的列表 class TranslationDataset(Dataset): def __init__(self, data, src_vocab, tgt_vocab, max_len=100): self.data = data self.src_vocab = src_vocab self.tgt_vocab = tgt_vocab self.max_len = max_len self.pad_idx = src_vocab['<pad>'] # 假设pad token在两个词汇表中索引一致 def __len__(self): return len(self.data) def __getitem__(self, idx): src_seq, tgt_seq = self.data[idx] # 截断或填充到固定长度，并添加起止符 src = [self.src_vocab['<sos>']] + src_seq[:self.max_len-2] + [self.src_vocab['<eos>']] tgt = [self.tgt_vocab['<sos>']] + tgt_seq[:self.max_len-2] + [self.tgt_vocab['<eos>']] src = src + [self.pad_idx] * (self.max_len - len(src)) tgt = tgt + [self.pad_idx] * (self.max_len - len(tgt)) return torch.LongTensor(src), torch.LongTensor(tgt) # 创建数据加载器 batch_size = 32 train_dataset = TranslationDataset(train_data, src_vocab, tgt_vocab) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

4.2 核心模块实现：注意力、编码器与解码器

我们先实现缩放点积注意力模块和多头注意力模块。

class ScaledDotProductAttention(nn.Module): def __init__(self, dropout=0.1): super().__init__() self.dropout = nn.Dropout(dropout) def forward(self, Q, K, V, mask=None): # Q, K, V: [batch_size, num_heads, seq_len, d_k] d_k = Q.size(-1) # 计算注意力分数 scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k) # [batch_size, num_heads, seq_len, seq_len] # 应用掩码（如果需要） if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) # 将mask为0的位置置为负无穷 # Softmax得到权重 attn_weights = nn.functional.softmax(scores, dim=-1) attn_weights = self.dropout(attn_weights) # 加权求和 output = torch.matmul(attn_weights, V) # [batch_size, num_heads, seq_len, d_v] return output, attn_weights class MultiHeadAttention(nn.Module): def __init__(self, d_model=512, num_heads=8, dropout=0.1): super().__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 self.d_v = 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) self.attention = ScaledDotProductAttention(dropout) self.dropout = nn.Dropout(dropout) self.layer_norm = nn.LayerNorm(d_model) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 1. 线性投影并分头 Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) V = self.W_v(value).view(batch_size, -1, self.num_heads, self.d_v).transpose(1, 2) # 2. 应用注意力 x, attn = self.attention(Q, K, V, mask=mask) # x: [batch_size, num_heads, seq_len, d_v] # 3. 合并多头 x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) # 4. 输出投影 output = self.W_o(x) # 5. 残差连接与层归一化 (采用Pre-Norm结构) x_norm = self.layer_norm(query + self.dropout(output)) return x_norm, attn

接下来实现前馈网络和编码器层。

class PositionwiseFeedForward(nn.Module): def __init__(self, d_model=512, d_ff=2048, 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) self.layer_norm = nn.LayerNorm(d_model) def forward(self, x): # Pre-Norm 结构 norm_x = self.layer_norm(x) ff_out = self.linear2(self.dropout(torch.relu(self.linear1(norm_x)))) return x + self.dropout(ff_out) class EncoderLayer(nn.Module): def __init__(self, d_model=512, num_heads=8, d_ff=2048, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout) def forward(self, x, src_mask): # x: [batch_size, src_len, d_model] # src_mask: [batch_size, 1, 1, src_len] 用于屏蔽pad位置 attn_output, _ = self.self_attn(x, x, x, mask=src_mask) ff_output = self.feed_forward(attn_output) return ff_output

解码器层的实现稍复杂，因为它包含掩码自注意力和交叉注意力。

class DecoderLayer(nn.Module): def __init__(self, d_model=512, num_heads=8, d_ff=2048, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.cross_attn = MultiHeadAttention(d_model, num_heads, dropout) self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout) def forward(self, x, encoder_output, src_mask, tgt_mask): # x: [batch_size, tgt_len, d_model] 解码器输入（上一层的输出或目标序列嵌入） # encoder_output: [batch_size, src_len, d_model] # src_mask: [batch_size, 1, 1, src_len] # tgt_mask: [batch_size, 1, tgt_len, tgt_len] 用于屏蔽未来信息 self_attn_output, _ = self.self_attn(x, x, x, mask=tgt_mask) cross_attn_output, attn_weights = self.cross_attn(self_attn_output, encoder_output, encoder_output, mask=src_mask) ff_output = self.feed_forward(cross_attn_output) return ff_output, attn_weights

4.3 位置编码与模型整合

实现正弦位置编码，并组装完整的Transformer模型。

class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=5000, dropout=0.1): super().__init__() self.dropout = nn.Dropout(p=dropout) pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) # [max_len, 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_len, d_model] self.register_buffer('pe', pe) # 这不是模型参数，不参与梯度更新 def forward(self, x): # x: [batch_size, seq_len, d_model] x = x + self.pe[:, :x.size(1), :] return self.dropout(x) class Transformer(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model=512, num_heads=8, num_encoder_layers=6, num_decoder_layers=6, d_ff=2048, max_len=100, dropout=0.1): 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.pos_encoding = PositionalEncoding(d_model, max_len, dropout) # 编码器和解码器堆叠 self.encoder_layers = nn.ModuleList([ EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_encoder_layers) ]) self.decoder_layers = nn.ModuleList([ DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_decoder_layers) ]) # 输出层 self.fc_out = nn.Linear(d_model, tgt_vocab_size) # 初始化参数 self._init_parameters() def _init_parameters(self): for p in self.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p) def encode(self, src, src_mask): src_embedded = self.src_embedding(src) * math.sqrt(self.d_model) src_embedded = self.pos_encoding(src_embedded) enc_output = src_embedded for layer in self.encoder_layers: enc_output = layer(enc_output, src_mask) return enc_output def decode(self, tgt, enc_output, src_mask, tgt_mask): tgt_embedded = self.tgt_embedding(tgt) * math.sqrt(self.d_model) tgt_embedded = self.pos_encoding(tgt_embedded) dec_output = tgt_embedded for layer in self.decoder_layers: dec_output, _ = layer(dec_output, enc_output, src_mask, tgt_mask) return dec_output def forward(self, src, tgt, src_mask=None, tgt_mask=None): # src, tgt: [batch_size, seq_len] if src_mask is None: src_mask = (src != pad_idx).unsqueeze(1).unsqueeze(2) # [batch_size, 1, 1, src_len] if tgt_mask is None: tgt_padding_mask = (tgt != pad_idx).unsqueeze(1).unsqueeze(2) tgt_len = tgt.size(1) subsequent_mask = torch.tril(torch.ones(tgt_len, tgt_len)).bool().to(tgt.device) # 下三角掩码 tgt_mask = tgt_padding_mask & subsequent_mask.unsqueeze(0).unsqueeze(0) enc_output = self.encode(src, src_mask) dec_output = self.decode(tgt, enc_output, src_mask, tgt_mask) output = self.fc_out(dec_output) # [batch_size, tgt_len, tgt_vocab_size] return output

4.4 训练循环与推理示例

最后，我们搭建一个简单的训练循环。这里使用交叉熵损失和Adam优化器。

# 假设 pad_idx 已定义 pad_idx = src_vocab['<pad>'] model = Transformer(src_vocab_size=len(src_vocab), tgt_vocab_size=len(tgt_vocab), d_model=512, num_heads=8, num_encoder_layers=3, # 为快速演示，层数减少 num_decoder_layers=3, d_ff=2048, max_len=100, dropout=0.1) criterion = nn.CrossEntropyLoss(ignore_index=pad_idx) # 忽略pad位置的损失 optimizer = optim.Adam(model.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) def train_epoch(model, data_loader, optimizer, criterion, device): model.train() total_loss = 0 for batch_idx, (src, tgt) in enumerate(data_loader): src, tgt = src.to(device), tgt.to(device) # 构造目标输入和目标输出（右移一位） tgt_input = tgt[:, :-1] tgt_output = tgt[:, 1:] # 前向传播 optimizer.zero_grad() output = model(src, tgt_input) # output: [batch, tgt_len-1, vocab_size] # 计算损失 loss = criterion(output.reshape(-1, output.size(-1)), tgt_output.reshape(-1)) total_loss += loss.item() # 反向传播 loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # 梯度裁剪，防止爆炸 optimizer.step() return total_loss / len(data_loader) # 训练多个epoch num_epochs = 10 for epoch in range(num_epochs): train_loss = train_epoch(model, train_loader, optimizer, criterion, device) print(f'Epoch {epoch+1}, Loss: {train_loss:.4f}')

对于推理（贪婪解码），我们需要一个自回归生成的过程。

def greedy_decode(model, src, src_mask, max_len, start_symbol, end_symbol, device): model.eval() src = src.to(device) src_mask = src_mask.to(device) # 编码源序列 memory = model.encode(src, src_mask) # 初始化目标序列，以起始符开始 ys = torch.ones(1, 1).fill_(start_symbol).long().to(device) for i in range(max_len-1): # 为当前已生成序列创建掩码 tgt_mask = (ys != pad_idx).unsqueeze(1).unsqueeze(2) tgt_len = ys.size(1) subsequent_mask = torch.tril(torch.ones(tgt_len, tgt_len)).bool().to(device) tgt_mask = tgt_mask & subsequent_mask.unsqueeze(0).unsqueeze(0) # 解码 out = model.decode(ys, memory, src_mask, tgt_mask) prob = model.fc_out(out[:, -1, :]) # 取最后一个位置的输出 _, next_word = torch.max(prob, dim=1) next_word = next_word.item() ys = torch.cat([ys, torch.ones(1, 1).fill_(next_word).long().to(device)], dim=1) if next_word == end_symbol: break return ys.squeeze(0)[1:] # 去掉起始符

5. 实战避坑指南与进阶思考

5.1 训练中的常见问题与调参技巧

Transformer虽然强大，但训练起来并不总是顺风顺水。以下是一些常见坑点和应对策略：

1. 损失不下降或NaN：

   • 学习率太大：Transformer对学习率很敏感。建议使用论文中的Adam优化器参数（beta1=0.9， beta2=0.98， epsilon=1e-9）和“热身+逆平方根衰减”的学习率调度器。热身阶段（例如前4000步）线性增加学习率，之后按步数的平方根衰减。
   • 梯度爆炸：务必使用梯度裁剪（clip_grad_norm_），通常将max_norm设置在0.5到1.0之间。
   • 初始化问题：确保使用Xavier或Kaiming初始化。上面的代码中_init_parameters方法做了这件事。
   • 数据或掩码错误：检查你的padding mask和causal mask是否正确。一个错误的掩码可能导致注意力权重全为0或NaN。

2. 过拟合：

   • Dropout：Transformer中大量使用了Dropout，包括注意力权重Dropout和前馈网络中的Dropout。这是防止过拟合的主要手段，通常设置为0.1。
   • 标签平滑：在计算交叉熵损失时使用标签平滑（Label Smoothing），可以缓解模型对正确标签的过度自信，提升泛化能力。PyTorch的CrossEntropyLoss可以通过手动修改target来实现。

3. 训练速度慢：

   • 激活检查点：对于非常大的模型，可以使用torch.utils.checkpoint来节省显存，用计算时间换空间。
   • 混合精度训练：使用torch.cuda.amp进行自动混合精度训练，可以显著减少显存占用并加速计算。
   • 数据加载：确保数据加载没有瓶颈，使用DataLoader的num_workers和pin_memory选项。

5.2 超越原始Transformer：关键变体与演进

原始的Transformer只是一个起点，后续涌现了大量改进工作：

• Transformer-XL：引入了段级递归和相对位置编码，让模型能够处理超长文本，并更好地建模长期依赖。
• BERT：采用了Transformer的编码器堆叠，并通过掩码语言模型和下一句预测任务进行预训练，开启了NLP的预训练-微调范式。
• GPT系列：基于Transformer的解码器堆叠，采用自回归语言建模进行预训练，在生成任务上表现出色。
• Vision Transformer：将图像分割成patch序列，加上位置编码后直接输入Transformer编码器，证明了其在计算机视觉领域的强大能力。
• Swin Transformer：引入了滑动窗口和分层下采样，让视觉Transformer能够像CNN一样高效处理多尺度特征，并降低了计算复杂度。
• 高效注意力机制：如Linformer、Performer、Longformer等，通过低秩近似、核方法、稀疏注意力等方式，将自注意力的计算和内存复杂度从O(n²)降低到O(n)或O(n log n)，使其能处理更长的序列。

5.3 从NLP到多模态：Transformer的统一之路

Transformer的通用性使其成为多模态学习的理想骨架。核心思想是将不同模态（文本、图像、音频）的数据都转化为序列化的token，并加上可区分的模态类型嵌入。

• CLIP：分别用图像编码器和文本编码器（都是Transformer）提取特征，在对比学习的框架下进行训练，实现了图像和文本的跨模态对齐。
• DALL-E：将文本和图像都离散化为token，使用自回归Transformer进行生成。
• 多模态大模型：通常有一个核心的Transformer作为融合器，接收来自各模态编码器的token序列，通过交叉注意力进行交互，最终完成理解或生成任务。

实现多模态Transformer的关键在于设计好不同模态数据的Tokenizer（如何将数据切分成token）和投影层（如何将不同模态的特征映射到统一的语义空间）。

我个人在复现和魔改Transformer的过程中，最深的一点体会是：理解架构的动机比记住公式更重要。当你明白了自注意力是为了解决并行化和长程依赖，位置编码是为了注入顺序信息，残差和层归一化是为了稳定深层训练，你就能更灵活地调整它来适应你的任务。比如，在处理具有强层次结构的数据时，你可能会想引入局部注意力或层次化注意力；在处理超长序列时，稀疏注意力或线性注意力可能就是必需品。不要把它当作一个黑盒，而是当作一套可以自由组合的乐高积木。