Long Context: RoPE / YaRN / NTK / MLA / Sliding Window 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. RoPE：对每对维度 $(2i, 2i+1)$ 做位置 $m$ 相关的 2D 旋转，$\theta_i = 10000^{-2i/d}$。$q_m^\top k_n$ 仅依赖相对位置 $m-n$（不依赖绝对 $m, n$ 各自），且无需训练参数。
2. PI (Position Interpolation, Chen 2023)：把所有 $\theta_i$ 同除以 $s = L_\text{new}/L_\text{train}$（等价于把绝对位置 $m$ 缩到 $m/s$）。伤害高频（早期维度的相位分辨率被压缩），但实现简单。
3. NTK-aware (bloc97 2023)：换底，新底 $b' = b \cdot s^{d/(d-2)}$。低频维度被强压缩、高频维度几乎不变，零样本外推优于 PI。
4. YaRN (Peng 2023)：NTK-by-parts（分段处理频率）+ temperature scaling（拟合公式 $\sqrt{1/t} \approx 0.1\ln s + 1$，即 $t \approx 1/(0.1\ln s + 1)^2$）+ attention scale。三组件分别解决：高频/低频分别处理、稀释 softmax、补偿外推后注意力熵增。
5. LongRoPE (Ding 2024 ICML)：演化搜索每维独立的缩放因子 $\lambda_i$，加上 short-context "rescue"，把上下文推到 2M tokens。
6. MLA (DeepSeek-V2)：$\mathbf{c}_t^{KV} = W_\text{DKV}\mathbf{h}_t$ 把 K/V 压成 $d_c \ll N_h d_h$ 的 latent；RoPE 必须解耦——单独留一份 $d_h^R$ 维 RoPE key（共享 across heads），否则旋转矩阵不能"吸进" $W_\text{UK}$ 里。
7. Streaming + Sink (Xiao 2024 ICLR)：保留前 4 个 token（attention sink，softmax 的"垃圾桶"）+ 滑动窗口；window 外的 token 直接丢，但 sink 不能丢，否则 PPL 爆炸。
8. System：Ring Attention / Context Parallel 跨设备 chunk K/V；FlashAttention 2/3 块化 + online softmax；Mistral SWA 把每层感受野从 $L$ 降到 $W$（多层叠加仍可看远）。

§1 Long Context 为什么难 — 一段直觉

把 Transformer 推到 100K-2M token 上下文，难点其实是 三件事并存：

• 位置编码外推 (extrapolation)：训练时只见过 $m \in [0, 4096)$，推理时给 $m = 100{,}000$，模型必须知道这是"很远"而不是数值崩坏。RoPE 默认不外推：未见过的旋转相位让 $q_m^\top k_n$ 的相对位置信号失效。
• KV cache 显存：自回归 decode 时 $\text{cache} \propto L \cdot n_\text{layers} \cdot 2 \cdot N_h \cdot d_h \cdot \text{bytes}$。对 LLaMA-2-7B（32 层, $N_h=32, d_h=128$, fp16，MHA）一条 4K 上下文 $\approx 2.1$ GB，一条 100K $\approx 52$ GB，单卡装不下。MQA/GQA 把 $N_h \to G$，MLA 把 $N_h d_h \to d_c$。
• 注意力本身的 $O(L^2)$：$L=100\text{K}$ 时 $L^2 = 10^{10}$，分数矩阵装不下。两条路：算法变稀疏/线性（sliding window, sparse attention, linear attention）或 系统切分（Ring Attention, Context Parallelism, FlashAttention 块化）。

§2 RoPE — 旋转位置编码

2.1 复数视角推导

目标：找一个对 query/key 的位置相关变换 $f(\mathbf{x}, m)$，使得内积 $\langle f(\mathbf{q}, m), f(\mathbf{k}, n) \rangle$ 只依赖于相对位置 $m - n$（以及 $\mathbf{q}, \mathbf{k}$ 内容本身），不再依赖绝对 $m, n$。

把 $\mathbf{x} \in \mathbb{R}^d$ 按相邻两维分组打包成 $d/2$ 个复数：$\mathbf{x} \leftrightarrow [x_0 + ix_1, x_2 + ix_3, \dots] \in \mathbb{C}^{d/2}$。定义

$$f(\mathbf{x}, m) = \mathbf{x} \odot e^{im\boldsymbol\theta}, \quad e^{im\boldsymbol\theta}_i = e^{im\theta_i}, \quad \theta_i = b^{-2i/d}\ (b = 10000)$$

其中 $\odot$ 是逐元素复数乘法。由复数乘法性质：

$$\langle f(\mathbf{q}, m), f(\mathbf{k}, n) \rangle_\mathbb{R} = \mathrm{Re}\!\left[(\mathbf{q} \odot e^{im\boldsymbol\theta})^* (\mathbf{k} \odot e^{in\boldsymbol\theta})\right] = \mathrm{Re}\!\left[\sum_{i=0}^{d/2-1} \bar{q_i} k_i \cdot e^{i(n-m)\theta_i}\right]$$

只依赖 $n - m$（与 $\bar{q_i}k_i$，即内容项），绝对位置项消掉——这就是 RoPE 给出相对位置的根本原因。

2.2 实数矩阵形式

每对维度上是 2D 旋转矩阵：

$$R_{\theta_i, m} = \begin{pmatrix} \cos m\theta_i & -\sin m\theta_i \\ \sin m\theta_i & \cos m\theta_i \end{pmatrix}$$

把 $\mathbf{x}$ 视作 $d/2$ 个 2D 向量的拼接，整体 $R_m = \mathrm{blkdiag}(R_{\theta_0, m}, \dots, R_{\theta_{d/2-1}, m})$。则：

$$\langle R_m \mathbf{q}, R_n \mathbf{k} \rangle = \mathbf{q}^\top R_m^\top R_n \mathbf{k} = \mathbf{q}^\top R_{n-m} \mathbf{k}$$

最后一步用 $R_m^\top R_n = R_{n-m}$（2D 旋转的可加性）。相对位置 $n - m$ 被显式编码到内积里。

2.3 为什么 $\theta_i = 10000^{-2i/d}$（频率分布）

把 $\theta_i$ 看作角速度。维度 $i$ 越大，$\theta_i$ 越小，旋转越慢（低频）；维度 $i$ 越小（接近 0），$\theta_i$ 越接近 1，旋转越快（高频）。

• 高频维度：周期短（$2\pi/\theta_i$ 短），位置变化对相位敏感——编码精细的局部相对位置
• 低频维度：周期长（最大 $2\pi \cdot 10000$），相位随位置缓变——编码粗粒度的远程位置

这种 几何级数频率分布 与 Vaswani 2017 sinusoidal PE 相同（不是巧合：sinusoidal PE 也是 $10000^{-2i/d}$），让模型在多个时间尺度上同时分辨位置。

2.4 from-scratch RoPE 代码

import torch

def precompute_rope_cache(seq_len: int, dim: int, base: float = 10000.0, device=None):
    """
    返回 cos / sin tensor，shape [seq_len, dim/2]，逐对维度共享旋转角。
    dim 必须是偶数 (RoPE 按相邻两维成对旋转)。
    """
    assert dim % 2 == 0, "RoPE dim must be even"
    half = dim // 2
    # θ_i = base^{-2i/dim},  i = 0, 1, ..., dim/2-1
    inv_freq = 1.0 / (base ** (torch.arange(0, half, device=device).float() / half))
    pos = torch.arange(seq_len, device=device).float()              # [L]
    freqs = torch.outer(pos, inv_freq)                              # [L, dim/2]
    return freqs.cos(), freqs.sin()                                 # [L, dim/2] each

def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
    """
    x:   [..., L, dim]              (Q 或 K)
    cos: [L, dim/2]  sin: [L, dim/2]
    实现实数形式: 把 x 拆成两半 x1, x2，对应复数实/虚部，做 2D 旋转。
    约定 (HuggingFace LLaMA style): pair = (x[..., :half], x[..., half:])
        而不是 (x[..., 0::2], x[..., 1::2])。
    数学等价 (取决于实现约定，二者只是排列不同)。
    """
    x1, x2 = x.chunk(2, dim=-1)                                     # 每个 [..., L, dim/2]
    # 旋转: (x1, x2) -> (x1*cos - x2*sin, x1*sin + x2*cos)
    rot1 = x1 * cos - x2 * sin
    rot2 = x1 * sin + x2 * cos
    return torch.cat([rot1, rot2], dim=-1)

# 完整流程示例 ——————————————————————————————————————
def rope_attention(Q, K, V, cos, sin, mask=None):
    """
    Q, K, V: [B, H, L, d_head]
    cos, sin: [L, d_head/2]  (可被 broadcast)
    """
    Q = apply_rope(Q, cos, sin)
    K = apply_rope(K, cos, sin)
    scores = (Q @ K.transpose(-2, -1)) / (Q.size(-1) ** 0.5)
    if mask is not None:
        scores = scores.masked_fill(~mask, float("-inf"))
    return torch.softmax(scores, dim=-1) @ V

§3 朴素位置编码回顾（对比基线）

§4 PI — Position Interpolation（最简单的 RoPE 外推）

4.1 动机

训练时 $m \in [0, L_\text{train})$；推理给 $m \in [0, L_\text{new})$，$L_\text{new} > L_\text{train}$。RoPE 直接外推会崩溃：当 $m \theta_i$ 超过训练见过的相位范围（特别是低频维度上 $m\theta_i$ 已经接近 $2\pi$ 时），相位进入未见区域，attention 行为不可预测。

PI 的想法（Chen et al., Meta, 2023, "Extending Context Window of LLMs via Position Interpolation"）：不外推，去插值。把 $m \in [0, L_\text{new})$ 线性压缩到 $[0, L_\text{train})$。

4.2 形式

设缩放因子 $s = L_\text{new} / L_\text{train}$。把绝对位置 $m$ 替换为 $m / s$：

$$\text{PI:}\quad f(\mathbf{x}, m) = \mathbf{x} \odot e^{i (m/s) \boldsymbol\theta}$$

等价地（更常见的实现）：保持 $m$ 不变，把所有 $\theta_i$ 替换为 $\theta_i / s$。两种说法完全等价。

4.3 副作用：高频被破坏

低频维度上 $m\theta_i$ 本来就 $\ll 2\pi$（在训练长度内未完成一周期），缩到 $m\theta_i / s$ 仍在合理范围。问题在高频：高频维度 $\theta_i \approx 1$，训练时 $m\theta_i$ 已经在 $[0, L_\text{train}]$ 范围内自由旋转，缩到 $1/s$ 后相对位置分辨率下降 $s$ 倍——本来相邻 token 之间相位差为 $\theta_i$（接近 1 rad），现在只剩 $\theta_i/s$，模型分辨"相距 1 token vs 相距 2 token"的能力下降。

4.4 PI 代码

def precompute_rope_cache_pi(seq_len: int, dim: int,
                              base: float = 10000.0,
                              scale: float = 1.0,        # s = L_new / L_train
                              device=None):
    """PI: 把 θ_i 同除以 s（等价于把 m 缩到 m/s）"""
    half = dim // 2
    inv_freq = 1.0 / (base ** (torch.arange(0, half, device=device).float() / half))
    inv_freq = inv_freq / scale                         # ← PI 的关键一行
    pos = torch.arange(seq_len, device=device).float()
    freqs = torch.outer(pos, inv_freq)
    return freqs.cos(), freqs.sin()

§5 NTK-aware RoPE — 保留高频的换底方案

5.1 起源与直觉

PI 把高频维度也压扁了，社区觉得太粗暴。bloc97 / jquesnelle 在 LocalLLaMA 2023 年 7 月的 reddit 帖里提出 NTK-aware scaling（"NTK-Aware Scaled RoPE"），名字来源于 Neural Tangent Kernel 中"高频 vs 低频"的视角：神经网络对高频信号学习慢，破坏高频比破坏低频更伤模型。

核心想法：换底而不是统一缩放——让高频维度几乎不变（保护精细位置），低频维度被强压缩（这部分本来训练就没见过完整周期，影响小）。

5.2 推导：怎样换底才能让低频被压到 $1/s$？

回顾 RoPE 频率 $\theta_i = b^{-2i/d}$。

• 最高频 ($i = 0$)：$\theta_0 = 1$
• 最低频 ($i = d/2 - 1$)：$\theta_{d/2-1} = b^{-(d-2)/d} \approx b^{-1}$（当 $d$ 大时）

PI 把所有 $\theta_i$ 都除以 $s$，等价于把所有维度的位置分辨率打 $s$ 折。

NTK-aware：换底从 $b$ 到 $b'$，使得最低频的 $\theta$ 被缩到 $1/s$，最高频的 $\theta$ 几乎不变。

设 $b' = b \cdot \alpha$。则新最低频是

$$\theta'_{d/2-1} = (b')^{-(d-2)/d} = b^{-(d-2)/d} \cdot \alpha^{-(d-2)/d}$$

要让 $\theta'_{d/2-1} = \theta_{d/2-1} / s$，需要

$$\alpha^{-(d-2)/d} = 1/s \quad\Longrightarrow\quad \alpha = s^{d/(d-2)}$$

所以

$$\boxed{\;b' = b \cdot s^{\,d/(d-2)}\;}$$

验证最高频：$\theta'_0 = (b')^0 = 1 = \theta_0$，完全不变。$\checkmark$

渐进：维度 $i$ 上 $\theta'_i / \theta_i = \alpha^{-2i/d} = s^{-2i/(d-2)}$。$i = 0$ 时比值 1（不变），$i = d/2-1$ 时比值 $1/s$（强压缩）。从高频到低频压缩比指数过渡——这就是"NTK-aware"的几何含义。

5.3 与 PI 的对比

5.4 NTK-aware 代码

def precompute_rope_cache_ntk(seq_len: int, dim: int,
                               base: float = 10000.0,
                               scale: float = 1.0,        # s = L_new / L_train
                               device=None):
    """
    NTK-aware: 换底 b' = b * s^{d/(d-2)}
    - 最高频维度 (i=0) θ 不变;
    - 最低频维度 (i=d/2-1) θ 被压到 1/s;
    - 中间维度按 i 指数过渡。
    """
    new_base = base * (scale ** (dim / (dim - 2)))
    half = dim // 2
    inv_freq = 1.0 / (new_base ** (torch.arange(0, half, device=device).float() / half))
    pos = torch.arange(seq_len, device=device).float()
    freqs = torch.outer(pos, inv_freq)
    return freqs.cos(), freqs.sin()

§6 YaRN — Yet another RoPE extensioN

6.1 总览

Peng et al. 2023 ("YaRN: Efficient Context Window Extension of Large Language Models") 把 NTK-aware 思路系统化，拆成三个相对独立的组件：

1. NTK-by-parts：按波长把维度分三段，分别处理
2. Temperature scaling：在 softmax 之前对 logits 整体加温度
3. Attention scale（与温度等价的另一种实现）：把 Q/K 的范数同步缩放

下面分别推导。

6.2 NTK-by-parts — 分频段处理

设 $L_\text{train}$ 是训练上下文长度。维度 $i$ 的波长 $\lambda_i = 2\pi / \theta_i = 2\pi b^{2i/d}$。定义比值

$$r_i = \frac{L_\text{train}}{\lambda_i} = \frac{L_\text{train} \cdot \theta_i}{2\pi}$$

$r_i$ 表示训练长度内维度 $i$ 转了多少圈。把维度分三段：

形式化：对维度 $i$，定义 ramp 函数

$$\gamma(r_i) = \mathrm{clip}\!\left(\frac{r_i - \alpha}{\beta - \alpha},\; 0,\; 1\right) \in [0, 1]$$

新频率取 NTK-aware 与 PI 的插值：

$$\theta'_i = (1 - \gamma(r_i)) \cdot \frac{\theta_i}{s} + \gamma(r_i) \cdot \theta_i$$

• $r_i \ge \beta$（高频）：$\gamma = 1$，$\theta'_i = \theta_i$（不变）
• $r_i \le \alpha$（低频）：$\gamma = 0$，$\theta'_i = \theta_i / s$（PI 全缩放）
• 中间：平滑过渡

6.3 Temperature Scaling — 注意力熵补偿

问题：扩展上下文后 softmax 输入的有效统计变了——同样的 query 现在面对 $L_\text{new} \gg L_\text{train}$ 个 key，attention 分布更扁平（熵更高），有效信号被稀释。

解决：在 softmax 前给 logits 除以温度 $t$（$t < 1$ 让分布更尖锐，补偿稀释）：

$$\mathrm{Attention} = \mathrm{softmax}\!\left(\frac{QK^\top}{t \sqrt{d_k}}\right) V$$

YaRN 论文的拟合公式（来自经验性 ablation）：

$$\boxed{\;\sqrt{1/t} \approx 0.1 \ln s + 1 \quad\Longleftrightarrow\quad t \approx \frac{1}{(0.1 \ln s + 1)^2}\;}$$

例如 $s = 8$ ($L_\text{new} = 32\text{K}$ from $L_\text{train} = 4\text{K}$)：$\sqrt{1/t} \approx 0.1 \cdot 2.08 + 1 \approx 1.21$，$t \approx 0.68$。

6.4 Attention Scale — 与 Temperature 等价的另一实现

直接改 softmax 温度需要改 attention kernel。等价做法：把 query 和 key 的范数同时乘以 $\sqrt{1/t} = (0.1\ln s + 1) > 1$（$t < 1$ 时是放大），这样 $QK^\top$ 自然被放大 $1/t$ 倍，softmax 看到的就是除以 $t$ 后的 logits。

YaRN 通过把 RoPE cache 直接乘进缩放因子来实现：

$$\text{cos}'_m = \cos(m \theta'_i) \cdot \sqrt{1/t}, \quad \text{sin}'_m = \sin(m \theta'_i) \cdot \sqrt{1/t}$$

注意这只对 RoPE 部分起作用，整体效果等价于把 query/key 范数放大 $\sqrt{1/t}$ 倍（$t < 1$ 时该因子 $> 1$）——前提是 Q/K 的范数主要由 RoPE 后的部分主导。实践中 YaRN 的 attention scale 实现就是把 cos/sin 缓存里乘上 $\sqrt{1/t}$。这等价于改温度且不动 attention kernel。

6.5 YaRN 三组件各解决什么（L3 必问）

YaRN 论文展示：仅 400 步 fine-tune 把 LLaMA-2-7B 从 4K 推到 128K（$s = 32$），优于 PI 和 NTK-aware。

6.6 YaRN 代码（NTK-by-parts + temperature）

import math

def precompute_rope_cache_yarn(
    seq_len: int, dim: int,
    base: float = 10000.0,
    scale: float = 1.0,            # s = L_new / L_train
    original_max_pos: int = 4096,  # L_train
    alpha: float = 1.0,            # ramp 下界 (圈数)
    beta: float = 32.0,            # ramp 上界 (圈数)
    device=None,
):
    """
    YaRN: NTK-by-parts + temperature scaling (实现为 attention scale).
    - 高频维 (r_i ≥ β):  不缩放
    - 低频维 (r_i ≤ α):  PI 风格全缩放
    - 中间维 (α < r_i < β): 平滑过渡
    """
    half = dim // 2
    i = torch.arange(0, half, device=device).float()                 # [half]
    inv_freq = 1.0 / (base ** (i / half))                            # θ_i
    wavelen = 2.0 * math.pi / inv_freq                               # λ_i
    r = original_max_pos / wavelen                                   # r_i = L_train / λ_i

    gamma = torch.clamp((r - alpha) / (beta - alpha), 0.0, 1.0)      # ramp ∈ [0,1]
    inv_freq_pi   = inv_freq / scale                                  # PI 全缩放
    inv_freq_ntk  = inv_freq                                          # NTK 不缩 (高频)
    inv_freq_yarn = (1.0 - gamma) * inv_freq_pi + gamma * inv_freq_ntk

    # Temperature scaling (作为 attention scale 实现到 cos/sin 上)
    # YaRN 经验公式:  sqrt(1/t) ≈ 0.1 ln(s) + 1
    # 目标: 让 effective QK^T 被放大 1/t 倍 (等价于 softmax 温度变 t<1 → 更尖锐).
    # 实现: Q 和 K 的范数各乘 sqrt(1/t), 则 QK^T 自然乘以 1/t.
    # 因为 RoPE 用 cos/sin 旋转, 把 sqrt(1/t) 乘到 cos/sin 上即可.
    sqrt_inv_t = 0.1 * math.log(scale) + 1.0 if scale > 1.0 else 1.0
    attn_scale = sqrt_inv_t                                           # ← 乘到 cos/sin 上, 放大 Q/K 范数

    pos = torch.arange(seq_len, device=device).float()
    freqs = torch.outer(pos, inv_freq_yarn)
    return freqs.cos() * attn_scale, freqs.sin() * attn_scale

§7 LongRoPE — 演化搜索 + 短上下文 rescue

Ding et al., ICML 2024 (Microsoft) 进一步问：每个维度的最优缩放因子能否独立搜索，而不是用同一个 ramp 函数？

7.1 关键观察

1. 不同维度对扩展长度的敏感性差异极大（同一 ramp 函数不一定最优）。
2. 超长上下文模型在短上下文 (≤ $L_\text{train}$) 上反而退化——因为 RoPE 缓存被改了，原训练分布被打乱。

7.2 三阶段方案

7.3 搜索空间

每个维度 $i$ 的 $\lambda_i \in [1, s_\text{max}]$（$s_\text{max} = L_\text{new}/L_\text{train}$），新频率 $\theta'_i = \theta_i / \lambda_i$。

搜索目标：

$$\min_{\{\lambda_i\}} \mathrm{PPL}\!\left(M; \theta'_i = \theta_i / \lambda_i\right) \quad \text{on a long-context validation set}$$

演化算法（CMA-ES 或类似）维护 population，迭代选优。论文实验上演化几百代即可收敛。

7.4 与 YaRN 对比

§8 ABF 与 NoPE — 两种"非主流"扩展

8.1 ABF — Adjusted Base Frequency (Xiong et al. 2023, Meta)

最朴素的"换底"——直接把 RoPE 底从 10000 改大（如 500000）。等价于全维度同步 NTK-aware 缩放，但不用考虑 ramp。

• 优点：最简单，1 行配置改动。
• 缺点：$\theta_0 = (b')^0 = 1$ 同样不变（与 NTK-aware 一致，最高频被精确保留），但 ABF 的 $b'$ 是凭经验拍出来的（如 $10^6$），没有按训练长度比例校准——不像 NTK-aware 那样让最低频精确压到 $1/s$。结果：低频维度的相位压缩力度全凭手感。
• 用在哪：CodeLlama 用 $b = 10^6$ 扩到 16K；Llama-3 / Llama-3.1 沿用大 base 加上更精细的 RoPE scaling。

8.2 NoPE — No Position Encoding

Kazemnejad et al. 2023 ("The Impact of Positional Encoding on Length Generalization in Transformers")：decoder-only 模型不加位置编码，仅靠 causal mask 也能学到位置信息。

观察：causal attention 的 mask 已经破坏了交换对称性（位置 $i$ 看不到位置 $j > i$ 的 token），这本身就编码了先后顺序。在小模型 / 短上下文上 NoPE 甚至外推性更好。

§9 MLA — Multi-Head Latent Attention（DeepSeek-V2 May 2024）

9.1 动机

GQA 把 KV cache 从 $2 N_h d_h$ 压到 $2 G d_h$（per-token, per-layer），但 $G$ 至少要 4-8 才能保住质量。能不能压得更狠？ MLA 把 KV cache 压到一个低秩 latent，理论上可以做到 $d_c \ll N_h d_h$ 而几乎不掉点。

9.2 朴素 low-rank K/V — 第一步推导

定义压缩矩阵 $W_\text{DKV} \in \mathbb{R}^{d_c \times d_\text{model}}$，把每个 token 的 hidden state $\mathbf{h}_t \in \mathbb{R}^{d_\text{model}}$ 投影到一个 KV latent：

$$\boxed{\;\mathbf{c}_t^{KV} = W_\text{DKV}\, \mathbf{h}_t \in \mathbb{R}^{d_c}\;}$$

每 head 的 K, V 通过上投影矩阵从这个 latent 恢复：

$$\mathbf{k}_t^{(h)} = W_\text{UK}^{(h)}\, \mathbf{c}_t^{KV}, \qquad \mathbf{v}_t^{(h)} = W_\text{UV}^{(h)}\, \mathbf{c}_t^{KV}$$

其中 $W_\text{UK}^{(h)}, W_\text{UV}^{(h)} \in \mathbb{R}^{d_h \times d_c}$。

关键：cache 只存 $\mathbf{c}_t^{KV}$（$d_c$ 维），不存 $\mathbf{k}, \mathbf{v}$ 本身。Per-token-per-layer cache 从 $2 N_h d_h$ 降到 $d_c$。DeepSeek-V2 选 $d_c = 4 d_h$（vs $N_h d_h = 128 d_h$ for $N_h = 128$），KV cache 压缩 ≈ 50×。

9.3 Absorbing trick — 避免显式上投影

朴素做法：每次 attention 都从 $\mathbf{c}_t^{KV}$ 算出 $\mathbf{k}_t^{(h)} = W_\text{UK}^{(h)} \mathbf{c}_t^{KV}$，再计算 $\mathbf{q}_t^{(h)\top} \mathbf{k}_t^{(h)}$。这等价于：

$$\mathbf{q}_t^{(h)\top} \mathbf{k}_t^{(h)} = \mathbf{q}_t^{(h)\top} (W_\text{UK}^{(h)} \mathbf{c}_t^{KV}) = (W_\text{UK}^{(h)\top} \mathbf{q}_t^{(h)})^\top \mathbf{c}_t^{KV}$$

设 $\tilde{\mathbf{q}}_t^{(h)} := W_\text{UK}^{(h)\top} \mathbf{q}_t^{(h)}$，则 attention 分数变成 $\tilde{\mathbf{q}}_t^{(h)\top} \mathbf{c}_s^{KV}$——直接和 latent cache 做内积，不需要再算 $\mathbf{k}_s^{(h)}$。同理 $W_\text{UV}^{(h)}$ 可以被吸收进 output projection $W_O$ 的左乘。这就是MLA 的 absorbing trick：训练时显式分两步，推理时把上投影矩阵 absorb 进 query/output 投影，实际 cache 读出 → matmul 一次完成。

9.4 为什么 RoPE 必须解耦（最关键的 L3 题）

问题：把 RoPE 加进来会怎样？传统 RoPE 直接乘到 $\mathbf{q}, \mathbf{k}$ 上：

$$\mathbf{q}_t^{(h)} \leftarrow R_t\, \mathbf{q}_t^{(h)}, \qquad \mathbf{k}_t^{(h)} \leftarrow R_t\, \mathbf{k}_t^{(h)} = R_t\, W_\text{UK}^{(h)}\, \mathbf{c}_t^{KV}$$

但 $R_t$ 是位置依赖的——对 cache 中不同 token $t$ 是不同的旋转矩阵。如果还想用 absorbing trick，把 $R_t W_\text{UK}^{(h)}$ 吸进 query 侧，会变成

$$\mathbf{q}_t^{(h)\top} \mathbf{k}_s^{(h)} = \mathbf{q}_t^{(h)\top} (R_s\, W_\text{UK}^{(h)}\, \mathbf{c}_s^{KV})$$

这里 $R_s$ 对每个 cache 位置 $s$ 都不同——没法 absorb 一个固定矩阵进 query 投影。换句话说：

$$(W_\text{UK}^{(h)\top} R_s^\top)\, \mathbf{q}_t^{(h)} \quad \text{中 } R_s \text{ 随 } s \text{ 变}$$

如果非要保留 RoPE 同时做 absorbing，等价于 per-position 的 query 投影，破坏了 absorbing trick 的全部 cache 友好性，cache 必须重新存 RoPE 后的 K（回到 $N_h d_h$ 大小）。

9.5 MLA 的解耦方案 — 共享 RoPE key + 非 RoPE 主体

DeepSeek-V2 的解法：把 K 拆成两段：

1. Non-RoPE 主体：从 latent 上投影得到，大小 $d_h$，参与 absorbing。
2. RoPE 部分：单独一份 key，大小 $d_h^R$（一般 64），所有 head 共享这一份，独立施加 RoPE，不参与 absorbing。

形式化（DeepSeek-V2 论文 Eq. 5-11）：

$$ \begin{aligned} \mathbf{c}_t^{KV} &= W_\text{DKV}\, \mathbf{h}_t \in \mathbb{R}^{d_c} \\ \mathbf{k}_t^{C,(h)} &= W_\text{UK}^{(h)}\, \mathbf{c}_t^{KV} \in \mathbb{R}^{d_h} \quad\text{(non-RoPE 主体, per head)}\\ \mathbf{k}_t^{R} &= \mathrm{RoPE}(W_\text{KR}\, \mathbf{h}_t) \in \mathbb{R}^{d_h^R} \quad\text{(共享 RoPE key, all heads share)}\\ \mathbf{k}_t^{(h)} &= [\mathbf{k}_t^{C,(h)}\; ;\; \mathbf{k}_t^{R}] \in \mathbb{R}^{d_h + d_h^R} \end{aligned} $$

Query 端也类似分成两半：

$$ \begin{aligned} \mathbf{c}_t^{Q} &= W_\text{DQ}\, \mathbf{h}_t \in \mathbb{R}^{d_c'} \\ \mathbf{q}_t^{C,(h)} &= W_\text{UQ}^{(h)}\, \mathbf{c}_t^{Q} \in \mathbb{R}^{d_h} \quad\text{(非 RoPE, 与 } \mathbf{k}_t^{C,(h)} \text{ 配对)}\\ \mathbf{q}_t^{R,(h)} &= \mathrm{RoPE}(W_\text{QR}^{(h)}\, \mathbf{c}_t^{Q}) \in \mathbb{R}^{d_h^R} \quad\text{(per head 的 RoPE query, 与 } \mathbf{k}_t^{R} \text{ 配对)}\\ \mathbf{q}_t^{(h)} &= [\mathbf{q}_t^{C,(h)}\; ;\; \mathbf{q}_t^{R,(h)}] \end{aligned} $$

Attention 分数（同一 head）：

$$\mathbf{q}_t^{(h)\top} \mathbf{k}_s^{(h)} = \underbrace{\mathbf{q}_t^{C,(h)\top}\, \mathbf{k}_s^{C,(h)}}_{\text{absorb 进 q 投影}} + \underbrace{\mathbf{q}_t^{R,(h)\top}\, \mathbf{k}_s^{R}}_{\text{RoPE 部分, 直接算}}$$

第一项中 $\mathbf{k}_s^{C,(h)} = W_\text{UK}^{(h)} \mathbf{c}_s^{KV}$，按 §9.3 absorbing trick 把 $W_\text{UK}^{(h)}$ 吸进 query 侧。第二项 RoPE key 所有 head 共享，cache 只存一份 $\mathbf{k}_s^R$。

9.6 MLA KV cache 总大小

Per token per layer：

$$\boxed{\;\text{MLA cache} = \underbrace{d_c}_{\mathbf{c}^{KV}} + \underbrace{d_h^R}_{\mathbf{k}^R} \quad \text{vs} \quad \text{MHA cache} = 2 N_h d_h\;}$$

DeepSeek-V2 数值（$N_h = 128, d_h = 128, d_c = 512, d_h^R = 64$）：

• MHA: $2 \cdot 128 \cdot 128 = 32{,}768$ 元素 / token / layer
• MLA: $512 + 64 = 576$ 元素 / token / layer
• 压缩比 57×（vs MHA），同时 KV cache 总比 GQA-8 还小约 4×。

9.7 MLA 简化代码

import torch
import torch.nn as nn
# 复用 §2.4 的 apply_rope 函数 (略).

class MultiHeadLatentAttention(nn.Module):
    """
    简化 MLA: 训练版 (推理可加 absorbing trick).
    Per token per layer cache: c_kv [d_c] + k_R [d_h_R]
    """
    def __init__(self, d_model: int, n_heads: int,
                 d_c: int = 512, d_h: int = 128, d_h_R: int = 64,
                 d_c_q: int = 1536):
        super().__init__()
        self.n_heads, self.d_h, self.d_h_R = n_heads, d_h, d_h_R

        # Down-projection 到 latent
        self.W_DKV = nn.Linear(d_model, d_c,  bias=False)
        self.W_DQ  = nn.Linear(d_model, d_c_q, bias=False)

        # Up-projection (non-RoPE 主体)
        self.W_UK = nn.Linear(d_c,   n_heads * d_h,   bias=False)
        self.W_UV = nn.Linear(d_c,   n_heads * d_h,   bias=False)
        self.W_UQ = nn.Linear(d_c_q, n_heads * d_h,   bias=False)

        # RoPE 解耦部分
        self.W_KR = nn.Linear(d_model, d_h_R,            bias=False)  # 共享 across heads
        self.W_QR = nn.Linear(d_c_q,   n_heads * d_h_R,  bias=False)  # per head

        self.W_O  = nn.Linear(n_heads * d_h, d_model, bias=False)

    def forward(self, h: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor,
                mask: torch.Tensor = None):
        # h: [B, L, d_model]; cos/sin for RoPE: [L, d_h_R/2]
        B, L, _ = h.shape
        H, dH, dHR = self.n_heads, self.d_h, self.d_h_R

        # ----- KV path -----
        c_kv = self.W_DKV(h)                                              # [B, L, d_c]
        k_C  = self.W_UK(c_kv).view(B, L, H, dH).transpose(1, 2)          # [B, H, L, d_h]
        v    = self.W_UV(c_kv).view(B, L, H, dH).transpose(1, 2)          # [B, H, L, d_h]

        k_R  = self.W_KR(h)                                                # [B, L, d_h_R]  (shared)
        k_R  = apply_rope(k_R, cos, sin)                                   # 共享 RoPE
        # broadcast 到 H 个 head 上做 concat
        k_R_per_head = k_R.unsqueeze(1).expand(B, H, L, dHR)                # [B, H, L, d_h_R]
        k = torch.cat([k_C, k_R_per_head], dim=-1)                          # [B, H, L, d_h+d_h_R]

        # ----- Q path -----
        c_q  = self.W_DQ(h)                                                 # [B, L, d_c_q]
        q_C  = self.W_UQ(c_q).view(B, L, H, dH).transpose(1, 2)             # [B, H, L, d_h]
        q_R  = self.W_QR(c_q).view(B, L, H, dHR).transpose(1, 2)            # [B, H, L, d_h_R]
        q_R  = apply_rope(q_R, cos, sin)                                    # per-head RoPE
        q = torch.cat([q_C, q_R], dim=-1)                                   # [B, H, L, d_h+d_h_R]

        # ----- Attention -----
        scores = (q @ k.transpose(-2, -1)) / ((dH + dHR) ** 0.5)
        if mask is not None:
            scores = scores.masked_fill(~mask, float("-inf"))
        attn = torch.softmax(scores, dim=-1)
        out  = (attn @ v).transpose(1, 2).contiguous().view(B, L, H * dH)   # [B, L, H*d_h]
        return self.W_O(out)                                                # [B, L, d_model]

9.8 训练成本

MLA 引入额外的下投影 / 上投影，训练 FLOPs 略增（DeepSeek-V2 报告 ≈ 2% 增加），换来推理时 KV cache 砍数十倍——属于"训练贵一点，推理便宜很多"的取舍。

§10 滑动窗口与流式注意力

10.1 Sliding Window Attention (Mistral 2023)

每个 query 只看前 $W$ 个 key（$W$ = window size，Mistral-7B 用 $W = 4096$）。

• 复杂度：从 $O(L^2 d)$ 降到 $O(L W d)$，长序列线性。
• 多层叠加感受野扩展：第 1 层看 $W$，第 2 层每个位置看前 $W$（其中每个 token 又看了它的前 $W$），有效感受野 $2W$；$\ell$ 层后感受野 $\ell W$。所以 32 层 × 4096 window ≈ 131K 有效感受野。

def sliding_window_mask(L: int, W: int, device=None) -> torch.Tensor:
    """
    L: sequence length; W: window size (含 self)
    返回 [L, L] bool mask, True=可见.
    位置 i 可看 j ∈ [max(0, i-W+1), i] (causal + sliding window)
    """
    idx_q = torch.arange(L, device=device).unsqueeze(1)   # [L, 1]
    idx_k = torch.arange(L, device=device).unsqueeze(0)   # [1, L]
    causal     = idx_k <= idx_q
    in_window  = idx_k > (idx_q - W)
    return causal & in_window

# 示例 L=8, W=4:
# row 0: [T F F F F F F F]
# row 1: [T T F F F F F F]
# row 2: [T T T F F F F F]
# row 3: [T T T T F F F F]
# row 4: [F T T T T F F F]    ← 0 号被推出 window
# row 5: [F F T T T T F F]
# row 6: [F F F T T T T F]
# row 7: [F F F F T T T T]

10.2 StreamingLLM — Attention Sink + Sliding Window

Xiao et al. ICLR 2024 ("Efficient Streaming Language Models with Attention Sinks") 提出推理时一个关键发现：

LLM decode 时，softmax 强制 attention 权重和为 1，但 query 实际可能"什么也不想 attend"。模型于是把权重大量倒给前 1-4 个 token（特别是 <bos>），形成 attention sink。 这些 token 内容上没什么信息，但它们的 KV cache 不能丢弃——丢了之后 softmax 没有"垃圾桶"，剩下 token 的注意力分布被强行重整，PPL 爆炸。

StreamingLLM 推理策略：

1. 永远保留 前 $S$ 个 token 的 KV cache（$S = 4$ 经验值）作为 sink。
2. 滑动窗口 保留最近 $W$ 个 token 的 KV cache。
3. window 之外、sink 之外的 token，直接丢弃 KV。

总 KV cache 大小为 $S + W$，与序列长度 $L$ 解耦，达到真正的流式生成。

10.3 StreamingLLM 推理循环代码

下面是 教学示意版，重点展示控制流。生产实现（HuggingFace streaming_llm / 原作者 streaming-llm repo）有两个关键细节，下面注释里说明。

@torch.no_grad()
def streaming_decode(model, input_ids, max_new_tokens,
                     sink_size=4, window_size=2044):
    """
    教学版 streaming inference: sink 区 + sliding window.
    总 cache = sink_size + window_size, 与生成长度无关.

    关键细节 (生产代码必须做):
    (a) Cache 存的是 *RoPE 之前* 的 K (即 W_K @ h, 未旋转), 同时记录该 token 的"逻辑位置".
        每次 forward 时, 根据当前 cache 中各 token 的*新* 逻辑位置, 对 sink / recent K 重新施加 RoPE.
        否则裁剪 + 位置漂移会让 cache 中的旋转角对不上新的逻辑位置.
    (b) Sink 区位置永远固定在 [0, S), recent window 位置永远固定在 [S, S+W),
        新 token 用 S+W (即 cache 容量上限) 作为它的逻辑位置.
        这样模型见到的"最大相对位置"始终 ≤ S+W, 永远不会触碰 RoPE 训练上限.
    """
    device = input_ids.device
    B = input_ids.size(0)
    total = sink_size + window_size

    # ----- 1) Prefill -----
    # past_kv_pre[i] = (k_pre, v) 其中 k_pre = W_K @ h, 未做 RoPE
    past_kv_pre = _prefill_unrotated(model, input_ids)            # 实现细节略

    # 若 prompt 已超 sink+window, 裁剪 (sink 段 + 最近 window 段)
    def trim_unrotated(past_kv_pre):
        new_past = []
        for (k_pre, v) in past_kv_pre:
            if k_pre.size(-2) <= total:
                new_past.append((k_pre, v));  continue
            sink = (k_pre[..., :sink_size, :], v[..., :sink_size, :])
            recent = (k_pre[..., -window_size:, :], v[..., -window_size:, :])
            new_past.append(
                (torch.cat([sink[0], recent[0]], dim=-2),
                 torch.cat([sink[1], recent[1]], dim=-2))
            )
        return new_past

    past_kv_pre = trim_unrotated(past_kv_pre)
    # logits 来自 prefill 最后一步
    next_token = _last_logits(model, past_kv_pre).argmax(-1, keepdim=True)
    generated = [next_token]

    # ----- 2) Autoregressive decode -----
    for step in range(max_new_tokens - 1):
        cur_len = past_kv_pre[0][0].size(-2)                       # 当前 cache 中 token 数
        # 给 cache 中每个 token 分配"逻辑位置"; 注意 prompt 极短时 cur_len < sink_size,
        # 此时所有 token 都视为 sink (没有 recent window).
        if cur_len <= sink_size:
            cache_pos = torch.arange(cur_len, device=device)        # [cur_len]
        else:
            cache_pos = torch.cat([
                torch.arange(sink_size, device=device),             # sink 段: [0..S)
                torch.arange(sink_size, cur_len, device=device),    # window 段: [S..cur_len)
            ])                                                       # 长度 = cur_len
        new_pos = torch.tensor([cur_len], device=device)             # 新 token 逻辑位置

        # 对 cache 中的 K_pre 重新施加 RoPE (按 cache_pos), 对新 token 按 new_pos.
        out = model(next_token, past_kv_pre=past_kv_pre,
                    cache_pos=cache_pos, new_pos=new_pos, use_cache=True)
        past_kv_pre = trim_unrotated(out.past_kv_pre)
        next_token = out.logits[:, -1].argmax(-1, keepdim=True)
        generated.append(next_token)

    return torch.cat(generated, dim=-1)

10.4 Lost-in-the-Middle (Liu 2023)

Liu et al. 2023 ("Lost in the Middle: How Language Models Use Long Contexts") 经验观察：长上下文模型对 prompt 头部和尾部的关注度远高于中间，造成"中间内容更难被检索到"。

• U-shaped curve：把 key info 放在 prompt 不同位置，检索准确率随位置呈 U 形（首尾高，中间低）。
• 原因：causal LM 训练分布中，第一个 token 影响最广（attention sink 同源问题）；最后一个 token 是 next-token 预测的直接前驱。中间内容被两端"挤压"。
• 缓解：(a) 把重要信息放在 prompt 开头或结尾；(b) Recurrent retrieval (chain prompts)；(c) 训练时增加中段权重 (位置感知 loss weighting)。

§11 System 级长上下文 — Ring / CP / FlashAttn

11.1 Ring Attention (Liu et al. 2023)

把序列在 $P$ 张 GPU 上切成 $P$ 段，每段独立持有自己的 Q/K/V chunk。Attention 通过 K/V chunk 在 GPU 间环形传递 实现：

GPU 0: 持 Q0, K0, V0  ←→  GPU 1: 持 Q1, K1, V1  ←→  ...  ←→  GPU P-1
            │                       │
            └─ pass K1, V1 to GPU 0, 同时 GPU 0 把 K0, V0 传给 GPU P-1
            (环形 P-1 次后, 每个 GPU 都看过所有 K, V)

• 每个 GPU 在每一轮用自己当前持有的 K/V 段，对本地 Q 段做局部 attention，累加 partial output。
• 通信与计算 overlap（下一段 K/V 在传时，本段 attention 在算）。
• 总通信量 $O(L \cdot d)$ per GPU（每个 GPU 收发 $P-1$ 次 chunk）；总计算 $O(L^2 d / P)$ per GPU。

关键效果：单 GPU 显存只需放 $L/P$ 的 K/V，有效上下文随 GPU 数线性扩展——理论上 8 GPU × 128K 单卡 = 1M 上下文。

11.2 Context Parallelism (Megatron 2024)

Megatron-Core 的 Context Parallel (CP) 是 Ring Attention 的工程化版本，集成进现有 tensor/pipeline parallelism。主要工程点：

• 配合 FlashAttention 块化做 fused all-to-all 通信
• 解决 causal mask 下 chunk 间负载不均（前半 chunk attention 计算少、后半多，需要负载均衡）
• 与 ZeRO-3 兼容

11.3 FlashAttention 2/3 与长上下文

FlashAttention v1 (Dao 2022) 的核心是 IO-aware exact attention，但 v1 的循环结构对长序列负载不均。

• v2 (Dao 2023)：换内外循环 (Q-outer, KV-inner)，更好 warp-level parallelism，长序列吞吐提升 2×。
• v3 (Dao 2024)：针对 H100，使用 WGMMA / TMA / FP8 asynchronous pipeline。

长上下文场景下，FlashAttention 是几乎所有训练 / 推理 stack 的默认（避免物化 $L \times L$ 分数矩阵）。

11.4 Differential Attention（可选，Microsoft 2024）

Ye et al. 2024 ("Differential Transformer") 提出每个 attention head 用两个独立 Q/K 投影做差：

$$\mathrm{Diff} = \mathrm{softmax}(Q_1 K_1^\top / \sqrt{d}) - \lambda \cdot \mathrm{softmax}(Q_2 K_2^\top / \sqrt{d})$$

• 直觉：第一项学"信号"，第二项学"噪声"，差值更尖锐。
• 效果：长上下文 needle-in-haystack 任务上比 vanilla attention 提升明显。
• 代价：每 head 多一组 Q/K 投影（参数和计算 + 50%）。

§12 复杂度与显存总表

12.1 KV cache per-token-per-layer 大小（attention 变体）

12.2 KV cache 总占用（per-sample-per-layer，受到 SWA / Streaming 等"窗口"机制影响）

注：SWA / Streaming 与 GQA / MLA 是正交的——两者乘起来即得到工业级 stack 的实际 cache 大小。

12.3 Attention 时间与显存

§13 综合对比与选型决策树

Q: 我要把上下文从 4K 推到 N tokens, N=?
│
├── N ≤ 16K, zero-shot, 不能 fine-tune
│    └── NTK-aware (1 行配置, base 改大)
│
├── N ≤ 32K, 可少量 fine-tune (~1000 步)
│    └── PI (简单稳定) or YaRN (更好)
│
├── 32K < N ≤ 128K, fine-tune 预算 < 500 步
│    └── YaRN (NTK-by-parts + temperature)
│
├── N > 128K (256K-2M)
│    └── LongRoPE (每维独立搜索 + short-context rescue)
│
└── 流式生成 (无限长度, 不需要远端检索)
     └── StreamingLLM (sink + sliding window)

Q: KV cache 显存压不住?
│
├── 想保住质量, 适度压
│    └── GQA (LLaMA-2/3, Mistral)
│
├── 想极致压, 接受重训练
│    └── MLA (DeepSeek-V2/V3): cache 砍 50×, RoPE 必须解耦
│
└── 推理 server 端
     └── 配合 PagedAttention (vLLM) 做 cache 分页管理

Q: Attention 算不动 (L^2 太大)?
│
├── 单卡推理
│    └── FlashAttention 2/3 (exact, 必装)
│
├── 多卡训练 / 推理
│    └── Ring Attention / Context Parallelism (chunk K/V 环传)
│
└── 不要远距精确检索, 只要本地依赖
     └── Sliding Window Attention (Mistral 风格)

§14 25 高频面试题

按难度分 L1（必会）/ L2（进阶）/ L3（顶级 lab）三档。每题展开看答案要点和易踩坑。

L1 必会题（任何长上下文相关岗位都问）

L2 进阶题（research-oriented 岗位）

L3 顶级 lab 难题（DeepSeek / Anthropic / OpenAI / Google 系）

§A 附录：实现要点 checklist

A.1 RoPE 工程实现要点

• pairing 一致性：奇偶交错 vs 前半/后半，必须和 cache 预计算保持一致
• half-dim 注意：cos/sin cache shape 是 $[L, d/2]$，应用时要 broadcast 到 $[L, d]$ 或在两半上分别乘
• dtype 处理：cos/sin 用 fp32 计算后转 dtype，避免 fp16/bf16 下旋转角累积误差
• YaRN 时：cos/sin cache 已经乘了 $1/\sqrt{t}$，attention 内部不要再缩放
• MLA 时：query / key 的 RoPE 部分和 non-RoPE 部分要 concat（一般 RoPE 在后），attention scale 用 $\sqrt{d_h + d_h^R}$ 而不是 $\sqrt{d_h}$

A.2 Long Context fine-tune 关键超参（YaRN 经验）

• 训练 token 数：≈ 1 B tokens（≈ 400-1000 步）即可显著改善 PPL
• 数据：必须含真实长上下文（books / arxiv / code repos），不能只用拼接的短文档
• 学习率：通常 $1\times 10^{-5}$ 到 $5\times 10^{-5}$，比 pretrain 小一个量级
• 不冻：所有层都参与 fine-tune；冻 attention 层效果显著更差
• Eval：PPL 在长上下文上、Needle-in-Haystack 检索准确率

A.3 StreamingLLM 部署 checklist

• Sink size $S = 4$ 经验最优（前 4 个 token）
• Window size $W$ 选择：吞吐 vs 质量权衡，常用 $W \in [1024, 4096]$
• Position ID 必须用逻辑位置而非绝对位置
• 与 RoPE / YaRN 兼容；按 §10.3 的做法 cache 应存 RoPE 之前 的 K，每次 forward 根据 sink / window 内 token 的当前逻辑位置重新施加 RoPE（部分 vendor 实现会把 sink 段当作"固定旋转 + 平移 attention key 索引"等价处理，效果近似）

A.4 速查表

Long Context Quick Reference · 主要参考：Su et al. 2021/2024 (RoPE/RoFormer, Neurocomputing), Chen et al. 2023 (PI, arXiv:2306.15595, Meta), bloc97 / jquesnelle 2023 (NTK-aware, LocalLLaMA community), Peng et al. 2023 (YaRN, arXiv:2309.00071), Ding et al. 2024 (LongRoPE, ICML 2024, Microsoft), DeepSeek-AI 2024 (DeepSeek-V2, arXiv:2405.04434), Jiang et al. 2023 (Mistral 7B, arXiv:2310.06825), Xiao et al. 2024 (StreamingLLM, ICLR 2024), Nelson F. Liu et al. 2023 (Lost in the Middle, arXiv:2307.03172, TACL), Hao Liu et al. 2023 (Ring Attention, arXiv:2310.01889), Dao et al. 2022-2024 (FlashAttention 1/2/3)