《Transformer黑魔法Mask与Softmax、Attention的关系：一个-∞符号如何让AI学会“选择性失明“》

【Transformer基石】Attention Mask全解析：为何-∞能让Softmax"视而不见"？

摘要：初学 Transformer 的同学经常会卡在一个"反直觉"的点上：既然 Transformer 的任务是像写小说一样，一个词一个词地往后预测，那为什么训练的时候它却能"一口吃成个胖子"，并行处理一整句话呢？本文将用最直白的比喻、最详尽的案例和代码，为你彻底揭开这个谜底。

一、引言：模型也会"非礼勿视"？

1.1 从人类认知说起

想象一个场景：你正在做一篇英语完形填空。为了得到最准确的答案，你必须根据上下文来推断。但有一个前提：你不能提前看到标准答案，也不能看到后面的句子。你的目光只能停留在当前空格之前的内容上。

具体例子：

The weather was _____ so we decided to stay home.
A. sunny  B. terrible  C. warm  D. pleasant

如果你能看到后面的"stay home"，答案显然是B（terrible）。但在真实考试中，你只能基于"The weather was"来猜测，这就困难多了。

1.2 AI模型的"考试规则"

在人工智能领域，尤其是在处理序列数据（如文本、语音）时，模型也面临同样的问题：

生成任务中的时间因果性

• 写小说场景：当AI写到"他打开门，看到了…“时，它不应该知道后面会写"一只猫"还是"空荡荡的房间”
• 机器翻译场景：翻译"I love"时，模型不能提前知道后面是"you"还是"ice cream"
• 对话系统场景：回答用户问题时，不能预知用户下一句会说什么

批处理中的数据对齐问题

原始句子：
1. "I love AI"           (3个词)
2. "Machine learning is amazing"  (4个词)  
3. "Hello"               (1个词)填充后（为了GPU并行处理）：
1. "I love AI <pad> <pad>"
2. "Machine learning is amazing <pad>"
3. "Hello <pad> <pad> <pad> <pad>"

模型必须明白，这些<pad>符号是毫无意义的"噪音"，在计算中应当被忽略。

1.3 解决方案预览

如何让模型学会这种"有选择性失明"的能力？答案就是Attention Mask（注意力掩码）。本文的核心，就是剖析这个掩码与Softmax函数结合后，所产生的神奇化学反应。

核心思想：

• 不是真的让模型"看不见"某些位置
• 而是让这些位置在数学计算上"不产生影响"
• 通过巧妙利用 $-\infty$ 和 $e^{-\infty }=0$ 的数学性质实现

二、通俗理解：一场"被操纵"的极限投票

2.1 投票大会的完整场景

在深入数学细节之前，我们先用一个生动的比喻来建立直观感受。

想象一下，Attention机制就是一场人气投票大会。具体场景如下：

参与者角色：

• 查询者（Query）：当前正在处理的词，比如"我爱"中的"爱"
• 候选人（Keys）：序列中的所有词，包括"我"、"爱"以及后面的词
• 价值提供者（Values）：每个词携带的信息内容

2.2 投票过程详解

第一步：初始票数（Logits）

通过Query和各个Key的匹配度计算，每个"候选人"都会得到一个初始票数。

实际例子：

句子："我爱学习人工智能"
当前Query："学习"初始票数（相似度分数）：
- "我"：2.3
- "爱"：5.7  
- "学习"：8.9 （自己和自己最相似）
- "人工"：-1.2 （还没出现，不该有分数）
- "智能"：-0.8 （还没出现，不该有分数）

第二步："作废"选票（Masking）

现在，一个"裁判"（Mask）入场了。裁判手里有一份"作弊名单"。

裁判的操作规则：

# 原始规则
if 候选人在未来位置:票数 = 票数 + (-∞)
elif 候选人是填充符:票数 = 票数 + (-∞)
else:票数 = 票数 + 0  # 不变

操作后的票数：

- "我"：2.3 + 0 = 2.3
- "爱"：5.7 + 0 = 5.7
- "学习"：8.9 + 0 = 8.9
- "人工"：-1.2 + (-∞) = -∞
- "智能"：-0.8 + (-∞) = -∞

第三步：公布得票率（Softmax）

主持人（Softmax函数）根据最终票数计算百分比。

数学计算过程：

总票数 = e^2.3 + e^5.7 + e^8.9 + e^(-∞) + e^(-∞)= 10.0 + 298.9 + 7332.0 + 0 + 0= 7640.9得票率：
- "我"：10.0/7640.9 = 0.13%
- "爱"：298.9/7640.9 = 3.91%
- "学习"：7332.0/7640.9 = 95.96%
- "人工"：0/7640.9 = 0%
- "智能"：0/7640.9 = 0%

2.3 为什么是负无穷？

关键洞察：使用其他负数行不行？

让我们做个对比实验：

import numpy as np# 原始分数
scores = [2.3, 5.7, 8.9, -1.2, -0.8]# 方案1：使用-100
masked_scores_100 = [2.3, 5.7, 8.9, -1.2-100, -0.8-100]
weights_100 = np.exp(masked_scores_100) / np.sum(np.exp(masked_scores_100))
print(f"使用-100时的权重：{weights_100}")
# 结果：[0.0013, 0.0391, 0.9596, 1.3838e-45, 1.8364e-45]# 方案2：使用-1000  
masked_scores_1000 = [2.3, 5.7, 8.9, -1.2-1000, -0.8-1000]
weights_1000 = np.exp(masked_scores_1000) / np.sum(np.exp(masked_scores_1000))
print(f"使用-1000时的权重：{weights_1000}")
# 结果：[0.0013, 0.0391, 0.9596, 0, 0]

结论：

• 使用-100时，被遮蔽位置仍有极小的权重（$10^{-45}$级别）
• 使用-1000时，在float32精度下已经等效于0
• 理论上的$-\infty$保证了数学上的精确为0

三、专业学术阐释：深入Softmax的数学原理

3.1 Softmax函数的完整剖析

3.1.1 基础定义与性质

Softmax函数，又称归一化指数函数，其作用是将一个任意实数的向量$z$转换成一个概率分布向量$S(z)$。

公式：
$$S(z_i)=\frac{e^{z_i}}{{\sum }_{j=1}^K{e}^{z_j}}\text{for }i=1,\dots ,K$$

详细解释：

• $z=[z_1,z_2,...,z_K]$：输入的logits向量，包含$K$个元素
• $z_i$：向量$z$中的第$i$个元素，可以是任意实数
• $e\approx 2.71828$：自然对数的底数
• ${\sum }_{j=1}^K{e}^{z_j}$：归一化因子，确保输出和为1

3.1.2 Softmax的深层性质

1. 平移不变性：
$$\text{softmax}(z+c)=\text{softmax}(z)$$
其中$c$是常数向量$[c,c,...,c]$

证明与应用：

# 数值稳定性技巧
def stable_softmax(x):# 减去最大值，防止数值溢出x_max = np.max(x)exp_x = np.exp(x - x_max)return exp_x / np.sum(exp_x)

2. 温度缩放：
$$S(z_i;T)=\frac{e^{z_i/T}}{{\sum }_{j=1}^K{e}^{z_j/T}}$$

温度$T$的影响：

• $T\to 0$：分布趋向one-hot（赢者通吃）
• $T=1$：标准softmax
• $T\to \infty$：分布趋向均匀分布

可视化例子：

import matplotlib.pyplot as pltlogits = [2.0, 1.0, 0.5, 0.1]
temperatures = [0.1, 0.5, 1.0, 2.0, 5.0]for T in temperatures:probs = np.exp(np.array(logits)/T)probs = probs / np.sum(probs)plt.plot(probs, label=f'T={T}')plt.legend()
plt.title('Softmax温度效应')
plt.xlabel('类别')
plt.ylabel('概率')

3.2 Attention中的掩码机制

3.2.1 标准注意力公式

在Transformer中，缩放点积注意力的完整公式为：

$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}+M\right)V$$

维度详解：

设：batch_size=2, num_heads=8, seq_len=10, d_k=64Q: [2, 8, 10, 64]  # [批次, 头数, 序列长度, 键维度]
K: [2, 8, 10, 64]
V: [2, 8, 10, 64]QK^T: [2, 8, 10, 10]  # 每个位置对所有位置的原始分数
M: [10, 10] -> 广播至 [2, 8, 10, 10]  # 掩码矩阵

3.2.2 缩放因子$\sqrt{d_k}$的重要性

为什么要除以$\sqrt{d_k}$？

当$d_k$较大时，点积$Q{K}^T$的方差会很大：
$$\text{Var}(q\cdot k)=d_k\cdot \text{Var}(q_i)\cdot \text{Var}(k_i)$$

假设$q_i,k_i\sim \mathcal{N}(0,1)$，则：
$$\text{Var}(q\cdot k)=d_k$$

不缩放的后果：

# 演示：大维度下的梯度消失问题
d_k_values = [8, 64, 512]
for d_k in d_k_values:# 随机初始化q = np.random.randn(d_k)k = np.random.randn(d_k)# 计算点积dot_product = np.dot(q, k)scaled_dot = dot_product / np.sqrt(d_k)print(f"d_k={d_k}:")print(f"  未缩放点积: {dot_product:.2f}")print(f"  缩放后点积: {scaled_dot:.2f}")print(f"  softmax导数量级: {np.exp(dot_product):.2e}")print()

3.3 掩码的数学原理深度剖析

3.3.1 极限分析

考虑向量$z=[z_1,z_2,...,z_k,-M]$，其中$M\to \infty$：

$$\underset{M\to \infty }{\lim }S(z_k)=\underset{M\to \infty }{\lim }\frac{e^{-M}}{{\sum }_{j=1}^{k-1}{e}^{z_j}+e^{-M}}$$

应用洛必达法则或直接分析：
$$=\frac{0}{{\sum }_{j=1}^{k-1}{e}^{z_j}+0}=0$$

3.3.2 数值稳定性考虑

实践中的"负无穷"选择：

# 不同框架的实现
PYTORCH_NINF = -1e9
TENSORFLOW_NINF = -1e10  
JAX_NINF = -1e30# 为什么不用float('-inf')?
# 1. 某些操作可能产生NaN
# 2. 梯度计算可能不稳定

安全的掩码实现：

def safe_masked_softmax(logits, mask, mask_value=-1e9):"""Args:logits: [batch, ..., seq_len]mask: [batch, ..., seq_len], True表示要遮蔽"""# 创建掩码值矩阵mask_values = mask_value * mask.float()# 应用掩码masked_logits = logits + mask_values# 计算softmaxreturn F.softmax(masked_logits, dim=-1)

四、代码示例与数据流：眼见为实

4.1 完整的Attention实现

让我们实现一个包含所有细节的注意力机制：

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as pltclass DetailedAttention(nn.Module):def __init__(self, d_model, n_heads):super().__init__()self.d_model = d_modelself.n_heads = n_headsself.d_k = d_model // n_heads# 线性变换层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 forward(self, x, mask=None, return_attention=False):batch_size, seq_len, _ = x.shape# 1. 线性变换并reshape为多头Q = self.W_q(x).view(batch_size, seq_len, self.n_heads, self.d_k)K = self.W_k(x).view(batch_size, seq_len, self.n_heads, self.d_k)V = self.W_v(x).view(batch_size, seq_len, self.n_heads, self.d_k)# 转置以匹配期望的维度Q = Q.transpose(1, 2)  # [batch, n_heads, seq_len, d_k]K = K.transpose(1, 2)V = V.transpose(1, 2)# 2. 计算注意力分数scores = torch.matmul(Q, K.transpose(-2, -1)) / np.sqrt(self.d_k)# 3. 应用掩码（如果提供）if mask is not None:# 扩展mask以匹配scores的维度if mask.dim() == 2:  # [seq_len, seq_len]mask = mask.unsqueeze(0).unsqueeze(0)elif mask.dim() == 3:  # [batch, seq_len, seq_len]mask = mask.unsqueeze(1)scores = scores.masked_fill(mask == 1, -1e9)# 4. 应用softmaxattention_weights = F.softmax(scores, dim=-1)# 5. 应用dropout（训练时）# attention_weights = F.dropout(attention_weights, p=0.1)# 6. 加权求和context = torch.matmul(attention_weights, V)# 7. 重新排列并通过输出投影context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)output = self.W_o(context)if return_attention:return output, attention_weightsreturn output# 测试代码
def test_attention_with_masks():# 设置d_model = 512n_heads = 8seq_len = 6batch_size = 2# 创建模型attention = DetailedAttention(d_model, n_heads)# 创建输入x = torch.randn(batch_size, seq_len, d_model)# 创建不同类型的掩码# 1. Look-ahead masklook_ahead_mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)# 2. Padding mask (假设最后2个位置是padding)padding_mask = torch.zeros(batch_size, seq_len, seq_len)padding_mask[:, :, -2:] = 1# 3. 组合maskcombined_mask = torch.max(look_ahead_mask.unsqueeze(0), padding_mask)# 运行并可视化_, weights_no_mask = attention(x, mask=None, return_attention=True)_, weights_look_ahead = attention(x, mask=look_ahead_mask, return_attention=True)_, weights_padding = attention(x, mask=padding_mask, return_attention=True)_, weights_combined = attention(x, mask=combined_mask, return_attention=True)# 可视化函数def plot_attention(weights, title):plt.figure(figsize=(8, 6))# 取第一个batch，第一个head的权重w = weights[0, 0].detach().numpy()plt.imshow(w, cmap='Blues', aspect='auto')plt.colorbar()plt.title(title)plt.xlabel('Key positions')plt.ylabel('Query positions')for i in range(seq_len):for j in range(seq_len):plt.text(j, i, f'{w[i,j]:.2f}', ha='center', va='center',color='white' if w[i,j] > 0.5 else 'black')plt.tight_layout()plt.show()# 绘制所有结果plot_attention(weights_no_mask, 'No Mask')plot_attention(weights_look_ahead, 'Look-ahead Mask')plot_attention(weights_padding, 'Padding Mask')plot_attention(weights_combined, 'Combined Mask')# 运行测试
test_attention_with_masks()

4.2 实际训练中的Mask应用

class TransformerDecoderBlock(nn.Module):def __init__(self, d_model, n_heads, d_ff, dropout=0.1):super().__init__()# 自注意力层（需要look-ahead mask）self.self_attention = DetailedAttention(d_model, n_heads)self.norm1 = nn.LayerNorm(d_model)# 交叉注意力层（需要padding mask）self.cross_attention = DetailedAttention(d_model, n_heads)self.norm2 = nn.LayerNorm(d_model)# 前馈网络self.ffn = nn.Sequential(nn.Linear(d_model, d_ff),nn.ReLU(),nn.Linear(d_ff, d_model))self.norm3 = nn.LayerNorm(d_model)self.dropout = nn.Dropout(dropout)def forward(self, x, encoder_output, tgt_mask, memory_mask):# 1. 自注意力（带look-ahead mask）attn_output = self.self_attention(x, mask=tgt_mask)x = self.norm1(x + self.dropout(attn_output))# 2. 交叉注意力（编码器-解码器）attn_output = self.cross_attention(x, encoder_output, mask=memory_mask)x = self.norm2(x + self.dropout(attn_output))# 3. 前馈网络ffn_output = self.ffn(x)x = self.norm3(x + self.dropout(ffn_output))return x

4.3 动态Mask生成示例

在实际应用中，mask通常需要动态生成：

def create_masks(src, tgt, src_pad_idx=0, tgt_pad_idx=0):"""为Transformer创建所有必要的maskArgs:src: 源序列 [batch, src_len]tgt: 目标序列 [batch, tgt_len]src_pad_idx: 源序列的padding索引tgt_pad_idx: 目标序列的padding索引Returns:src_mask: 编码器的padding masktgt_mask: 解码器的组合mask（look-ahead + padding）memory_mask: 交叉注意力的mask"""# 源序列的padding masksrc_mask = (src == src_pad_idx).unsqueeze(1).unsqueeze(2)# [batch, 1, 1, src_len]# 目标序列的padding masktgt_pad_mask = (tgt == tgt_pad_idx).unsqueeze(1).unsqueeze(3)# [batch, 1, tgt_len, 1]# Look-ahead masktgt_len = tgt.shape[1]tgt_sub_mask = torch.triu(torch.ones(tgt_len, tgt_len), diagonal=1).bool()# [tgt_len, tgt_len]# 组合目标masktgt_mask = tgt_pad_mask | tgt_sub_mask# [batch, 1, tgt_len, tgt_len]# Memory mask（用于交叉注意力）memory_mask = src_mask# [batch, 1, 1, src_len]return src_mask, tgt_mask, memory_mask# 使用示例
src = torch.tensor([[1, 2, 3, 0, 0],[1, 2, 0, 0, 0]])  # 0是padding
tgt = torch.tensor([[1, 2, 3, 4, 0],[1, 2, 3, 0, 0]])src_mask, tgt_mask, memory_mask = create_masks(src, tgt)
print(f"源mask形状: {src_mask.shape}")
print(f"目标mask形状: {tgt_mask.shape}")
print(f"内存mask形状: {memory_mask.shape}")

五、具体应用案例：Mask的多样化应用

5.1 Look-ahead Mask：解码器的"防作弊"机制

5.1.1 为什么需要"防作弊"？

训练时的Teacher Forcing：

目标句子: "I love machine learning"训练时输入输出对：
Input:  [<START>, I,     love,    machine]
Output: [I,       love,  machine, learning]

如果没有mask，模型在预测"love"时可以看到整个输入序列，包括"machine"，这就像考试时能看到答案一样。

5.1.2 具体应用场景

1. GPT系列模型

class GPTBlock(nn.Module):def __init__(self, config):super().__init__()self.attention = DetailedAttention(config.n_embd, config.n_head)self.ln1 = nn.LayerNorm(config.n_embd)self.ln2 = nn.LayerNorm(config.n_embd)self.mlp = nn.Sequential(nn.Linear(config.n_embd, 4 * config.n_embd),nn.GELU(),nn.Linear(4 * config.n_embd, config.n_embd),)def forward(self, x):# 始终使用causal maskseq_len = x.size(1)mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)x = x + self.attention(self.ln1(x), mask=mask)x = x + self.mlp(self.ln2(x))return x

2. 文本生成任务

def generate_text(model, prompt, max_length=50, temperature=1.0):"""自回归文本生成"""model.eval()tokens = tokenize(prompt)for _ in range(max_length):# 获取模型预测with torch.no_grad():logits = model(tokens)# 只关注最后一个位置的预测next_token_logits = logits[:, -1, :] / temperature# 采样下一个tokenprobs = F.softmax(next_token_logits, dim=-1)next_token = torch.multinomial(probs, num_samples=1)# 添加到序列tokens = torch.cat([tokens, next_token], dim=1)# 检查是否结束if next_token.item() == eos_token_id:breakreturn decode(tokens)

5.2 Padding Mask：批处理的效率保证

5.2.1 为什么需要Padding？

GPU并行计算的需求：

# 低效的循环处理
for sentence in batch:output = model(sentence)  # 每个句子长度不同# 高效的批处理
padded_batch = pad_sequences(batch)  # 统一长度
outputs = model(padded_batch)  # 一次处理整个批次

5.2.2 Padding带来的问题与解决

问题示例：

# 原始句子
sentences = ["Hello world",      # 长度: 2"I love AI",        # 长度: 3  "Deep learning",    # 长度: 2
]# Padding后（假设词汇表中 <PAD>=0）
padded = [[15, 76, 0],       # "Hello world <PAD>"[9, 23, 5],        # "I love AI"[41, 88, 0],       # "Deep learning <PAD>"
]# 不使用mask时的问题：
# 1. <PAD>会参与注意力计算
# 2. 影响其他词的注意力分布
# 3. 在某些情况下导致梯度问题

解决方案实现：

class PaddingMaskAttention(nn.Module):def forward(self, query, key, value, key_padding_mask=None):"""Args:query, key, value: [batch, seq_len, d_model]key_padding_mask: [batch, seq_len], True表示padding位置"""batch_size, seq_len, d_model = query.shape# 计算注意力分数scores = torch.matmul(query, key.transpose(-2, -1))scores = scores / math.sqrt(d_model)# 应用padding maskif key_padding_mask is not None:# 扩展mask维度: [batch, seq_len] -> [batch, 1, seq_len]key_padding_mask = key_padding_mask.unsqueeze(1)# 广播: [batch, 1, seq_len] -> [batch, seq_len, seq_len]expanded_mask = key_padding_mask.expand(-1, seq_len, -1)# 应用maskscores = scores.masked_fill(expanded_mask, -1e9)# Softmaxweights = F.softmax(scores, dim=-1)# 加权求和output = torch.matmul(weights, value)return output, weights

5.3 特殊Mask应用

5.3.1 稀疏注意力（Sparse Attention）

用于处理超长序列，只关注部分位置：

def create_sparse_mask(seq_len, window_size=5, stride=3):"""创建稀疏注意力mask每个位置只能看到：1. 局部窗口内的位置2. 每隔stride的全局位置"""mask = torch.ones(seq_len, seq_len)for i in range(seq_len):# 局部窗口start = max(0, i - window_size)end = min(seq_len, i + window_size + 1)mask[i, start:end] = 0# 全局位置mask[i, ::stride] = 0# 确保能看到自己mask.fill_diagonal_(0)return mask.bool()# 可视化稀疏模式
sparse_mask = create_sparse_mask(50, window_size=5, stride=10)
plt.imshow(sparse_mask, cmap='gray')
plt.title('稀疏注意力模式')
plt.show()

5.3.2 分组注意力（Grouped Attention）

不同组之间不能相互注意：

def create_group_mask(seq_len, group_sizes):"""创建分组mask例如: group_sizes = [10, 15, 25] 表示三个组"""mask = torch.ones(seq_len, seq_len)start = 0for size in group_sizes:end = start + size# 组内可以相互注意mask[start:end, start:end] = 0start = endreturn mask.bool()# 示例：模拟多轮对话
# 用户1(5词) -> 助手1(8词) -> 用户2(6词) -> 助手2(10词)
group_mask = create_group_mask(29, [5, 8, 6, 10])

六、性能优化与实践技巧

6.1 Flash Attention中的Mask优化

Flash Attention通过融合计算减少内存访问：

# 传统方法：多次内存读写
def traditional_attention(Q, K, V, mask):scores = torch.matmul(Q, K.transpose(-2, -1))  # 内存写入scores = scores / math.sqrt(d_k)                # 内存读写scores = scores + mask                          # 内存读写weights = F.softmax(scores, dim=-1)            # 内存读写output = torch.matmul(weights, V)              # 内存读写return output# Flash Attention思路：融合kernel
# 在CUDA kernel中一次完成所有操作，减少内存传输

6.2 常见错误与调试

1. Mask维度错误

def debug_mask_dimensions(mask, scores):print(f"Mask shape: {mask.shape}")print(f"Scores shape: {scores.shape}")# 自动修复维度if mask.dim() < scores.dim():# 添加缺失的维度for _ in range(scores.dim() - mask.dim()):mask = mask.unsqueeze(0)return mask

2. 数值稳定性问题

def safe_log_softmax(logits, mask, temperature=1.0):"""数值稳定的log_softmax with mask"""# 应用温度logits = logits / temperature# 应用maskmasked_logits = logits.masked_fill(mask, -1e9)# 数值稳定的log_softmaxmax_logits = masked_logits.max(dim=-1, keepdim=True)[0]exp_logits = torch.exp(masked_logits - max_logits)sum_exp = exp_logits.sum(dim=-1, keepdim=True)log_probs = masked_logits - max_logits - torch.log(sum_exp)return log_probs

七、深入理解：从理论到实践的桥梁

7.1 为什么Transformer训练可以并行？

这是很多初学者的困惑。关键在于理解训练和推理的区别：

训练时（Teacher Forcing）：

# 输入："I love machine learning"
# 目标："love machine learning <EOS>"# 一次性处理整个序列
def training_step(model, input_ids, target_ids):# 创建causal mask确保不能看到未来seq_len = input_ids.size(1)mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)# 并行计算所有位置logits = model(input_ids, mask=mask)  # [batch, seq_len, vocab_size]# 计算每个位置的损失loss = F.cross_entropy(logits.view(-1, vocab_size),target_ids.view(-1))return loss

推理时（自回归生成）：

# 必须逐个生成
def inference_step(model, prompt):output = promptfor _ in range(max_length):# 只能基于已生成的内容next_token = model.generate_next(output)output.append(next_token)return output

7.2 Mask在不同任务中的变体

1. BERT的双向Mask

# BERT不需要causal mask，但需要[MASK] token的attention mask
def create_bert_mask(input_ids, mask_token_id):# 允许所有位置相互看见seq_len = input_ids.size(1)mask = torch.zeros(seq_len, seq_len)# 但[MASK]位置的输出不应该直接看到自己mask_positions = (input_ids == mask_token_id)# ... 特殊处理return mask

2. Prefix LM的混合Mask

def create_prefix_lm_mask(seq_len, prefix_len):"""前prefix_len个token可以相互看见（双向）之后的token只能看见之前的（单向）"""mask = torch.ones(seq_len, seq_len)# Prefix部分：双向mask[:prefix_len, :prefix_len] = 0# 生成部分：单向for i in range(prefix_len, seq_len):mask[i, :i+1] = 0return mask.bool()

八、总结：简单背后的深刻

8.1 核心要点回顾

1. Attention Mask的本质：通过数学技巧实现"选择性失明"
2. -∞的妙用：利用$e^{-\infty }=0$实现精确的概率归零
3. 两大应用场景：
   • Look-ahead Mask：保证因果性
   • Padding Mask：处理变长序列
4. 实现优雅性：仅通过加法操作就改变了整个注意力分布

8.2 设计哲学

Transformer的成功很大程度上源于其将复杂的序列依赖问题转化为简单的矩阵运算。Attention Mask正是这种设计哲学的完美体现：

• 简单性：只需要逐元素加法
• 高效性：完全可并行化
• 通用性：适用于各种场景
• 数学优雅：利用极限性质

8.3 未来展望

随着模型规模的增长和应用场景的拓展，Mask机制也在不断演进：

1. 动态Mask：根据内容自适应调整注意力模式
2. 学习型Mask：让模型自己学习最优的注意力模式
3. 高效Mask：如Flash Attention等优化实现
4. 多模态Mask：处理图像、视频等其他模态

如果这篇文章对你有帮助的话，麻烦佬【点赞】【收藏】【加关注】。如有不足敬请指出。