想象你受邀承办一场「超长宴会」，到场的宾客数量用 n 表示。老式宴会有条铁律：每位宾客必须与全场所有其他人逐一握手寒暄。于是 n 位宾客要完成大约 n² 次握手——宾客从一千涨到一万，握手总量直接放大一百倍。更要命的是，管家还要把每场对话一字不差写进备忘录，n² 页的笔记把整个储物间都堆满了。这就是标准 Transformer 面对长序列时的窘境：自注意力的「全场社交」让计算量和显存双双平方级暴涨。 Reformer 这位聪明的策划师给出了两把钥匙。第一把是「兴趣分桌」：宾客入场时做一道快速性格测试（局部敏感哈希），兴趣相近的人被分到一桌，你只需和同桌深聊，社交量从「见全场」骤降为「见一桌」；第二把是「倒放录像」：管家不再记流水账，只留最后一帧画面和一段倒放公式，就能把之前的对话原样复原，笔记厚度锐减。两把钥匙一拧，原本只能承办一千人的场地（一块 GPU），如今能接待数万人的超级宴会。 这篇文章，我们就跟着策划师，把这两把钥匙的原理、组装与边界逐一拆开。

岗位关联

读透 Reformer，你就掌握了在有限 GPU 显存下处理数万 token 长序列的两大核心技法——哈希稀疏注意力与可逆重算，这是长上下文大模型架构优化的必修课。

目录
  1. 可视化演示
  2. 二次复杂度瓶颈：全场社交的灾难
  3. 局部敏感哈希：按兴趣分桌
  4. 可逆残差层：倒放录像省显存
  5. 组件协同：分批上菜与二维座位
  6. 训练深化：让分桌更稳的细节
  7. 性能与局限：能跑多远
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

对比标准自注意力On2全连接矩阵与Longformer滑动窗口+全局注意力Onw稀疏矩阵，展示长文档高效建模的注意力模式差异。

本节配有交互动效（进入视口后自动加载，约 3KB）。

Longformer注意力机制 滑动窗口：局部上下文感知 全局token: 关键位置全连接 O(n*w) vs O(n^2) 线性复杂度突破长序列瓶颈

二次复杂度瓶颈：全场社交的灾难

想象你承办一场超长宴会，到场的宾客数量叫 n。传统社交礼仪要求每位宾客必须和全场所有其他宾客逐一握手寒暄——于是总寒暄次数是 n×(n−1)/2，也就是 n² 的量级。宾客从一千涨到一万，寒暄总量直接乘以一百。这还只算了计算量；更可怕的是，管家要为每场对话做记录，n² 条记录纸堆满了整个宴会厅。

Transformer 的自注意力机制，就是这场「全场社交」。序列里每个词（token）是宾客，注意力分数是握手，注意力矩阵就是那张 n×n 的记录表。标准实现里，我们要计算 QKᵀ 得到 n 行 n 列的「亲密度表格」，再据此把 V 里的信息加权混合——也就是让每个词看遍序列里所有其他词。

这张 n×n 的表格带来双重灾难。计算上，矩阵乘法需要 O(n²·d) 次运算，d 是向量维度；存储上，注意力分数矩阵和每层中间激活都要占用 n² 量级的显存。序列长度 1024 时还能忍受，但当长度来到 64000（约一本短篇小说的字数），n² 就是 40 亿——一张注意力表就要好几个 GB，远超单卡显存。这就是为什么早期 Transformer 处理长文档总是「内存先爆，算力未满」。

所以，标准 Transformer 那位固执的主人坚持「全场社交」，n² 次握手和 n² 页笔记让宴会规模被死死卡在几百上千人。Reformer 的破局思路非常直接：不再跟全场寒暄，而是按兴趣分桌。

Attention(Q,K,V)=softmax(QK⊤dk)V,O(n2dk)\mathrm{Attention}(\mathbf{Q},\mathbf{K},\mathbf{V})=\mathrm{softmax}\left(\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}\right)\mathbf{V},\quad O(n^{2}d_k)
公式里的 n 就是序列长度：序列翻一倍，注意力矩阵的格子数就翻四倍——这就是平方级爆炸的来源。
  1. Q、K、V 三张入场券每个词都准备三份信息——Q 是「我想找谁」的提问、K 是「我是谁」的名片、V 是「我真正要传递的话」，三者的行数都是序列长度 n。
    Q,K,V∈Rn×dk\mathbf{Q},\mathbf{K},\mathbf{V}\in\mathbb{R}^{n\times d_k}
  2. QKᵀ 亲密打分把每个提问和全场所有名片做点积相似度，得到一张 n 行 n 列的亲密度表格——这就是「全场社交」的账单。
    QK⊤∈Rn×n\mathbf{Q}\mathbf{K}^{\top}\in\mathbb{R}^{n\times n}
  3. 除以 √d_k 缩放维度越高点积数值越大，缩放一步让打分保持稳定，避免 softmax 过早两极分化。
    QK⊤dk\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}
  4. softmax 归一化把每行分数变成加起来等于 1 的注意力权重，谁和你更像，谁分到的关注就更多。
    softmax(QK⊤dk)\mathrm{softmax}\left(\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}\right)
  5. 按权重混合 V用这张权重表去加权求和 V 中的信息，输出每个词融合全场信息的表示。
    softmax(QK⊤dk)V\mathrm{softmax}\left(\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}\right)\mathbf{V}

局部敏感哈希：按兴趣分桌

聪明的策划师宣布改革：每位宾客入场时先做一套「兴趣测试」，口味相近的人被安排到同一张餐桌。你不需要认识全场几万人，只需要跟同桌的十几位深聊——真正和你聊得来的人，大概率就在这一桌。这套「兴趣测试」在算法里叫局部敏感哈希（Locality-Sensitive Hashing，LSH）。

LSH 的关键是设计一个「测试」：让相似的向量以极大概率拿到同一个测试结果（桶编号），不相似的向量几乎不会同桶。Reformer 把它用在注意力上：每个词先算出一个哈希桶号，注意力只计算「同桶」的词对，跨桶的词直接跳过。这样注意力矩阵从「人人对人人」的 n×n，变成若干「桶内小组」的小矩阵。

具体做法是论文中的随机投影哈希：把每个词的向量 x 乘一个固定的随机矩阵 R，取结果与镜像中最大分量所在的坐标作为桶号。为了让分桶更稳定，论文还让 Q 和 K 共享同一套参数，这样每个词的「提问」和「名片」来自同一身份，哈希分桶天然自洽。再加多轮哈希（multi-round hashing），用多张不同的「测试卷」各分一次桌，让每个词有机会跟更多不同的桶交流，弥补单次分桶的偶然偏差。

分桌之后，「全场几万次握手」变成「只和同桌十几人深聊」，注意力矩阵从「人人对人人」的 n×n 变成若干个桶内小组的小矩阵，计算量与显存同步断崖式下降——这是 Reformer 处理长序列的第一根支柱。

h(x)=arg⁡max⁡([xR; −xR]),R∈Rd×b/2h(\mathbf{x})=\arg\max\left(\left[\mathbf{x}\mathbf{R};\ -\mathbf{x}\mathbf{R}\right]\right),\quad \mathbf{R}\in\mathbb{R}^{d\times b/2}
随机投影加 argmax 就是一道可复用的「性格测试」：相似向量以高概率进同一个桶，不相似向量几乎不会同桶。
  1. x 是词的投影向量每个词带着自己的特征参加分桌测试，形状与 R 的第二维匹配。
    x∈Rd\mathbf{x}\in\mathbb{R}^{d}
  2. R 是随机投影矩阵由标准正态分布采样、训练中冻结不更新的「兴趣维度试纸」，一共 b/2 张。
    R∼N(0,1),R∈Rd×b/2\mathbf{R}\sim\mathcal{N}(0,1),\quad \mathbf{R}\in\mathbb{R}^{d\times b/2}
  3. 正负投影拼接把 xR 与 −xR 拼成 b 维向量。加镜像是为了让向量无论朝哪个方向，总有一个分量的值最大，能被均匀分到 b 个桶中。
    [xR; −xR]∈Rb\left[\mathbf{x}\mathbf{R};\ -\mathbf{x}\mathbf{R}\right]\in\mathbb{R}^{b}
  4. argmax 取桶号最大分量所在的下标就是桶编号，相似的 x 会以极高概率落入同一个桶。
    h(x)∈{0,1,…,b−1}h(\mathbf{x})\in\{0,1,\dots,b-1\}

可逆残差层：倒放录像省显存

宴会规模上去了，新麻烦来了：管家仍然坚持把每场对话一字不差写进备忘录，几万人的录音笔记把储物间都堆满了。策划师决定换一种记录方式——不再记流水账，只录最后一帧画面，外加一张「倒放说明书」：只要知道宴会结束时的样子，照着公式一步步倒推，就能把之前的每一幕原样复原。

这个「倒放说明书」就是可逆残差层（Reversible Residual Layer）。普通 Transformer 的残差结构在反向传播时需要每一层的输入激活值，所以前向时得把每层结果都存进显存；层数越深、序列越长，这堆「流水账」越恐怖。可逆层的核心思想是：把输入拆成两半 x₁ 和 x₂，让两层之间的更新互相耦合；反向时从最终输出出发，用减法就能把所有中间输入全部还原，因此完全不需要存储层间激活。

具体数学长这样：前向时 x₁ 加上函数 F(x₂) 得到 y₁，x₂ 再加上 G(y₁) 得到 y₂；反向时先算 x₂ = y₂ − G(y₁)，再算 x₁ = y₁ − F(x₂)。关键在于前向每一步都是加法，反向只需做对应的减法，不需要额外的参数参与，就能精确复原。

有了倒放录像，管家再也不用囤积成山的流水账笔记，显存占用与层数解耦——模型从「每层都存一份」变成「只存最后一份加说明书的成本」，这就是 Reformer 的第二根支柱，让超深超长模型也能塞进一块 GPU。

y1=x1+F(x2),y2=x2+G(y1)x2=y2−G(y1),x1=y1−F(x2)\begin{aligned}\mathbf{y}_1&=\mathbf{x}_1+F(\mathbf{x}_2), &\quad \mathbf{y}_2&=\mathbf{x}_2+G(\mathbf{y}_1)\\[4pt]\mathbf{x}_2&=\mathbf{y}_2-G(\mathbf{y}_1), &\quad \mathbf{x}_1&=\mathbf{y}_1-F(\mathbf{x}_2)\end{aligned}
前向只用加法，反向只用减法，数学上严格可逆——所以中间激活不必存，需要时重算即可。
  1. 拆分双流把输入按通道拆成两半，像左账本与右账本，各自走一条路径。
    x→(x1,x2)\mathbf{x}\rightarrow(\mathbf{x}_1,\mathbf{x}_2)
  2. 耦合前向 F用右账本的内容算增量，更新左账本。注意更新完全不依赖 x₁ 自身。
    y1=x1+F(x2)\mathbf{y}_1=\mathbf{x}_1+F(\mathbf{x}_2)
  3. 耦合前向 G用更新过的左账本 y₁ 算增量，更新右账本。G 的输入是 y₁ 而非 x₁，这是可逆的关键。
    y2=x2+G(y1)\mathbf{y}_2=\mathbf{x}_2+G(\mathbf{y}_1)
  4. 逆序反向还原倒过来，先用减法还原 x₂，再还原 x₁，全程只有加减法，无需额外存储。
    x2=y2−G(y1),x1=y1−F(x2)\mathbf{x}_2=\mathbf{y}_2-G(\mathbf{y}_1),\quad \mathbf{x}_1=\mathbf{y}_1-F(\mathbf{x}_2)

组件协同：分批上菜与二维座位

两根支柱立起来了，但宴会的杂活还有很多。厨房（前馈网络）空间有限：前馈层中间维度通常是隐藏维度的 4 倍，几万个 token 的中间结果同时堆在厨房里，照样爆内存。策划师的解法是「分批上菜」：把序列切成固定大小的块，逐块送进厨房加工，加工完再拼回长桌。

分块前馈（Chunked Feed-Forward）之所以可行，是因为前馈网络对序列中的每个 token 是独立处理的——块与块之间没有任何依赖。于是数学结果与一次性处理完全等价，但峰值内存被摊平到单块的大小，GPU 的「厨房」再也不用为一次接待全部客人而扩容。

另一个细节是位置编码。序列从 1024 涨到 64000，完整的可学习位置编码表参数也跟着线性膨胀。Reformer 采用轴向位置编码（Axial Positional Encoding）：把一维位置拆成二维坐标 (i, j)，满足 n = n₁×n₂，只学两张小表分别编码行与列，再拼接成完整的位置向量——参数量从 O(n) 降到 O(√n)，几万长度的位置信息一张小表轻松装下。

至此三件套齐全：LSH 分桌管社交、可逆层管笔记、分块前馈管厨房、位置编码管座位。Reformer 把这几样组件像搭积木一样拼进标准 Transformer，就得到了一套能承办「数万人宴会」的完整方案。

PE(i,j)=Concat(p1[i], p2[j]),n=n1×n2\mathbf{PE}(i,j)=\mathrm{Concat}\left(\mathbf{p}_1[i],\ \mathbf{p}_2[j]\right),\quad n=n_1\times n_2
一张大位置表拆成「排号表 + 座号表」两张小表，参数规模从 O(n) 降到 O(√n)——这就是二维座位的妙处。
  1. 位置拆成二维把第 k 个位置改写成 (i, j)，满足 k = i×n₂ + j，一维坐标变成座位表上的「第几排第几号」。
    k=i⋅n2+j,0≤i<n1, 0≤j<n2k=i\cdot n_2+j,\quad 0\leq i<n_1,\ 0\leq j<n_2
  2. 两张小表p₁ 编码「排号」（共 n₁ 项），p₂ 编码「座号」（共 n₂ 项），每一项都是一个小维度的向量。
    p1∈Rn1×dp,p2∈Rn2×dp\mathbf{p}_1\in\mathbb{R}^{n_1\times d_p},\quad \mathbf{p}_2\in\mathbb{R}^{n_2\times d_p}
  3. 拼接成完整编码把排号向量和座号向量拼接起来，得到每个位置独一无二的位置向量。
    PE(i,j)∈R2dp\mathbf{PE}(i,j)\in\mathbb{R}^{2d_p}

训练深化：让分桌更稳的细节

分桌方案听起来美好，实操中却有不少「坑」。比如：每个桶的人数可能严重不均——有的桌挤了上百人，有的桌空无一人。宴会策划师必须想办法让每桌人数大致均衡，否则忙的忙死、闲的闲死，GPU 利用率会很难看。

论文的做法是：把序列先按桶号排序，再切成固定大小的分块（chunk），每个块内做注意力时，注意力范围限定在本块和相邻块。这样既保证了「同桌交流」的近似性，又让计算量完全可控。为了弥补排序分块带来的边界丢失——本来同桌的词却被切到不同块——还额外把一个 chunk 和它后面那个 chunk 拼在一起算注意力，让边界上的词也能互相看到。

另一个实操细节是共享 QK。Reformer 让 Q = K = XWqk，好处有二：一是哈希只需对一份向量做，省了一半投影计算；二是「提问方」和「名片方」身份一致，避免「我想找 A 桌的人、我的名片却挂在 B 桌」的矛盾。训练上，论文还配合梯度裁剪等技术保证长序列训练的稳定。

这些细节就像宴会现场的「应急预案」：均衡分桌、预留邻桌通道、身份统一。它们不改变分桌的大方向，却决定了系统在真实长序列上能不能稳定、高效地跑起来。

Q=K=XWqk\mathbf{Q}=\mathbf{K}=\mathbf{X}\mathbf{W}_{qk}
Q 与 K 共享参数后，分桶决策只依赖同一套向量，天然自洽——不用再担心「提问」和「名片」被分到两桌。
  1. 同一个输入 X每个 token 从同一个词向量出发，不再为 Q 和 K 分别准备两套投影。
    X∈Rn×d\mathbf{X}\in\mathbb{R}^{n\times d}
  2. 同一个权重矩阵 WqkQ 和 K 共享一份投影参数，身份合一；V 仍然使用独立投影，保住信息多样性。
    Wqk∈Rd×dk\mathbf{W}_{qk}\in\mathbb{R}^{d\times d_k}
  3. 逐 token 相等Q 与 K 完全相等，LSH 哈希分桶时只需要对 Q（=K）做一次投影分桶。
    Q=K=XWqk\mathbf{Q}=\mathbf{K}=\mathbf{X}\mathbf{W}_{qk}

性能与局限：能跑多远

改革后的宴会到底能承办多少人？标准方案 n² 的社交量让一万人成为上限；Reformer 把注意力复杂度降到接近 O(n log n)，再加上可逆层把每层激活变成「零存整取」，几千 token 的常规模型可以扩展到几万甚至十几万 token。

论文在 64K 长度的任务上做了验证：单个加速器就能跑 64,000 个词，而且困惑度（perplexity）与标准 Transformer 相当。这告诉我们 Reformer 的「性价比」：它牺牲了一部分「全场精准社交」的建模能力（毕竟不看跨桶词对），换来了处理超长序列的可能性。当序列足够长、长程依赖任务足够硬，这种交换就是值得的。

当然它也有局限。LSH 是近似注意力：个别本该互相注意的词对可能被分到不同桶而漏掉，多轮哈希只能缓解、不能根治。此外，哈希分桶、排序、重排这些操作在工程实现上并不简单，并非所有场景都值得引入这套复杂度。

从「千人宴会」到「数万人宴会」，Reformer 用两根支柱证明：不是场地不够大，而是之前的社交与记账方式太浪费。后来 Longformer、BigBird、FlashAttention 等一大批高效注意力工作，都沿着「少打招呼、精打细算」的思路继续前行。

O(n2d)  →  LSH    O(nlog⁡n⋅d),O(L⋅n)  →  reversible    O(n)O(n^{2}d)\;\xrightarrow{\;\mathrm{LSH}\;}\;O(n\log n\cdot d),\qquad O(L\cdot n)\;\xrightarrow{\;\mathrm{reversible}\;}\;O(n)
前半段是注意力时间（从 n² 降到 n log n），后半段是激活显存（从「层数×长度」降到「只存一份」）——LSH 管时间，可逆层管显存。
  1. n 与 L 的含义n 是序列长度，即宾客人数；L 是 Transformer 层数，相当于宴会的楼层数。
    n,Ln,\quad L
  2. 注意力时间对比时间从 n² 降到 n log n，因为现在只计算同桶（同桌）词对的注意力，不再全场社交。
    n2→nlog⁡nn^{2}\rightarrow n\log n
  3. 激活显存对比显存从「每层存一份中间结果」变成「只存一份最终结果」，层数 L 不再放大显存需求。
    L⋅n→nL\cdot n\rightarrow n
  4. 促成者标注前一个箭头由 LSH 注意力促成，后一个由可逆层促成，二者正是 Reformer 的两根支柱。
    →  LSH  ,→  reversible  \xrightarrow{\;\mathrm{LSH}\;},\quad\xrightarrow{\;\mathrm{reversible}\;}

AI 应用场景

超长文档的整篇精读

阶段：长序列建模 / 模型推理

解决的问题：普通 Transformer 处理几万字合同或论文时直接显存溢出，只能截断成片段，导致上下文断裂；Reformer 用 LSH 注意力加可逆层让整篇文档一次进模型，保留全文依赖关系。

具体案例：某法律科技公司对一篇 200 页的 IPO 招股说明书做风险条款抽取。用 Reformer 把整份文档作为单条样本送入模型，显存占用不到原方案的三分之一，还能同时关联「第一章定义」与「第八章风险」的跨页呼应条款。

长音频与视频特征序列建模

阶段：特征序列处理 / 预训练

解决的问题：语音按帧采样后一小时音频产生数万帧特征，视频每秒数十帧，标准自注意力的平方级开销让这类超长序列根本无法训练。

具体案例：在某音频识别项目中，研究者把一小时语音切成 64,000 帧 MFCC 特征，用 Reformer 训练帧级分类器，在单卡上完成了原本需要多卡并行的实验，序列长度是之前 Transformer 方案的 16 倍。

大模型长上下文扩展的架构选型

阶段：模型架构设计 / 训练基础设施

解决的问题：大模型把上下文窗口从 2K 扩到 32K 以上时，标准注意力内存不可接受；工程师需要评估「近似注意力」与「精确注意力」的取舍。

具体案例：某团队在扩展客服大模型上下文时，先用 Reformer 做对照组，验证了「遗忘跨桶信息」在真实问答中损失可控，再决定是否投入更重的 FlashAttention 工程改造——省下了一轮昂贵的实验成本。

Python 演示

python63 行
import numpy as np  class LSHBuckets:    # Reformer-style LSH: random projection + sign mirror + argmax    def __init__(self, dim, n_buckets, seed=42):        rng = np.random.RandomState(seed)        self.R = rng.randn(dim, n_buckets // 2).astype(np.float32)     def hash(self, x):        proj = x @ self.R        combined = np.concatenate([proj, -proj], axis=1)        return np.argmax(combined, axis=1)  def lsh_attention(q, k, v, n_buckets=4):    # Only compute attention between tokens in the same bucket.    n, d = q.shape    bucket_ids = LSHBuckets(d, n_buckets).hash(q)    out = np.zeros_like(v)    total_pairs = 0    for b in range(n_buckets):        idx = np.where(bucket_ids == b)[0]        m = len(idx)        if m == 0:            continue        if m == 1:            out[idx] = v[idx]            continue        sub_q, sub_k, sub_v = q[idx], k[idx], v[idx]        scores = sub_q @ sub_k.T / np.sqrt(d)        exp = np.exp(scores - scores.max(axis=1, keepdims=True))        weights = exp / exp.sum(axis=1, keepdims=True)        out[idx] = weights @ sub_v        total_pairs += m * (m - 1) // 2    return out, bucket_ids, total_pairs  def full_attention(q, k, v):    scores = q @ k.T / np.sqrt(q.shape[1])    exp = np.exp(scores - scores.max(axis=1, keepdims=True))    weights = exp / exp.sum(axis=1, keepdims=True)    return weights @ v  def main():    rng = np.random.RandomState(0)    n, d = 16, 8    x = rng.randn(n, d).astype(np.float32)    q = k = x  # Reformer shares Q and K    v = rng.randn(n, d).astype(np.float32)     out_full = full_attention(q, k, v)    out_lsh, bucket_ids, pairs = lsh_attention(q, k, v)     print("bucket sizes:", np.bincount(bucket_ids, minlength=4))    print("full pairs:", n * (n - 1) // 2)    print("lsh pairs:", pairs)    print("mean output diff:", round(float(np.abs(out_full - out_lsh).mean()), 4))  if __name__ == "__main__":    main()
目的：用 NumPy 实现 Reformer 的 LSH 随机投影分桶与「桶内注意力」，并与完整注意力对比交互次数和输出差异，直观感受从 n² 量级到「同桶小矩阵」的降幅。
  1. self.R = rng.randn(dim, n_buckets // 2).astype(np.float32)生成随机投影矩阵 R，对应论文里「每人一份性格测试卷」，初始化后冻结不再更新。
  2. combined = np.concatenate([proj, -proj], axis=1)把投影结果与镜像拼接，让向量无论朝向哪边都能被均匀分桶。
  3. np.argmax(combined, axis=1)取最大分量下标作为桶号，相似向量大概率得到相同桶号。
  4. q = k = x复现 Reformer 的共享 QK 设定：提问与名片同一身份。
  5. idx = np.where(bucket_ids == b)[0]找出同一桌的宾客，只在这些下标之间做注意力。
  6. scores = sub_q @ sub_k.T / np.sqrt(d)只算桶内亲密度小矩阵，完全避开 n×n 全矩阵。
  7. total_pairs += m * (m - 1) // 2累计实际交互次数，与完整注意力的 n(n−1)/2 直接对比。

常见误区

误区我以为 Reformer 只是把注意力算得更快，数学结果和标准 Transformer 一模一样，模型效果也分毫不差。

正解不是的。LSH 注意力是「近似注意力」：它只计算同桶内的词对，跨桶词对直接忽略。桶划分本身带随机性，所以逐点的输出与标准注意力有明显差异，论文说的「表现相当」是指在困惑度（perplexity）等整体指标上大体持平。就像分桌后你只和同桌深聊，当然会错过其他桌的有趣故事，但整场宴会的氛围并不会崩。

为何常见：看到论文「与标准 Transformer 相当」的结论，误把「整体效果相当」理解成「逐点输出相同」，忽略近似注意力本身的精度损失。

误区我觉得把残差层改成可逆结构，输出还能倒推回来，那模型表达能力一定变弱了，前向结果必然和原来不一样。

正解可逆层是「数学上等价」的重参数化：y₁ = x₁ + F(x₂) 表达的能力范围与普通残差结构一致，改变的只是内存策略——不存中间激活、反向时重算，而不是修改前向计算结果。好比把流水账换成倒放录像：宴会过程本身没变，变的只是记录方式。

为何常见：把「工程上的显存优化」误当成「模型数学结构的改动」，没有分清前向计算与内存管理是两个独立层面。

误区既然复杂度从平方级降到了对数级，那我直接把序列拉到一百万 token，Reformer 也能轻松处理。

正解Reformer 只是把注意力从 O(n²) 降到约 O(n log n)，这个函数仍然随 n 增长；再加上哈希排序、多轮哈希的开销，以及可逆层反向重算带来的额外时间成本，序列长度仍有硬上限。它把门槛从「几千」推到「几万到十几万」，但绝不是无上限——宴会厅再大，也有物理边界。

为何常见：只记住「复杂度降低了」的结论，忽略了降低后的复杂度依然是随 n 增长的函数关系。

误区把哈希桶数调大，每桶人变少，注意力算得更快，所以桶数越大性能越好。

正解桶数过多会导致每桶 token 太少，注意力退化成「近视眼」——每个词只看到极少数邻居，长程信息彻底丢失，模型效果崩坏。桶数要和序列长度、chunk 大小协调，追求「每桶人数适中、覆盖率足够」。分桌分得太细，宴会上你就谁都聊不上了。

为何常见：把复杂度公式里「桶数在分母」误读为单调利好，忽略了注意力质量需要足够多的同桶邻居来保证。

面试题

Q1. 标准自注意力的时间复杂度是？

单选题 · easy

  • A.O(n) 的线性量级复杂度
  • B.O(n log n) 近线性复杂度
  • C.O(n²) 的平方级复杂度← 正确答案
  • D.O(2ⁿ) 的指数级复杂度

答案：C。标准自注意力要计算 QKᵀ 得到 n×n 的注意力矩阵，每对 token 都要交互一次，所以时间和显存都是 O(n²)。n log n 是 Reformer 用 LSH 之后的目标复杂度，不是标准注意力的。

Q2. LSH 注意力中，决定 token 被分到哪个桶的直接依据是什么？

单选题 · easy

  • A.哈希函数对向量做投影的结果← 正确答案
  • B.词频统计中高频词语的结果
  • C.位置编码奇偶性判定的结果
  • D.随机初始化词向量排序的桶位

答案：A。Reformer 用随机投影哈希：向量乘随机矩阵 R，取拼接结果中最大分量下标作为桶号。词频、位置奇偶性都不参与分桶；随机初始化的词向量本身也不是分桶依据，只有投影后的比较结果决定桶号。

Q3. Reformer 让 Q 和 K 共享参数的主要目的是什么？

单选题 · mid

  • A.直接减少模型参数的存储总量
  • B.让哈希分桶自洽并减少投影计算← 正确答案
  • C.提高 softmax 的数值稳定性
  • D.让注意力权重矩阵变为对称

答案：B。共享 QK 后每个 token 的「提问」和「名片」来自同一份向量，LSH 哈希只需对 Q（=K）做一次投影，避免「提问去 A 桌、名片在 B 桌」的矛盾。参数减半只是副产物，且只占模型总参数的小部分；与 softmax 稳定性、矩阵对称性无关。

Q4. 可逆残差层通过什么方式节省显存？

单选题 · mid

  • A.降低模型整体的参数量规模
  • B.降低前向传播的计算总量
  • C.反向传播时重新计算中间激活← 正确答案
  • D.用低精度压缩各层的输出缓存

答案：C。可逆层的前向只有加法，反向可以用减法精确还原每层输入，因此不需要把每层中间激活存进显存，需要时重算即可。它省的是「激活显存」，不是参数量，也不减少前向计算量。

Q5. 关于多轮哈希（multi-round hashing）的作用，下面说法正确的是？

单选题 · mid

  • A.把多轮的分桶结果取平均输出
  • B.让 token 与更多不同的桶交流← 正确答案
  • C.提高单轮哈希的随机强度
  • D.减少哈希投影的计算轮数

答案：B。单轮哈希可能把本该互相注意的词对分到不同桶而漏掉。多轮哈希用多张不同的「测试卷」各分一次桌，每个 token 有机会与更多不同的桶交互，从而弥补单轮分桶的偶然偏差。它不取平均、不增强随机性，也不会减少计算轮数。

Q6. Reformer 能处理超长序列，依赖了下列哪些机制？

多选题 · mid

  • A.LSH 注意力大幅降低时间开销← 正确答案
  • B.可逆层大幅降低激活显存← 正确答案
  • C.分块前馈摊平峰值内存← 正确答案
  • D.扩大词表以缩短序列长度

答案：ABC。LSH 注意力把时间从 O(n²) 降到约 O(n log n)，可逆层让中间激活不必存储，分块前馈把前馈网络的峰值内存摊平，三者共同支撑超长序列。扩大词表不能缩短序列长度，也与内存优化无关。

Q7. 下列哪些属于 Reformer 在工程上的优化细节？

多选题 · mid

  • A.分块前馈摊平峰值内存← 正确答案
  • B.共享 QK 减少投影开销← 正确答案
  • C.增大隐藏层提升表达能力
  • D.轴向编码压缩位置参数← 正确答案

答案：ABD。分块前馈、共享 QK、轴向位置编码都是 Reformer 论文中的工程优化；「增大隐藏层」是普通的模型容量调整，不是 Reformer 特有的优化手段，也不解决长序列的内存问题。

Q8. Reformer 中桶内注意力为什么要让一个 chunk 与相邻 chunk 拼接后一起计算？

单选题 · hard

  • A.增大每个注意力块内的 token 数
  • B.弥补排序分块损失的边界词对← 正确答案
  • C.允许模型采用更大的学习率
  • D.减少哈希函数的投影轮次数

答案：B。按桶号排序后切成固定 chunk，可能把原本同桶相邻、应当互相注意的词对切到两个块的边界上。把当前 chunk 与下一个 chunk 拼接算注意力，等于在分块之间留出「邻桌通道」，让边界词对仍然能互相看到。这与学习率、轮次数无关。

Q9. 关于 Reformer 的局限性，下列说法正确的有哪些？

多选题 · hard

  • A.哈希近似可能漏掉跨桶关键信息← 正确答案
  • B.可逆层反向重算增加额外耗时← 正确答案
  • C.序列长度的扩展不受任何限制
  • D.排序分块工程实现比较繁琐← 正确答案

答案：ABD。LSH 是近似注意力，跨桶词对被忽略，多轮哈希只能缓解不能根治；可逆层用「反向重算」换省显存，会带来额外前向时间；哈希排序、重排等操作工程上并不简单。序列长度仍然受算力与显存硬约束，并非无限扩展。

Q10. 设序列长度 n=1024，桶数 b=64 且每桶人数理想均匀。单轮哈希下，LSH 注意力的交互次数约为标准注意力的多少？

单选题 · extreme

  • A.约 1/2
  • B.约 1/8
  • C.约 1/64← 正确答案
  • D.约 1/128

答案：C。标准注意力交互约为 n²/2 ≈ 524,288 次。每桶人数 n/b = 16，单桶交互 16×15/2 = 120 次，64 桶共 7,680 次，比值约为 1/68，最接近 1/64。这正体现了「分桌」把平方级社交压缩到近线性的核心威力。