RoPE 的 β 进制类比与长度外推

RoPE 优雅地解决了"用绝对编码实现相对位置"的问题，但它自身面临另一个挑战：当模型需要处理训练时未见过的更长序列时，位置编码会发生什么？这个问题——长度外推——直接决定了模型能否在推理阶段扩展上下文窗口。理解长度外推的关键，在于苏剑林提出的一个深刻类比：RoPE 的旋转角度就是 $\beta$ 进制数的各位数字。

这个类比不仅提供了直觉，更统一了直接外推、位置内插、NTK-aware 缩放和 YaRN 等看似不同的外推策略。本文将从 $\beta$ 进制类比出发，揭示这些方法背后"分辨率与范围"的根本取舍。

RoPE 的外推困境

回顾 RoPE 的旋转角度 $\theta_i = \beta^{-2i/d}$ ，其中 $\beta = 10000$ 。对位置 $m$ 的第 $i$ 个维度对，旋转角度为 $m\theta_i = m / \beta^{2i/d}$ 。

假设训练时的最大序列长度为 $L$ 。在训练过程中，模型从未见过位置 $m > L$ 的输入。推理时如果直接使用 $m > L$ ，会发生什么？

从几何上看，位置 $m > L$ 的旋转角度 $m\theta_i$ 可能超出训练时见过的角度范围。对于高频分量（ $i$ 小， $\theta_i$ 大）， $m\theta_i$ 可能在训练范围内已经经历了多个完整旋转周期，超出范围只是多旋转了几圈，模型对此尚可应对。但对于低频分量（ $i$ 大， $\theta_i$ 小）， $m\theta_i$ 在训练范围内可能只覆盖了圆周的一小段，超出范围意味着进入全新的角度区域，模型没有任何经验，注意力分布将变得不可预测。

这就是 RoPE 的外推困境：低频分量在长序列上的分辨率不足，导致模型在超出训练长度的位置上注意力计算失准。

$\beta$ 进制类比

整数 $n$ 的 $\beta$ 进制表示将 $n$ 分解为各位数字：

n = \sum_{i=0}^{k} d_i \cdot \beta^i, \quad d_i \in \{0, 1, \ldots, \beta-1\}

各位数字 $d_i$ 捕捉了 $n$ 在不同尺度上的信息： $d_0$ 是最低位，变化最快，捕捉细粒度信息； $d_k$ 是最高位，变化最慢，捕捉粗粒度信息。

RoPE 的旋转角度 $m\theta_i = m / \beta^{2i/d}$ 与此有深刻的对应。将 $m$ 写成某种"旋转进制"的表示：

m\theta_i = m \cdot \beta^{-2i/d}

这可以理解为 $m$ 除以 $\beta^{2i/d}$ 的小数部分。当 $i$ 从 $1$ 增大到 $d/2$ 时， $\beta^{2i/d}$ 从 $\beta^{2/d}$ 增大到 $\beta$ ，相当于进制表示中从低位到高位的遍历。低频分量（ $i$ 大）对应高位数字，变化缓慢，分辨率低；高频分量（ $i$ 小）对应低位数字，变化快速，分辨率高。

更精确地说，每个频率分量的"周期"为 $2\pi / \theta_i = 2\pi \beta^{2i/d}$ 。第 $i$ 个分量在位置 $m$ 处的角度 $m / \beta^{2i/d}$ 可以视为"第 $i$ 位数字"的值。当 $m$ 增加 $1$ 时，最低位数字变化 $\beta^{2/d}$ ，最高位数字变化 $1/\beta$ 。这正是一个 $\beta$ 进制计数器的行为。

这个类比的核心发现是：进制系统的表示范围由位数决定，分辨率由底数决定。要扩展表示范围，要么增加位数（增加维度 $d$ ），要么增大底数（增大 $\beta$ ）。

为了使这个类比更加具体，考虑苏剑林给出的具象数字例子。整数 759 的十进制表示是 $[7, 5, 9]$ ，各位数字的计算方式为 $\lfloor 759 / 10^m \rfloor \mod 10$ ：百位 $7 = \lfloor 759 / 100 \rfloor \mod 10$ ，十位 $5 = \lfloor 759 / 10 \rfloor \mod 10$ ，个位 $9 = 759 \mod 10$ 。类似地，1749 转为十六进制是 $[6, \text{D}, 5]$ ，因为 $1749 = 6 \times 16^2 + 13 \times 16 + 5$ 。

RoPE 的旋转角度 $m / \beta^{2i/d}$ 与 $\lfloor m / \beta^k \rfloor \mod \beta$ 有相同的底数 $\beta$ 。而且 $\mod \beta$ 与 $\sin / \cos$ 同为周期函数——前者是离散周期，后者是连续周期，但两者其实都在捕捉"角度的小数部分"。这就是 $\beta$ 进制类比精确的数学对照：RoPE 的每个频率分量在做的事情，与进制系统中某一位数字在做的事情，在数学上是同构的。

进制转换的代价是精度。3 位十进制能表示 $0 \sim 999$ ，转为十六进制后 3 位能表示 $0 \sim 4095$ ——表示范围扩大了 4 倍，但每个数位的分辨精度从 $1$ 变为 $16$ ，相当于每个十进制数对应十六进制中的 $16$ 个可能值被模糊为一个。这正是长度外推中分辨率与范围取舍的直接类比：通过调整底数 $\beta$ 来扩大表示范围，代价是每个频率分量的角度分辨率降低。

三种外推策略

$\beta$ 进制类比将长度外推问题重新表述为：如何让进制系统在超出原有表示范围时仍然正常工作？有三种基本策略。

直接外推

直接使用超出训练范围的 $m > L$ 。在 $\beta$ 进制类比中，这相当于计数器溢出：高位数字进入从未见过的区域。

对于低频分量， $m\theta_i$ 进入全新的角度范围，模型注意力急剧恶化。实验表明，直接外推在超出训练长度 $20\%$ 以上时性能就显著下降。

位置内插（Position Interpolation）

Chen 等人提出的 Position Interpolation 不改变编码方式，而是将位置缩放到训练范围内：

m' = \frac{m \cdot L}{L'}

其中 $L'$ 是目标长度。在 $\beta$ 进制类比中，这相当于在原有进制下将数字按比例压缩：原来范围 $[0, L]$ 对应 $[0, L']$ 。

位置内插保证了所有角度仍在训练范围内，但代价是分辨率降低。原来相邻位置 $m$ 和 $m+1$ 对应的旋转角度差为 $\theta_i$ ，内插后变为 $\theta_i \cdot L / L'$ 。当 $L' = 4L$ 时，分辨率降低为原来的 $1/4$ ，高频分量可能无法区分相邻位置。

NTK-Aware 缩放

NTK-Aware 方法的核心思想是调整底数 $\beta$ 而非缩放位置。将 $\beta$ 替换为 $\beta' = \beta \cdot \alpha^{d/(d-2)}$ ，其中 $\alpha$ 是缩放因子。

在 $\beta$ 进制类比中，增大底数相当于改变进制：从 $\beta$ 进制变为 $\beta'$ 进制。底数增大后，每个数字的取值范围变大，但每个数字的变化步长也变大。关键在于，不同位受到的影响不同：

高位（低频分量）： $\theta_i = \beta'^{-2i/d}$ ，底数增大使得角度变小，相当于高位数字的变化更缓慢，从而能够"数到"更大的位置而不溢出
低位（高频分量）：由于 $\beta'$ 相对 $\beta$ 的增幅被 $d/(d-2)$ 次方调整，高频分量的角度变化接近训练时的范围，保持了局部分辨率

这种"不均匀缩放"正是 NTK-Aware 方法的精妙之处：它在低频分量上做了内插（扩展范围），在高频分量上接近外推（保持分辨率），从而在范围和分辨率之间取得了比纯粹内插更好的平衡。

三种外推策略的频率分量对比

Loading visualization...

左：各频率分量的波长变化（条形图）；右：不同方法下旋转角度随位置的变化

// ========================================
// RoPE β 进制类比 + 三种外推策略可视化
// ========================================

const W = container.clientWidth;
const H = container.clientHeight;

const cs = getComputedStyle(document.documentElement);
const colors = {
  accent: cs.getPropertyValue('--viz-accent').trim() || '#3b82f6',
  text: cs.getPropertyValue('--viz-text').trim() || '#1f2937',
  muted: cs.getPropertyValue('--viz-text-muted').trim() || '#6b7280',
  grid: cs.getPropertyValue('--viz-grid').trim() || '#e5e7eb',
};

const methodColors = {direct: '#ef4444', interp: '#3b82f6', ntk: '#10b981'};
const d = 64; // 维度
const beta = 10000;
const trainLen = 2048;
const numFreqs = 8; // 展示前 8 个频率分量

// --- 控制面板 ---
const controls = d3.select(container).append('div').attr('class', 'd3-viz-controls');
controls.append('label').text('扩展比例 (L\'/L):');
const scaleSlider = controls.append('input')
  .attr('type', 'range').attr('min', 1).attr('max', 8).attr('value', 4).attr('step', 0.5);
const scaleValue = controls.append('span').attr('class', 'd3-viz-value').text('4x');

controls.append('div').attr('class', 'd3-viz-hint')
  .text('调整扩展比例，观察三种方法下频率分量和注意力分数的变化');

// --- 左侧：频率分量波长条形图 ---
const leftW = Math.floor(W * 0.45);
const rightW = W - leftW - 20;

const svgLeft = d3.select(container).append('svg')
  .attr('width', leftW).attr('height', H - 55);

// 标题
svgLeft.append('text').attr('x', leftW/2).attr('y', 18)
  .attr('text-anchor','middle').attr('font-size','0.8em').attr('font-weight','600').attr('fill', colors.text)
  .text('频率分量波长');

// Y 轴：频率索引
const yBar = d3.scaleBand().domain(d3.range(numFreqs).map(i => `θ${i+1}`)).range([0, lH]).padding(0.25);

gLeft.append('g')
  .call(d3.axisLeft(yBar))
  .selectAll('text').attr('fill', colors.muted).attr('font-size','0.7em');
gLeft.selectAll('.domain,.tick line').attr('stroke', colors.grid);

// --- 右侧：注意力热力图 ---
const svgRight = d3.select(container).append('svg')
  .attr('width', rightW).attr('height', H - 55)
  .style('position','absolute').style('right','10px').style('top','55px');

// 三行热力图，分别对应三种方法
const heatmapSize = Math.min((rightW - 30) / 3, 80);
const seqLen = 64; // 热力图显示的序列长度
const cellW = (rightW - 60) / seqLen;
const cellH = (H - 120) / seqLen;

const methodLabels = [
  {key: 'direct', label: '直接外推', color: methodColors.direct},
  {key: 'interp', label: '位置内插', color: methodColors.interp},
  {key: 'ntk', label: 'NTK-Aware', color: methodColors.ntk}
];

const heatmaps = {};

methodLabels.forEach((method, idx) => {
  const g = svgRight.append('g')
    .attr('transform', `translate(50, ${idx * ((H - 70) / 3) + 15})`);

g.append('text').attr('x', -45).attr('y', (H - 120) / 6)
    .attr('text-anchor','middle').attr('font-size','0.7em').attr('font-weight','600')
    .attr('fill', method.color)
    .attr('transform', `rotate(-90, -45, ${(H-120)/6})`)
    .text(method.label);

heatmaps[method.key] = g;
});

// --- 计算函数 ---
function computeThetas(scaleFactor) {
  const targetLen = trainLen * scaleFactor;
  const ntkAlpha = scaleFactor;
  const ntkBeta = beta * Math.pow(ntkAlpha, d / (d - 2));

return {
    original: d3.range(numFreqs).map(i => Math.pow(beta, -2 * (i + 1) / d)),
    interp: d3.range(numFreqs).map(i => Math.pow(beta, -2 * (i + 1) / d) / scaleFactor),
    ntk: d3.range(numFreqs).map(i => Math.pow(ntkBeta, -2 * (i + 1) / d))
  };
}

function computeAttention(m, n, thetas, numDims) {
  // 简化：假设 q 和 k 为单位向量，内积 = Σ cos((m-n)*θ_i)
  let sum = 0;
  for (let i = 0; i < numDims; i++) {
    sum += Math.cos((m - n) * thetas[i]);
  }
  return sum / numDims;
}

// --- 更新函数 ---
function update(scaleFactor) {
  const thetas = computeThetas(scaleFactor);
  const targetLen = trainLen * scaleFactor;

// 更新左侧条形图
  gLeft.selectAll('.bar-group').remove();

const methods = [
    {key: 'original', label: '原始', color: colors.muted},
    {key: 'interp', label: '内插', color: methodColors.interp},
    {key: 'ntk', label: 'NTK', color: methodColors.ntk}
  ];

const xBar = d3.scaleLog().domain([1, 1e8]).range([0, lW]);

gLeft.selectAll('.domain,.tick line').attr('stroke', colors.grid);

// X 轴
  gLeft.select('.x-axis').remove();
  gLeft.append('g').attr('class', 'x-axis')
    .attr('transform', `translate(0,${lH})`)
    .call(d3.axisBottom(xBar).ticks(4, '.0e'))
    .selectAll('text').attr('fill', colors.muted).attr('font-size','0.6em');

for (let i = 0; i < numFreqs; i++) {
    const group = gLeft.append('g').attr('class', 'bar-group')
      .attr('transform', `translate(0,${yBar(`θ${i+1}`)})`);

const barH2 = yBar.bandwidth() / 3;
    methods.forEach((method, mi) => {
      const wavelength = 2 * Math.PI / thetas[method.key][i];
      group.append('rect')
        .attr('x', 0).attr('y', mi * barH2)
        .attr('width', Math.max(2, xBar(wavelength)))
        .attr('height', barH2 - 1)
        .attr('rx', 1)
        .attr('fill', method.color)
        .attr('opacity', mi === 0 ? 0.4 : 0.8);
    });
  }

// 图例
  gLeft.selectAll('.legend').remove();
  const legend = gLeft.append('g').attr('class', 'legend').attr('transform', `translate(${lW - 120}, -20)`);
  methods.forEach((m, i) => {
    const lg = legend.append('g').attr('transform', `translate(${i * 55}, 0)`);
    lg.append('rect').attr('width', 10).attr('height', 8).attr('rx', 1)
      .attr('fill', m.color).attr('opacity', i === 0 ? 0.4 : 0.8);
    lg.append('text').attr('x', 13).attr('y', 7).attr('font-size','0.6em').attr('fill', colors.muted).text(m.label);
  });

// 更新右侧热力图
  const allThetas = {
    direct: thetas.original, // 直接外推用原始频率
    interp: thetas.interp,
    ntk: thetas.ntk
  };

const numDimsForAttn = 16; // 用前 16 维计算注意力

methodLabels.forEach(method => {
    const g = heatmaps[method.key];
    g.selectAll('rect').remove();

// 计算注意力分数矩阵
    const scores = [];
    const maxScore = numDimsForAttn;
    for (let m = 0; m < seqLen; m++) {
      for (let n = 0; n < seqLen; n++) {
        // 模拟超出训练长度：偏移位置
        const posM = m + Math.floor(targetLen - seqLen);
        const posN = n + Math.floor(targetLen - seqLen);
        const attn = computeAttention(posM, posN, allThetas[method.key], numDimsForAttn);
        scores.push({m, n, attn: attn / maxScore + 0.5});
      }
    }

// 颜色映射
    const colorScale = d3.scaleSequential(d3.interpolateRdYlBu)
      .domain([0, 1]);

g.selectAll('rect')
      .data(scores)
      .enter()
      .append('rect')
      .attr('x', d => d.n * cellW)
      .attr('y', d => d.m * cellH)
      .attr('width', Math.max(cellW - 0.5, 0.5))
      .attr('height', Math.max(cellH - 0.5, 0.5))
      .attr('fill', d => colorScale(Math.max(0, Math.min(1, d.attn))));
  });

scaleValue.text(scaleFactor + 'x');
}

update(4);
scaleSlider.on('input', function() { update(+this.value); });

从可视化中可以直观对比三种策略的差异。直接外推时，低频分量的波长不足以覆盖扩展后的范围，注意力矩阵出现大面积的均匀分布（信息丢失）；位置内插虽然保持了注意力的局域性，但局部结构被模糊化；NTK-Aware 在两者之间取得了更好的平衡。

NTK-Aware 的数学细节

NTK-Aware 方法的底数调整公式为：

\beta' = \beta \cdot \alpha^{d/(d-2)}

其中 $\alpha = L'/L$ 是长度缩放因子。这个指数 $d/(d-2)$ 的选择并非任意——它是基于 NTK（Neural Tangent Kernel）理论的分析。

考虑一个宽度无限的网络，其 NTK 在输入变化时的稳定性取决于位置编码的频率分布。RoPE 的频率 $\theta_i = \beta^{-2i/d}$ 形成几何级数，NTK 分析表明，要保持 NTK 的稳定性，频率的缩放应该是非均匀的。

具体地，对于第 $i$ 个频率分量，NTK-Aware 的有效缩放因子为：

s_i = \left(\frac{\beta'}{\beta}\right)^{2i/d} = \alpha^{2i/(d-2)}

当 $i$ 小（高频）时， $s_i \approx \alpha^{0} \approx 1$ ，高频分量几乎不变，保持了局部分辨率；当 $i$ 大（低频）时， $s_i \approx \alpha$ ，低频分量被按比例缩放，扩展了表示范围。

这正是 NTK-Aware 的核心：不均匀缩放使得每个频率分量都得到合适的调整，高频保持分辨率，低频扩展范围。

值得区分的是，NTK-Aware 缩放在实践中演化出了多个版本：

NTK-RoPE-old：仅替换底数 $\beta \to \beta'$ ，这是原始版本，直观但低频分量的缩放不够充分
NTK-RoPE-fixed：在频率上额外除以 $k^m$ （ $k$ 为缩放因子， $m$ 为维度索引），修正版，低频分量获得更大缩放，更合理
NTK-RoPE-mixed（混合进制）：不同频率分量使用不同缩放因子，低位承担更多外推压力——这是苏剑林 $\beta$ 进制系列的核心创新。在 $\beta$ 进制类比中，mixed 版本相当于不同位使用不同的底数，低位用更大的底数以承担更多外推压力

实验表明，mixed 版本优于 fixed 版本，fixed 版本优于 old 版本。这个进化过程的逻辑是：从"统一调整底数"到"逐位调整"，越来越精确地匹配每个频率分量在长度外推中的需求。

苏剑林区分三个版本的根本论据是相对位置分布不均衡。在训练长度 $L$ 内，相对位置 0 出现最频繁（ $L$ 次），1 次之（ $L-1$ 次），高位出现的次数很少。这意味着低位（高频分量）训练充分、外推压力小；高位（低频分量）训练不充分、外推压力大。因此外推压力不应该平摊到所有频率分量——这正是 NTK-RoPE-mixed 的设计动机：低位承担更多外推压力，高位承担更少。old 版本的统一底数调整无视了这种不均衡，fixed 版本通过额外除以 $k^m$ 部分地补偿了高位的外推压力，而 mixed 版本则为每个频率分量单独设定缩放因子，精确匹配其在训练中获得的"免疫力"与外推时面临的压力之比。

YaRN：注意力温度的引入

NTK-Aware 解决了频率分布的问题，但仍有不足：随着上下文扩展，注意力分布变得更加均匀（entropy 增大），导致模型对远处 token 的关注度增加，近处 token 的注意力被稀释。

YaRN（Yet another RoPE extensioN）在 NTK-Aware 的基础上引入了注意力温度调节：

\text{Attention}(m, n) = \frac{(\mathbf{R}_m \mathbf{q}_m)^T (\mathbf{R}_n \mathbf{k}_n)}{\sqrt{d} \cdot t(\alpha)}

其中 $t(\alpha)$ 是随缩放因子 $\alpha$ 增大而增大的温度参数。增大温度使得 softmax 的输入变小，输出更均匀；减小温度使 softmax 更尖锐。

YaRN 的设计逻辑是：在扩展上下文时，注意力分数的绝对值会因为频率分量的变化而改变，通过调节温度可以补偿这种变化，使得注意力的有效感受野保持稳定。

ReRoPE：截断实现无限外推

前面讨论的所有方法——位置内插、NTK-Aware、YaRN——都在"调整编码"上做文章：要么缩放位置，要么调整底数，要么调节温度。苏剑林在《无限外推的ReRoPE？》中提出了一个根本不同的思路：不调整编码，而是截断相对位置。

ReRoPE（Rescaled RoPE）的核心机制是在注意力计算中，将相对位置截断为：

|m - n|' = \min(|m - n|, w)

其中 $w$ 是训练时的最大位置距离。效果是双重的：

训练范围内（ $|m - n| \leq w$ ）：注意力计算与原始 RoPE 完全一致，模型行为不受影响
超出训练范围（ $|m - n| > w$ ）：注意力等价于在位置 $w$ 处的注意力，即最大距离处的注意力模式被"复制"到更远的距离上

从几何上看，ReRoPE 将相对位置超出 $w$ 的所有 token 都映射到同一个旋转角度，使得这些远处 token 的注意力分数保持在一个模型"见过"的范围内。这避免了直接外推中低频分量进入全新角度区域的问题。

Leaky ReRoPE：截断策略的连续推广

ReRoPE 的截断公式 $|m - n|' = \min(|m - n|, w)$ 是一种"硬截断"——窗口外的位置信息被完全丢弃。一个自然的推广是引入连续参数 $\lambda \in (0, 1]$ ，允许窗口外的位置信息以线性衰减的方式保留：

|m - n|' = \begin{cases} |m - n| & \text{if } |m - n| \leq w \\ \lambda \cdot |m - n| & \text{if } |m - n| > w \end{cases}

参数 $\lambda$ 在三个极端之间插值：

$\lambda = 0$ ：标准 ReRoPE，窗口外完全截断
$\lambda = 1$ ：标准 RoPE，不做任何调整
$\lambda \in (0, 1)$ ：窗口外部分保留位置的线性衰减

苏剑林用一个精妙的类比来解释三者的关系：ReRoPE 对应 ReLU（窗口外完全截断），Leaky ReRoPE 对应 Leaky ReLU（窗口外线性衰减），标准 RoPE 对应 Linear（不做任何调整）。这个类比不仅形式上相似，更揭示了截断策略的本质——在"完全丢弃窗外信息"与"完全保留窗外信息"之间存在连续的光谱，而 $\lambda$ 正是控制这个光谱位置的旋钮。

ReRoPE 的实际限制

尽管 ReRoPE 在理论上提供了最优雅的外推方案，其实际部署面临显著的工程代价：

计算量翻倍：ReRoPE 需要两次 Attention 计算——一次用原始位置编码计算注意力分数，一次用截断后的位置编码重新计算。这意味着计算量约为标准 Attention 的 2 倍。
与 Flash Attention 不兼容：Flash Attention 假设位置编码已在 Q/K 中预计算完成，通过批量矩阵乘法实现高效的 Attention 计算。而 ReRoPE 需要在 Attention 分数计算完成后再修改位置信息，这与 Flash Attention 的计算流程根本冲突。
KV Cache 需要特殊处理：标准 KV Cache 存储的是已编码的 $k_t$ ，但 ReRoPE 需要同时存储未编码的 $k_t$ 和位置信息，以便在推理时动态应用截断。这增加了内存开销和实现复杂度。

苏剑林在原文中对这些工程限制有详细讨论，并指出这些是 ReRoPE 尚未被主流框架广泛采用的主要原因。结论是：ReRoPE 在理论上提供了最优雅的外推方案，但工程代价使其更适合作为理解外推问题的理论工具，而非即插即用的工程方案。

苏剑林的实验表明，在不微调的情况下，ReRoPE 的效果超过 NTK-Aware，甚至超过从零训练的 HFWA（Hybrid Frequency Window Attention）。这个结果令人意外：一个不修改任何参数、只截断位置的简单操作，竟能超越需要调参的方法。

ReRoPE 代表了外推方法论的下一个重大台阶——从"调整编码"到"截断+重缩放"。其哲学是：与其试图让编码适配更长的范围，不如承认训练范围外的位置信息不可靠，将其截断到模型有信心的范围内。这种思路更符合外推问题的本质——模型没有见过的位置，不应该试图"猜测"其编码，而应该保守地使用已知范围内最远处的信息。

统一理解：分辨率与范围的取舍

$\beta$ 进制类比将所有外推方法统一到一个框架下：

方法	策略	分辨率	范围	本质
直接外推	不调整	保持	溢出	高位溢出，进制不变
位置内插	线性缩放位置	降低 $1/\alpha$	扩展 $\alpha$ 倍	压缩数字，降低精度
NTK-Aware	非均匀缩放频率	高频保持，低频降低	扩展 $\alpha$ 倍	增大底数，调整进制
YaRN	NTK + 温度调节	同 NTK	同 NTK	调制 + 校准
ReRoPE	截断相对位置	保持（范围内）	无限（截断后）	截断溢出，保守外推

这四种方法代表了同一个权衡的不同取点：分辨率与表示范围的取舍。在固定的维度 $d$ 下，你不可能同时拥有无限的分辨率和无限的范围——这是信息论的基本约束。每种方法的本质区别在于如何在不同频率分量之间分配这个取舍。

外推方法对注意力分布的影响

Loading visualization...

热力图展示不同方法下注意力分数矩阵的对角局域性；切换方法观察结构变化

// ========================================
// RoPE 外推方法对注意力的影响可视化
// ========================================

const W = container.clientWidth;
const H = container.clientHeight;

const beta = 10000;
const d = 64;
const seqLen = 48;
const numDims = 16;

// --- 控制面板 ---
const controls = d3.select(container).append('div').attr('class', 'd3-viz-controls');

controls.append('label').text('方法:');
const methodSelect = controls.append('select')
  .attr('class', 'd3-viz-value')
  .style('font-size', '0.82em')
  .style('padding', '2px 6px')
  .style('border-radius', '4px');
methodSelect.selectAll('option')
  .data([
    {value: 'original', label: '原始 RoPE (训练范围内)'},
    {value: 'direct', label: '直接外推'},
    {value: 'interp', label: '位置内插'},
    {value: 'ntk', label: 'NTK-Aware'}
  ])
  .enter().append('option').attr('value', d => d.value).text(d => d.label);

controls.append('label').text('扩展比例:');
const scaleSlider = controls.append('input')
  .attr('type', 'range').attr('min', 1).attr('max', 8).attr('value', 4).attr('step', 0.5);
const scaleValue = controls.append('span').attr('class', 'd3-viz-value').text('4x');

controls.append('div').attr('class', 'd3-viz-hint')
  .text('切换方法与扩展比例，观察注意力矩阵的对角局域性变化');

// --- 主热力图 ---
const svg = d3.select(container).append('svg')
  .attr('width', W).attr('height', H - 55);

const margin = {top: 15, right: 80, bottom: 30, left: 40};
const plotSize = Math.min(W - margin.left - margin.right, H - 55 - margin.top - margin.bottom);
const cellSize = plotSize / seqLen;

const g = svg.append('g').attr('transform', `translate(${margin.left},${margin.top})`);

// --- 右侧：对角线截面 ---
const profileW = W - margin.left - plotSize - 30;
const profileG = svg.append('g')
  .attr('transform', `translate(${margin.left + plotSize + 15}, ${margin.top})`);

const pxScale = d3.scaleLinear().domain([0, seqLen]).range([0, profileW - 10]);
const pyScale = d3.scaleLinear().domain([0, 1]).range([plotSize, 0]);

profileG.append('g')
  .call(d3.axisLeft(pyScale).ticks(4, '.2f'))
  .selectAll('text').attr('fill', colors.muted).attr('font-size','0.6em');
profileG.selectAll('.domain,.tick line').attr('stroke', colors.grid);

profileG.append('text').attr('transform','rotate(-90)').attr('y',-30).attr('x',-plotSize/2)
  .attr('text-anchor','middle').attr('font-size','0.65em').attr('fill', colors.muted)
  .text('注意力分数');

profileG.append('text').attr('x', profileW/2 - 5).attr('y', plotSize + 20)
  .attr('text-anchor','middle').attr('font-size','0.65em').attr('fill', colors.muted)
  .text('|m−n|');

// 原始方法线
const originalLine = profileG.append('path').attr('fill','none')
  .attr('stroke', colors.muted).attr('stroke-width', 1.5).attr('stroke-dasharray','4,3').attr('opacity', 0.6);
// 当前方法线
const currentLine = profileG.append('path').attr('fill','none')
  .attr('stroke', colors.accent).attr('stroke-width', 2);

// --- 计算注意力 ---
function getThetas(method, scaleFactor) {
  const ntkAlpha = scaleFactor;
  const ntkBeta = beta * Math.pow(ntkAlpha, d / (d - 2));

return d3.range(numDims).map(i => {
    const origTheta = Math.pow(beta, -2 * (i + 1) / d);
    if (method === 'original' || method === 'direct') return origTheta;
    if (method === 'interp') return origTheta / scaleFactor;
    if (method === 'ntk') return Math.pow(ntkBeta, -2 * (i + 1) / d);
    return origTheta;
  });
}

function attnScore(m, n, thetas) {
  let sum = 0;
  for (let i = 0; i < thetas.length; i++) {
    sum += Math.cos((m - n) * thetas[i]);
  }
  // softmax-like 归一化
  return sum / thetas.length;
}

// --- 更新函数 ---
function update() {
  const method = methodSelect.node().value;
  const scaleFactor = +scaleSlider.node().value;
  const targetLen = 2048 * scaleFactor;

g.selectAll('rect').remove();

const thetas = getThetas(method, scaleFactor);
  const originalThetas = getThetas('original', 1);

// 计算分数矩阵
  const scores = [];
  const offsets = [];
  for (let m = 0; m < seqLen; m++) {
    offsets.push(m);
    for (let n = 0; n < seqLen; n++) {
      // 模拟超出训练长度：使用偏移位置
      let posM = m, posN = n;
      if (method !== 'original') {
        posM = m * Math.floor(targetLen / seqLen);
        posN = n * Math.floor(targetLen / seqLen);
      }
      scores.push({
        m, n,
        score: attnScore(posM, posN, thetas)
      });
    }
  }

// 归一化到 [0, 1]
  const minS = d3.min(scores, d => d.score);
  const maxS = d3.max(scores, d => d.score);
  const range = maxS - minS || 1;

const colorScale = d3.scaleSequential()
    .interpolator(d3.interpolateViridis)
    .domain([0, 1]);

g.selectAll('rect')
    .data(scores)
    .enter()
    .append('rect')
    .attr('x', d => d.n * cellSize)
    .attr('y', d => d.m * cellSize)
    .attr('width', Math.max(cellSize - 0.5, 0.5))
    .attr('height', Math.max(cellSize - 0.5, 0.5))
    .attr('fill', d => colorScale((d.score - minS) / range));

// 右侧：对角线截面
  const originalProfile = [];
  const currentProfile = [];

for (let delta = 0; delta < seqLen; delta++) {
    let posDelta = delta;
    if (method !== 'original') {
      posDelta = delta * Math.floor(targetLen / seqLen);
    }
    currentProfile.push({
      x: delta,
      y: (attnScore(posDelta, 0, thetas) - minS) / range
    });
    originalProfile.push({
      x: delta,
      y: (attnScore(delta, 0, originalThetas) - d3.min(scores, d => d.score)) / range
    });
  }

const lineGen = d3.line().x(d => pxScale(d.x)).y(d => pyScale(d.y));
  originalLine.attr('d', lineGen(originalProfile));
  currentLine.attr('d', lineGen(currentProfile));

// 图例
  profileG.selectAll('.profile-legend').remove();
  const leg = profileG.append('g').attr('class', 'profile-legend').attr('transform', `translate(0, ${plotSize + 30})`);
  leg.append('line').attr('x1',0).attr('x2',15).attr('y1',0).attr('y2',0)
    .attr('stroke', colors.muted).attr('stroke-width',1.5).attr('stroke-dasharray','4,3').attr('opacity',0.6);
  leg.append('text').attr('x',18).attr('y',3).attr('font-size','0.6em').attr('fill', colors.muted).text('原始');
  leg.append('line').attr('x1',55).attr('x2',70).attr('y1',0).attr('y2',0)
    .attr('stroke', colors.accent).attr('stroke-width',2);
  leg.append('text').attr('x',73).attr('y',3).attr('font-size','0.6em').attr('fill', colors.muted).text('当前');

scaleValue.text(scaleFactor + 'x');
}

update();

methodSelect.on('change', update);
scaleSlider.on('input', update);

应用：从 LLaMA 到 Qwen3.5

长度外推技术在实际大模型中的应用已经非常广泛。

LLaMA 2 的上下文长度为 4096，LLaMA 3 扩展到了 8192，而通过 NTK-Aware 类方法进一步扩展到 100K+ 已成为社区的标准操作。Meta 官方在 LLaMA 3.1 中通过训练阶段的长度扩展将上下文推到了 128K。

Qwen 系列更是一个典型案例。Qwen3.5 通过结合 NTK-Aware 缩放和渐进式训练，实现了 1M token 的上下文窗口（架构分析详见 Qwen3 vs Qwen3.5 架构对比）。其核心策略是：在预训练阶段逐步增大 RoPE 的底数 $\beta$ ，使得模型在扩展上下文时无需完全从头训练。

这些方法的实际部署往往不只是简单的公式套用，还需要配合渐进式训练、数据混合等工程手段。纯粹的 NTK-Aware 缩放在推理时即插即用，但性能不如经过微调的版本；而 YaRN 需要在扩展上下文上进行少量训练才能发挥最佳效果。

小结

$\beta$ 进制类比将 RoPE 的长度外推问题从"频率该怎么调"重新表述为"进制该怎么变"，提供了一个统一且直观的框架：

直接外推是不改变进制，让计数器溢出
位置内插是压缩数字，牺牲精度换范围
NTK-Aware是增大底数，不均匀地调整各频率分量
YaRN在 NTK-Aware 基础上增加温度校准
ReRoPE截断相对位置，保守地使用已知范围内的信息

这些方法的核心取舍是分辨率与范围的 trade-off：在有限维度下，你无法同时拥有任意高的分辨率和任意大的表示范围。而 ReRoPE 提供了一个跳出这个 trade-off 的视角——不追求更大的表示范围，而是承认范围外的信息不可靠并将其截断。理解了这个根本约束和跳出约束的思路，就能理解每种方法为什么这样设计，以及在实际部署中如何根据需求选择。

参考文献

Su, J. (2023). Transformer升级之路：RoPE是一种β进制编码. https://kexue.fm/archives/9675
Su, J. (2023). Transformer升级之路：将β进制位置进行到底. https://kexue.fm/archives/9706
Su, J. (2023). Transformer升级之路：无限外推的ReRoPE？ https://kexue.fm/archives/9708
Chen, S., et al. (2023). Extending Context Window of Large Language Models via Positional Interpolation. arXiv:2306.15595.

RoPE 的外推困境#

β\beta 进制类比#

三种外推策略#

直接外推#

位置内插（Position Interpolation）#

NTK-Aware 缩放#

NTK-Aware 的数学细节#

YaRN：注意力温度的引入#

ReRoPE：截断实现无限外推#

Leaky ReRoPE：截断策略的连续推广#

ReRoPE 的实际限制#

统一理解：分辨率与范围的取舍#

应用：从 LLaMA 到 Qwen3.5#

小结#

相关概念#

参考文献#

相关文章