ALiBi位置编码的数值陷阱：长序列下注意力失明与修复策略

训练大模型的朋友可能都遇到过这一类场景：训练曲线一直很漂亮，某个 step 突然跳出一个 loss spike，恢复后效果却再也回不到原来的水平；或者模型序列长度越拉越长，长文本任务的表现反而下降，模型像是把前面的内容“忘掉”了。排查时总会先怀疑学习率、数据质量、显存溢出，很少有人会想到：问题可能不在优化器，也不在数据，而在 attention 内部一个几行代码就能实现的位置编码——ALiBi 的数值稳定性。

ALiBi 全称 Attention with Linear Biases，凭借零参数、训练友好、外推能力强的特点，成为很多大模型和长文本项目的位置编码首选。但正因为实现太简单，它的数值隐患也特别容易被忽略。我的核心判断是：ALiBi 的偏置量会随 token 距离线性增长，在低精度训练、高维度 head、超长序列的组合条件下，attention logits 会被推入极端负值区间，经过 softmax 后注意力分布发生“失明”，表现为注意力熵骤降、梯度消失、loss 不稳定或长文本效果退化。这篇文章会从问题场景切入，拆解 ALiBi 的原理和公式，用 PyTorch 脚本复现“失明”过程，再给出可落地的诊断方法、修复策略和替代方案。

1. ALiBi 解决的是位置编码的什么问题

Transformer 本身没有时序概念。如果把一句话打乱词序输入模型，得到的向量表示几乎不变，因此必须给 token 注入位置信息。早期方案以绝对位置编码为主，比如 Transformer 原始论文里的正弦位置编码，以及 BERT 里可学习的绝对位置 Embedding。它们的思想是：给每个位置分配一个独立的向量，加到 token Embedding 上，让模型感知“这个词出现在第几个位置”。

绝对位置编码的问题在于外推能力差。训练时见过的最大位置是 512 或 1024，推理时遇到 2048 的序列长度，就需要插值或直接外推，效果往往明显下降。更重要的一点是，绝对位置编码把位置信息“混入”了 token 表示，模型必须额外学习如何从混合向量中分离内容与位置。

相对位置编码的思路不同：不关心 token 的绝对位置，只关心 query 和 key 之间的相对距离。T5 的 Relative Bias 给不同距离分配不同的可学习偏置，RoPE 通过旋转矩阵把相对位置信息编码进 Q/K 内积。ALiBi 是这种思路里最极简的一支：它不给模型增加任何位置 Embedding，也不修改 Q/K/V 的生成方式，只做一件事——在 attention score 上，按 query 与 key 的距离减去一个线性增长的偏置。

这带来的直接好处有四个：

• 零参数，不需要为长序列额外训练位置 Embedding。
• 推理阶段无需位置插值，长度外推能力天然优于绝对位置编码。
• 改动极小，任何标准 attention 实现加几行代码就能切换。
• 与 FlashAttention 这类高效注意力 Kernel 容易集成，因为没有额外的位置向量参与矩阵运算。

正因为这种极简，ALiBi 在很长一段时间里成了“省心”的代名词。但省心不代表没有风险，问题恰恰藏在那个看似人畜无害的线性偏置里。

2. ALiBi 核心原理与标准实现

2.1 公式拆解

标准 softmax attention 的计算公式是：

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

其中d是 head 维度。加入 ALiBi 后，公式变成：

Attention(Q, K, V) = softmax(Q * K^T + bias) * V

这里的bias是一个只与距离相关的矩阵。对于第i个 query 和第j个 key：

bias[i][j] = -m * (i - j)

其中m是每个 head 对应的斜率。需要注意的是(i - j)只对i > j生效，也就是只作用于 causal mask 范围内的“左侧 token”。距离越远，偏置越负，模型在计算当前位置时，对远处历史 token 的注意力权重被抑制。

2.2 不同 head 的斜率从哪来

ALiBi 论文里规定，如果模型有n个 head，那么每个 head 的斜率按几何级数生成：

m = 2^(-8/n * k)

其中k从 1 到n。也就是说，第一个 head 的斜率是2^(-8/n)，最后一个 head 的斜率是2^(-8)。这样设计的目的，是让不同的 head 拥有不同的“感受野”。斜率大的 head 注意力集中在很近的 token，斜率小的 head 可以覆盖更远的距离。这种多尺度设计让不同 head 分别捕捉局部和全局信息。

这里已经能看到第一个隐患：slope 不是用户手工指定的固定小值，而是根据 head 数自动生成的。head 数为 8 时，第一个 head 的m大约为2^(-1) = 0.5；head 数为 32 时，第一个 head 的m约为2^(-0.25) ≈ 0.84。当序列长度达到 2048 时，这个 head 在距离 2047 上的偏置大约是-0.84 * 2047 ≈ -1719。这个值已经远远超过常见 attention logits 的量级。

2.3 PyTorch 参考实现

下面给出一个标准的 ALiBi slope 生成函数和 attention 前向计算示例，便于后续实验对照。

# 文件路径：alibi_attention_demo.py import math import torch import torch.nn.functional as F def build_alibi_slopes(num_heads: int) -> torch.Tensor: """ 生成 ALiBi 每个 head 的斜率。 参考论文: https://arxiv.org/abs/2108.12409 """ def get_slope(head_idx): return 2 ** (-8 * (head_idx + 1) / num_heads) slopes = torch.tensor( [get_slope(i) for i in range(num_heads)], dtype=torch.float32, ) return slopes.view(num_heads, 1, 1) def build_alibi_bias(slopes: torch.Tensor, seq_len: int) -> torch.Tensor: """ 构建 ALiBi 偏置矩阵，形状为 [num_heads, seq_len, seq_len]。 只保留 causal 下三角部分，避免看到未来 token。 """ num_heads, _, _ = slopes.shape positions = torch.arange(seq_len, dtype=torch.float32) distance = positions.view(1, seq_len, 1) - positions.view(1, 1, seq_len) # 对 causal mask 之外的区域（j > i）不计算偏置，后续会被 mask 掉 bias = distance * slopes causal_mask = torch.triu( torch.ones(seq_len, seq_len, dtype=torch.bool), diagonal=1 ) bias = bias.masked_fill(causal_mask, float("-inf")) return bias def alibi_attention(query, key, value, slopes): """ query/key/value: [batch_size, num_heads, seq_len, head_dim] """ batch_size, num_heads, seq_len, head_dim = query.shape scale = head_dim ** 0.5 attn_weights = torch.matmul(query, key.transpose(-2, -1)) / scale alibi_bias = build_alibi_bias(slopes, seq_len) attn_weights = attn_weights + alibi_bias.to(attn_weights.device) attn_weights = F.softmax(attn_weights, dim=-1) attn_output = torch.matmul(attn_weights, value) return attn_output, attn_weights

这个实现没有对偏置做任何裁剪或缩放，这也是大多数简化版 ALiBi 实现的常见状态。问题现场，就藏在这个看似完整的代码里。

3. ALiBi 数值失效的场景与机制

3.1 一个反直觉的事实：偏置比注意力分数大几个数量级

很多人在实现 ALiBi 时，凭直觉认为m * (i - j)只是一个小惩罚项，比如距离 10 时减 0.5，距离 100 时减 5。这个直觉在短序列、head 数少的情况下成立，但在长序列、head 数多的情况下会彻底失效。

以 head 数 32、序列长度 4096 的模型为例，第一个 head 的 slope 约为0.84。距离 4000 的 token 会承受约-3360的偏置。而正常 attention logits 的量级是多少？在 head_dim 为 64 时，假设 Q 和 K 的每个元素都在[-1, 1]区间，Q * K^T的量级大约在几十到几百，即使除以sqrt(64) = 8，也不过是几十。也就是说，一个-3360的偏置完全可以把相对较远 token 的 logits 压到远低于任何有效信号的区间。

在数学上这不是 bug，它确实实现了“远处 token 对当前位置影响更小”的预期。但问题在于“压缩”和“消灭”是两回事。当偏置大到一定程度，softmax 里的exp(x)对远距离 token 的 logits 产生下溢，结果不是“权重变小”，而是权重直接变成 0。这时模型不再是对远距离信息“降低关注”，而是“完全失明”。

3.2 softmax 下溢之后：梯度消失

softmax 的计算过程是：

softmax(x_i) = exp(x_i - max(x)) / sum(exp(x_j - max(x)))

当某个x_i - max(x)非常负，比如小于-87（单精度 float32 下exp(-87)已经接近最小正规格化数），对应的exp结果就是0。在长序列中，远距离位置的梯度会因为权重为 0 而无法回传，导致模型根本学不到“如何使用远处信息”的梯度信号。

更麻烦的是，现代大模型训练普遍使用混合精度。float16 的动态范围远小于 float32，很多数值被抑制为 0 后，反向传播里对应位置的梯度也为 0。虽然这不会立刻让训练崩溃，但会积累成两类问题：一是远距离依赖长期得不到优化信号，长文本能力始终上不去；二是当某些层的 logits 出现极端值时，可能引发 NaN 或 Inf，进而造成训练不稳定。

3.3 与 RoPE 的数值特征对比

RoPE 的数值表现和 ALiBi 有很大差异。RoPE 通过旋转矩阵把位置信息编码进 Q/K 内积，相对位置带来的衰减是“旋转角度差”的函数，天然被限制在有限范围内，不会因为序列拉长而无限增长。ALiBi 的偏置则随距离线性增长，没有任何上限。

这并不是说 RoPE 一定优于 ALiBi，而是两者的数值边界不同。ALiBi 的简洁是以“偏置无界增长”为代价的，在工程上必须显式处理这个边界；RoPE 虽然实现更复杂，但数值上相对温和，不需要为位置偏置设置额外的裁剪逻辑。

3.4 与 FlashAttention 结合时的额外风险

FlashAttention 为了减少显存访问，在 Kernel 内部对 attention score 做在线 softmax，并通过缩放因子修正统计量。ALiBi 在 FlashAttention 中通常是作为 score bias 直接加到每个 tile 的 logits 上。如果 Kernel 内部对 bias 的处理不完整，或者使用低精度做累加，偏置的极端值会进一步放大数值误差。

这里的风险点在于：用户从 PyTorch 原生 attention 切换到 FlashAttention 时，得到的结果理论上应该基本一致，但数值精度会略有不同。当 ALiBi 偏置过大时，这种精度差异可能从“可忽略”变成“显著”，甚至导致同一个 checkpoint 在两种实现下生成完全不同的输出。因此，评估 ALiBi 模型时，必须分别在训练框架和推理框架中检查 logits 分布，而不是默认“结果应该一样”。

4. 最小复现实验：观察 ALiBi 的“失明”过程

下面用一个最小 PyTorch 脚本，观察不同序列长度和 slope 情况下，ALiBi 对 attention 分布熵值的影响。熵值是衡量注意力分布“集中程度”的常用指标，熵值越低，说明注意力越集中，越接近 one-hot 分布；当熵值降到接近 0，就可以认为注意力已经失明。

# 文件路径：alibi_failure_demo.py import math import torch import torch.nn.functional as F def compute_alibi_slope(head_idx, num_heads): return 2 ** (-8 * (head_idx + 1) / num_heads) def attention_entropy(attn_weights: torch.Tensor) -> torch.Tensor: """ 计算 attention 权重的熵值（按最后一个维度）。 输入形状: [batch, heads, seq_len, seq_len] """ eps = 1e-12 log_p = torch.log(attn_weights + eps) entropy = -(attn_weights * log_p).sum(dim=-1) return entropy.mean(dim=(0, 1)) def run_demo(seq_len=2048, num_heads=8, head_dim=64): torch.manual_seed(42) batch_size = 1 slopes = torch.tensor( [compute_alibi_slope(i, num_heads) for i in range(num_heads)], dtype=torch.float32, ).view(num_heads, 1, 1) # 构造接近实际分布的 Q/K，元素量级控制在 [-1, 1] query = torch.randn(batch_size, num_heads, seq_len, head_dim) key = torch.randn(batch_size, num_heads, seq_len, head_dim) query = query / query.abs().max(dim=-1, keepdim=True).values key = key / key.abs().max(dim=-1, keepdim=True).values scale = head_dim ** 0.5 attn_weights = torch.matmul(query, key.transpose(-2, -1)) / scale positions = torch.arange(seq_len, dtype=torch.float32) distance = positions.view(1, seq_len, 1) - positions.view(1, 1, seq_len) alibi_bias = distance * slopes causal_mask = torch.triu( torch.ones(seq_len, seq_len, dtype=torch.bool), diagonal=1 ) alibi_bias = alibi_bias.masked_fill(causal_mask, float("-inf")) attn_with_bias = attn_weights + alibi_bias probs = F.softmax(attn_with_bias, dim=-1) entropy_without_bias = attention_entropy( F.softmax(attn_weights.masked_fill(causal_mask, float("-inf")), dim=-1) ) entropy_with_bias = attention_entropy(probs) min_logits = attn_with_bias[attn_with_bias != float("-inf")].min().item() max_logits = attn_with_bias[attn_with_bias != float("-inf")].max().item() print(f"seq_len={seq_len}, num_heads={num_heads}, head_dim={head_dim}") print(f"slopes: {slopes.view(-1).tolist()}") print(f"attention 熵值(无 ALiBi): {entropy_without_bias.item():.4f}") print(f"attention 熵值(有 ALiBi): {entropy_with_bias.item():.4f}") print(f"logits 范围: [{min_logits:.2f}, {max_logits:.2f}]") print(f"softmax 后最小非零概率: {probs[probs > 0].min().item():.2e}") print() if __name__ == "__main__": run_demo(seq_len=512, num_heads=8, head_dim=64) run_demo(seq_len=2048, num_heads=8, head_dim=64) run_demo(seq_len=4096, num_heads=32, head_dim=64)

运行方式：

python alibi_failure_demo.py

这个脚本的输出会非常直观地暴露问题。在seq_len=512、num_heads=8时，第一个 head 的 slope 是0.5，距离 500 的偏置是-250，此时的熵值会出现明显下降。当seq_len=4096、num_heads=32时，第一个 head 的 slope 约为0.84，距离 4000 的偏置接近-3360，大部分远距离位置的 softmax 概率已经下溢为 0，attention 熵值会跌到极其接近 0 的水平。

这个实验告诉我们：ALiBi 的“线性偏置”表面上只影响注意力分布，但一旦序列长度和 slope 组合越界，影响就从“抑制”变成了“彻底关闭”。在实际训练中，这直接导致模型对远距离信息的梯度长期为 0。

5. 失效症状与诊断方法

工程上，ALiBi 数值失效不会像“程序崩溃”那样直接报错，而是以更隐蔽的方式出现。常见症状包括以下五类。

5.1 训练 loss 周期性尖峰

如果 ALiBi 偏置让某些 head 的 logits 范围过大，在混合精度训练中可能触发溢出，产生 Inf 或 NaN。一个典型的特征是 loss 曲线整体正常，但每隔一段时间出现一次尖峰，随后模型参数被污染，需要回滚 checkpoint。很多团队在这种场景下反复调学习率、改 warmup，却忽略了 attention logits 的数值分布已经异常。

5.2 长文本能力不升反降

对长文本任务做评估时，模型在短文本上表现正常，一旦序列长度超过某个阈值，性能明显下降。原因是超过阈值后，远距离位置的注意力权重被完全压成 0，模型实际上退化成了一个“局部注意力模型”，只能看到附近少量 token。

5.3 attention 熵值骤降

把 attention 熵值作为监控指标，观察训练过程中各个 head 的熵值变化。正常情况下，不同 head 的熵值应有区分度，代表不同 head 关注范围不同。如果某一个或某几个 head 的熵值在第几百步后突然塌缩到接近 0，大概率是 ALiBi 偏置已经主导了 attention score。

5.4 中间层梯度稀疏化

在训练过程中统计某些层的梯度稀疏比例。如果大量梯度的绝对值为 0，且分布在 transformer 层靠近 attention 的部分，说明 softmax 已经下溢。这个症状对 ALiBi 尤其典型，因为只有距离较远的位置会受影响，距离近的位置仍然正常，梯度看起来是“部分稀疏”而非“整体消失”。

5.5 推理与训练框架结果不一致

同一个 checkpoint 在训练框架和推理框架中表现不一致。如果推理框架使用的是不同的 attention 实现，对 ALiBi bias 的精度处理不同，在极端偏置下结果差异会被放大。不要把这种不一致简单归因为“浮点误差”，要主动检查 logits 分布范围。

5.6 诊断检查清单

当你怀疑 ALiBi 数值失效时，按下面顺序排查：

1. 统计训练日志中 attention logits 的 min/max，观察是否存在超过 [-100, 100] 的值。 2. 统计各个 head 的 attention 熵值，查看是否存在熵值接近 0 的 head。 3. 检查混合精度训练日志中是否有 Inf/NaN，定位到具体 layer 和 head。 4. 用固定 seed 跑一个短序列和一个长序列的 forward，对比 attention 输出分布。 5. 把 ALiBi 偏置临时关闭，看长文本指标是否恢复。若恢复，说明问题定位在偏置本身。

写一个简单的 logits 统计函数也很容易：

# 文件路径：logits_stats.py def inspect_attention_logits(attn_weights, heads_to_show=4): """ attn_weights 形状: [batch, heads, seq_len, seq_len] 排除 causal mask 后的 -inf 后，统计每个 head 的 logits 范围。 """ for head_idx in range(min(attn_weights.size(1), heads_to_show)): logits = attn_weights[0, head_idx] valid = logits[logits != float("-inf")] print( f"head {head_idx}: " f"min={valid.min().item():.2f}, " f"max={valid.max().item():.2f}, " f"mean={valid.mean().item():.2f}" )

如果在某个 head 上看到min达到-200以下，基本可以确定 ALiBi 偏置已经把该 head 的远距离注意力关闭了。

6. 工程修复与替代方案

6.1 方案一：限制偏置范围

最直接的修复方法，是给 ALiBi 偏置设置一个上限。具体做法是把bias = -m * (i - j)限制在[-max_bias, 0]区间。比如设置max_bias = 64，距离超过64 / m的 token 不再承受更大的负偏置。这种做法保留了 ALiBi 的“近强远弱”特性，同时避免远距离 token 被完全压制到下溢。

# 文件路径：alibi_bias_clipped.py def build_alibi_bias_clipped(slopes, seq_len, max_bias=64.0): num_heads, _, _ = slopes.shape positions = torch.arange(seq_len, dtype=torch.float32) distance = positions.view(1, seq_len, 1) - positions.view(1, 1, seq_len) bias = distance * slopes bias = torch.clamp(bias, min=-max_bias, max=0.0) causal_mask = torch.triu( torch.ones(seq_len, seq_len, dtype=torch.bool), diagonal=1 ) bias = bias.masked_fill(causal_mask, float("-inf")) return bias

这种做法的好处是改动极小，几乎不影响短序列行为，对长序列的数值稳定性提升非常明显。缺点是需要额外调max_bias，设置过大仍然会失效，设置过小会削弱 ALiBi 的外推优势。

6.2 方案二：调整 slope 生成方式

ALiBi 论文中的 slope 是按几何级数生成的，在 head 数多时，第一个 head 的 slope 会接近 1。如果项目里 head 数很多，可以考虑降低 slope 的上限。常见做法是对 slope 整体乘以一个缩放系数，比如0.5或动态设置。

另一种调整思路是让 slope 随序列长度变化。比如设定一个目标“最大距离对应的偏置不超过某阈值”，然后反推当前训练长度下应使用的 slope。这在训练阶段很容易实现，但要注意推理阶段的长度可能与训练长度不同，需要统一约定。

6.3 方案三：attention logits 使用 fp32 累加

如果项目使用混合精度训练，建议在计算 attention score 时，把 Q/K 乘法和 ALiBi 偏置累加放在 float32 下完成，输出回传时再转回 float16。这个操作在标准 PyTorch 中可以通过torch.autocast的局部配置或手动 cast 实现。代价是会略微增加显存和计算量，但通常只在 attention 部分，整体开销可控。

# 伪代码片段：attention logits 用 fp32 累加 attn_weights = torch.matmul(query.float(), key.float().transpose(-2, -1)) attn_weights = attn_weights / scale attn_weights = attn_weights + alibi_bias.float() attn_weights = F.softmax(attn_weights, dim=-1) attn_output = torch.matmul(attn_weights, value.float())

6.4 方案四：切换到 RoPE 或 T5 Relative Bias

如果项目仍处于早期阶段，且对长文本外推有很高要求，可以重新评估是否必须使用 ALiBi。RoPE 的数值范围更温和，外推能力在多个开源模型中已经得到验证。T5 的相对位置偏置是可学习的，模型可以自主调节偏置的量级，不需要手动设置 slope。

切换方案的代价是代码改动更大，需要重新训练模型，不适用于已经训练到一半的 checkpoint。但对新启动的长文本项目来说，这是一个值得做的架构决策。

6.5 方案五：与 FlashAttention 的适配检查

如果你使用的是 FlashAttention 或类似的高效 attention Kernel，务必确认 Kernel 对 ALiBi bias 的实现方式。不同 Kernel 对 bias 的精度处理差别很大：有的在 fp32 下做偏置加法，有的在 fp16 下直接融合。建议在切换 Kernel 时跑一个固定输入的数值对比测试，观察 logits 分布是否一致，而不是盲目信任“结果应该一致”。

如果 Kernel 对偏置的精度处理不理想，优先在框架层完成 bias 的裁剪或 fp32 累加，再把处理后的 bias 传给 Kernel。

7. 常见问题与排查方法

8. 最佳实践与工程建议

8.1 在训练前做一次“注意力数值体检”

很多团队在训练大模型前会检查数据、参数量、显存，却很少检查 position encoding 的数值边界。建议在正式训练前，用一个小模型做一次扫描：固定随机种子，对多个序列长度（512、2048、4096、8192）跑前向，统计每个 head 的 attention logits 范围和熵值。这一步只需要几十分钟，能提前暴露 ALiBi 偏置是否越界。

8.2 把 attention 熵值加入训练监控

在训练过程中记录每个 head 的 attention 熵值，作为常规监控指标。一旦发现某个 head 的熵值在某个 step 后骤降，立即暂停检查 logits 分布。这个指标比 loss 更灵敏，能在 loss 明显变化之前暴露问题。

8.3 对 slope 做超参搜索，而不是直接用默认值

ALiBi 论文的默认 slope 公式适合论文里的实验设置，未必适合你的模型规模、head 数、序列长度。建议在训练前做小规模搜索，重点评估两个参数：slope 的全局缩放系数、bias 的 max_bias 阈值。搜索目标不是在短序列上效果最好，而是在目标最大序列长度下梯度分布仍然健康。

8.4 保存 checkpoint 时记录 logits 统计信息

在保存训练 checkpoint 时，同步保存一份当前 attention logits 的 min/max/mean 统计信息。这样当后续训练出现问题时，可以直接定位到是哪个 step 开始出现数值异常，不需要重新复现训练过程。

8.5 低精度训练时特别注意 attention 部分

混合精度训练下，attention 的 Q/K 乘法结果通常比普通层的数值动态范围更大。对于使用 ALiBi 的模型，建议把 attention 内部的关键计算保持在 fp32，至少在 logits 加 bias 的环节不要使用 fp16。如果为了性能必须用低精度，优先使用 bf16 而不是 fp16，因为 bf16 的动态范围更大，虽然精度略低，但不容易出现溢出。

8.6 给团队建立 ALiBi 的“避坑文档”

如果团队内有多个项目使用 ALiBi，建议沉淀一份内部文档，写下当前模型的 head 数、序列长度、使用的 slope 配置、bias 是否有裁剪，以及不同实现方式（PyTorch 原生、FlashAttention、推理框架）之间的数值差异。这个文档能帮后续接手的人少踩很多坑。

8.7 评估替代方案时不要只看测试集指标

在对比 ALiBi 和 RoPE 时，除了看评测集上的分数，还要对比两者的数值稳定性。RoPE 可能在某些配置下测试集分数略低，但它的数值边界更清晰，长序列下更稳定。对于追求长上下文稳定性的产品项目，RoPE 的“可预期性”比 ALiBi 的“简洁性”更有价值。

9. 总结

ALiBi 确实是一个设计精巧的位置编码方案，它的零参数、天然外推、易于集成等特性，让它成为很多长文本模型的首选。但它的线性偏置是一把双刃剑：偏置与距离成正比，没有天然上限，在长序列、高 head 数、低精度训练的组合条件下，很容易把远距离 token 的 attention logits 推入下溢区间，造成注意力分布塌缩、梯度消失、长文本能力退化。

应对方法并不复杂，核心是三个动作：一是训练前做注意力数值体检，确认 logits 范围不越界；二是给 bias 加上合理裁剪或调整 slope，避免偏置无界增长；三是在训练和推理中监控 attention 熵值，把它当作和 loss 同等重要的健康指标。

如果你的项目正在使用 ALiBi，建议保存这份笔记，下次遇到“loss 莫名 spike”或“长文本效果不升反降”时，先检查 attention 的 logits 分布，再决定要不要调学习率。

更进一步，如果你正在设计新的长文本模型架构，不妨把位置编码的数值稳定性纳入架构选型标准。ALiBi 的简洁和 RoPE 的数值温和性，需要在真实的长序列训练中权衡，而不是只看论文里的外推曲线。