[{"content":" 本文假设读者熟悉线性代数（矩阵乘法、外积、逆矩阵）和基本的序列模型概念，建议先阅读 KDA 数学原理。\n摘要 本文推导了 DPLR（Diagonal Plus Low Rank） 的 chunk-wise 并行算法。DPLR 是广义 Delta Rule 的重要变体，被应用于 RWKV-7 等架构中。核心贡献：\n建立 DPLR 的显式转移矩阵形式：$\\mathbf{P}_t = \\text{diag}(\\exp(\\mathbf{g}_t)) + \\mathbf{b}_t \\mathbf{a}_t^T$ 推导 DPLR 的 WY 表示，将累积转移矩阵分解为对角部分与低秩部分之和 证明 DPLR 同样满足 Affine 变换形式，天然支持 CP 并行 对比 DPLR、KDA、IPLR 的异同，揭示线性注意力家族的统一数学框架 DPLR 相比标准 Delta Rule 的优势：显式控制对角衰减（dim-wise forgetting）和低秩更新，表达力更强，但在 chunk 形式下显著的引入了额外的计算复杂度，需要更多的 HBM 空间来存储中间变量。\n目录 引言：从 Delta Rule 到 DPLR 符号表与约定 核心引理 DPLR 的递推形式 WY 表示：累积转移矩阵的分解 核心定理：Chunk-wise Affine 形式 算法实现：从理论到代码 DPLR vs KDA vs IPLR CP 并行与多级并行 总结 引言：从 Delta Rule 到 DPLR Delta Rule 的局限性 标准 Delta Rule（以及没有遗忘门的 GDN/KDA）的状态更新可以写成：\n$$\\mathbf{s}_t = \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^T (\\mathbf{v}_t - \\mathbf{k}_t \\mathbf{s}_{t-1})$$这种形式的转移矩阵是隐式的：\n通过残差 $(\\mathbf{v}_t - \\mathbf{k}_t \\mathbf{s}_{t-1})$ 间接影响状态更新 遗忘机制通过门控 $\\boldsymbol{\\lambda}_t$ 实现 从数学上看，这等价于：\n$$\\mathbf{s}_t = (\\mathbf{I} - \\beta_t \\mathbf{k}_t^T \\mathbf{k}_t)\\mathbf{s}_{t-1} + \\beta_t \\mathbf{k}_t^T \\mathbf{v}_t$$转移矩阵 $\\mathbf{I} - \\beta_t \\mathbf{k}_t^T \\mathbf{k}_t$ 是单位矩阵 + 低秩（rank-1）的形式，即IPLR（Identity Plus Low Rank）结构。\nDPLR 的核心思想 DPLR（Diagonal Plus Low Rank） 采用显式的转移矩阵形式：\n$$\\mathbf{S}_t = \\exp(\\mathbf{g}_t) \\odot \\mathbf{S}_{t-1} + \\mathbf{k}_t^T \\mathbf{v}_t + \\mathbf{b}_t (\\mathbf{a}_t^T \\mathbf{S}_{t-1})$$或者更紧凑地写成：\n$$\\mathbf{S}_t = (\\mathbf{D}_t + \\mathbf{b}_t \\mathbf{a}_t^T) \\mathbf{S}_{t-1} + \\mathbf{k}_t^T\\mathbf{v}_t$$其中：\n$\\mathbf{D}_t = \\text{diag}(\\exp(\\mathbf{g}_t)) \\in \\mathbb{R}^{K \\times K}$ 是对角衰减矩阵 $\\mathbf{a}_t, \\mathbf{b}_t \\in \\mathbb{R}^{K \\times 1}$（列向量）是低秩更新的两个向量 转移矩阵 $\\mathbf{P}_t = \\mathbf{D}_t + \\mathbf{b}_t \\mathbf{a}_t^T$ 是**对角+低秩（DPLR）**结构 为什么叫 \u0026ldquo;Diagonal Plus Low Rank\u0026rdquo;？ 矩阵 $\\mathbf{P}_t = \\mathbf{D}_t + \\mathbf{b}_t \\mathbf{a}_t^T$ 的结构：\n对角部分 $\\mathbf{D}_t$：控制每个维度的独立衰减 低秩部分 $\\mathbf{b}_t \\mathbf{a}_t^T$：秩为 1 的更新，提供跨维度的耦合 这种结构在数值线性代数中有深入研究，特别适合快速矩阵-向量乘法。\n与 RWKV-7 的关系 RWKV-7 采用了基于 DPLR 思想的动态状态演化（Dynamic State Evolution）架构。在我们的底层并行实现中，RWKV-7 的状态更新公式实际上是 DPLR 框架的一个具体实例化：\n传统线性注意力试图直接拟合 $\\{k, v\\}$ 对，而 RWKV-7 在 L2 loss $L=\\frac{1}{2} \\left\\Vert v - S k \\right\\Vert^2$ 的指导下，通过模拟动态梯度下降来更新状态 $S$。其理论更新公式为：\n$$S_t = S_{t-1} \\text{Diag}(d_t) - \\eta_t \\cdot S_{t-1} k_t k_t^{\\top} + \\eta_t \\cdot v_t k_t^{\\top}$$在算法实现中，这个基于梯度的更新被泛化为更灵活的 DPLR 形式：\n$$S_t = S_{t-1} \\odot \\exp(-e^{w_t}) + (S_{t-1} a_t) b_t^T + v_t k_t^T$$对应到我们在并行系统中的参数映射为：\n$w_t$ 对应对数衰减项（具体为 $-\\exp(w_t)$） $a_t$ 对应低秩更新向量 $a$（动态学习率调节器 / in-context learning rate） $b_t$ 对应低秩更新向量 $b$（状态更新调节器） 这使得 RWKV-7 ：\n动态的衰减与学习率：$w_t, a_t, b_t$ 都是 data-dependent 的，允许模型根据上下文动态决定遗忘和更新的强度。 表达能力有所提升：由于引入了显式的状态演化，RWKV-7 能够识别所有正则语言（regular languages），其理论表达能力超越了 TC0 的 Transformer，达到了 NC1。 无缝接入 DPLR Chunk 并行：由于其本质是 DPLR 结构，RWKV-7 可以直接复用 DPLR 的 chunk-wise 算法来实现高效的长序列并行训练。 符号表与约定 符号 维度 含义 $\\mathbf{s}_t$ $\\mathbb{R}^{K \\times V}$ token-level 状态矩阵 $\\mathbf{S}$ $\\mathbb{R}^{K \\times V}$ chunk-level 初始状态 $\\mathbf{S}'$ $\\mathbb{R}^{K \\times V}$ chunk-level 结束状态 $\\mathbf{k}_t, \\mathbf{q}_t$ $\\mathbb{R}^{1 \\times K}$（行向量） token-level key/query $\\mathbf{v}_t$ $\\mathbb{R}^{1 \\times V}$（行向量） token-level value $\\mathbf{a}_t, \\mathbf{b}_t$ $\\mathbb{R}^{K \\times 1}$（列向量） 低秩更新的两个向量 $\\mathbf{K}, \\mathbf{V}$ $\\mathbb{R}^{C \\times K}$ / $\\mathbb{R}^{C \\times V}$ chunk-level key/value 矩阵，第 $i$ 行为 $\\mathbf{k}_i$ / $\\mathbf{v}_i$ $\\mathbf{A}^{\\text{lr}} \\in \\mathbb{R}^{C \\times K}$ 第 $i$ 行为 $\\mathbf{a}_i^T$ 低秩向量 $\\mathbf{a}$ 的矩阵形式（列向量转行排列） $\\mathbf{B}^{\\text{lr}} \\in \\mathbb{R}^{C \\times K}$ 第 $i$ 行为 $\\mathbf{b}_i^T$ 低秩向量 $\\mathbf{b}$ 的矩阵形式（列向量转行排列） $\\mathbf{g}_t$ $\\mathbb{R}^{K}$ log decay 向量（累积前） $\\mathbf{g}_t^{\\text{cum}}$ $\\mathbb{R}^{K}$ 累积 log decay（cumsum 后） $\\mathbf{D}_t = \\text{diag}(\\exp(\\mathbf{g}_t^{\\text{cum}}))$ $\\mathbb{R}^{K \\times K}$ 对角衰减矩阵 $\\boldsymbol{\\Gamma}_i^t = \\prod_{j=i}^t \\mathbf{D}_j$ $\\mathbb{R}^{K \\times K}$ 累积对角衰减矩阵 $\\mathbf{P}_t = \\mathbf{D}_t + \\mathbf{b}_t \\mathbf{a}_t^T$ $\\mathbb{R}^{K \\times K}$ 转移矩阵（低秩外积形式） $\\mathbf{A}_{ab}, \\mathbf{A}_{ak}$ $\\mathbb{R}^{C \\times C}$ 严格下三角注意力矩阵 $\\mathbf{W}, \\mathbf{U}$ $\\mathbb{R}^{C \\times K}$ / $\\mathbb{R}^{C \\times V}$ WY 表示的加权矩阵 $\\mathbf{w}_i, \\mathbf{u}_i$ $\\mathbb{R}^{K}$ / $\\mathbb{R}^{V}$ WY 表示的加权向量（第 $i$ 个分量） $\\tilde{\\mathbf{u}}_i$ $\\mathbb{R}^{V}$ 包含历史状态贡献的修正向量 $\\mathbf{M}$ $\\mathbb{R}^{K \\times K}$ Affine transition 矩阵 $\\mathbf{B}$ $\\mathbb{R}^{K \\times V}$ Affine bias 矩阵 $\\odot$ - Hadamard 积（逐元素乘） 重要约定：\nDPLR 在 flash-linear-attention 的实现中采用左乘形式：$\\mathbf{S}_t = \\mathbf{P}_t \\mathbf{S}_{t-1} + \\mathbf{k}_t^T \\mathbf{v}_t$ 状态矩阵 $\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$（key dim × value dim） 注：原生的 RWKV-7 公式是其对偶的右乘形式，状态矩阵为 $\\mathbf{S}_{\\text{rwkv}} \\in \\mathbb{R}^{V \\times K}$，更新公式为 $\\mathbf{S}_t = \\mathbf{S}_{t-1} \\mathbf{P}_t^T + \\mathbf{v}_t \\mathbf{k}_t^T$。在 FLA 框架中，为了与 KDA 等其他线性注意力机制保持统一，我们对状态矩阵进行了转置，统一采用左乘形式。\n与 KDA 的对比：\n特性 KDA DPLR (FLA 实现) RWKV-7 原生 乘法方向 左乘 左乘 右乘 状态维度 $\\mathbb{R}^{K \\times V}$ $\\mathbb{R}^{K \\times V}$ $\\mathbb{R}^{V \\times K}$ Affine 形式 $\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$ $\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$ $\\mathbf{S}' = \\mathbf{S}\\mathbf{M}^T + \\mathbf{B}^T$ 转移矩阵 隐式（Delta Rule） 显式（DPLR） 核心引理 引理 1：下三角矩阵的逆 设 $\\mathbf{L} \\in \\mathbb{R}^{C \\times C}$ 是单位下三角矩阵（对角线为 1，上三角为 0），则 $\\mathbf{L}^{-1}$ 也是单位下三角矩阵，且可以通过前向替换计算。\n特别地，若 $\\mathbf{L} = \\mathbf{I} - \\mathbf{N}$，其中 $\\mathbf{N}$ 是严格下三角矩阵（对角线为 0），则\n$$\\mathbf{L}^{-1} = \\mathbf{I} + \\mathbf{N} + \\mathbf{N}^2 + \\cdots + \\mathbf{N}^{C-1}$$证明：直接验证 $(\\mathbf{I} - \\mathbf{N})(\\mathbf{I} + \\mathbf{N} + \\cdots + \\mathbf{N}^{C-1}) = \\mathbf{I} - \\mathbf{N}^C = \\mathbf{I}$（因为 $\\mathbf{N}^C = 0$）。\n引理 2：DPLR 矩阵的乘积结构 设 $\\mathbf{P}_i = \\mathbf{D}_i + \\mathbf{b}_i \\mathbf{a}_i^T$，其中 $\\mathbf{D}_i$ 是对角矩阵。则反向累积乘积 $\\mathbf{P}_{t:1} = \\prod_{i=t}^1 \\mathbf{P}_i = \\mathbf{P}_t \\mathbf{P}_{t-1} \\cdots \\mathbf{P}_1$ 可以表示为：\n$$\\mathbf{P}_{t:1} = \\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot (\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_1^{i-1})$$注意乘积方向：这里的乘积是从右到左累乘（$\\mathbf{P}_t$ 在最左边），与状态递推 $\\mathbf{S}_t = \\mathbf{P}_t \\mathbf{S}_{t-1} + \\mathbf{k}_t^T \\mathbf{v}_t$ 展开后的形式一致。在展开后的求和项中，$\\boldsymbol{\\Gamma}_{i+1}^t$ 是 $\\mathbf{b}_i$ 左侧的累积衰减（从 $i+1$ 到 $t$），$\\boldsymbol{\\Gamma}_1^{i-1}$ 是 $\\mathbf{a}_i^T$ 右侧的累积衰减（从 $1$ 到 $i-1$）。\n意义：这个引理保证了 DPLR 结构在矩阵乘法下的封闭性，是 WY 表示存在的基础。具体形式表明累积乘积保持\u0026quot;对角+低秩\u0026quot;的结构。\n引理 3：对数衰减的分解 对于累积对数衰减，有：\n$$\\exp(\\mathbf{g}_i^{\\text{cum}} - \\mathbf{g}_j^{\\text{cum}}) = \\exp(\\mathbf{g}_i^{\\text{cum}}) \\odot \\exp(-\\mathbf{g}_j^{\\text{cum}})$$这使得衰减计算可以表示为两个门控向量的外积形式。\nDPLR 的递推形式 基本递推 DPLR 的状态更新方程为：\n$$\\mathbf{S}_t = \\exp(\\mathbf{g}_t) \\odot \\mathbf{S}_{t-1} + \\mathbf{k}_t^T \\mathbf{v}_t + \\mathbf{b}_t (\\mathbf{a}_t^T \\mathbf{S}_{t-1})$$或写成矩阵形式：\n$$\\mathbf{S}_t = (\\mathbf{D}_t + \\mathbf{b}_t \\mathbf{a}_t^T) \\mathbf{S}_{t-1} + \\mathbf{k}_t^T \\mathbf{v}_t$$其中：\n第一项 $\\mathbf{S}_{t-1} \\odot \\exp(\\mathbf{g}_t)$：维度级衰减（Hadamard 积形式） 第二项 $\\mathbf{k}_t^T \\mathbf{v}_t$：标准的 key-value 外积更新 第三项 $\\mathbf{b}_t (\\mathbf{a}_t^T \\mathbf{S}_{t-1})$：低秩更新，通过 $\\mathbf{a}_t^T$ 投影状态（得到 $1 \\times V$），再通过 $\\mathbf{b}_t$ 扩展（得到 $K \\times V$） 展开递推 为了理解 chunk-wise 并行，我们先展开前几个时间步：\n$$ \\begin{aligned} \\mathbf{S}_1 \u0026= \\mathbf{P}_1 \\mathbf{S}_0 + \\mathbf{k}_1^T \\mathbf{v}_1 \\\\ \\mathbf{S}_2 \u0026= \\mathbf{P}_2 \\mathbf{S}_1 + \\mathbf{k}_2^T \\mathbf{v}_2 \\\\ \u0026= \\mathbf{P}_2 (\\mathbf{P}_1 \\mathbf{S}_0 + \\mathbf{k}_1^T \\mathbf{v}_1) + \\mathbf{k}_2^T \\mathbf{v}_2 \\\\ \u0026= \\mathbf{P}_2 \\mathbf{P}_1 \\mathbf{S}_0 + \\mathbf{P}_2 \\mathbf{k}_1^T \\mathbf{v}_1 + \\mathbf{k}_2^T \\mathbf{v}_2 \\end{aligned} $$一般形式： $$\\mathbf{S}_t = \\left( \\prod_{i=t}^1 \\mathbf{P}_i \\right) \\mathbf{S}_0 + \\sum_{i=1}^t \\left( \\prod_{j=t}^{i+1} \\mathbf{P}_j \\right) \\mathbf{k}_i^T \\mathbf{v}_i$$挑战：直接计算累积转移矩阵 $\\mathbf{P}_{t:1} = \\prod_{i=t}^1 \\mathbf{P}_i$ 需要 $O(t)$ 的矩阵乘法，如何实现并行？\nWY 表示：累积转移矩阵的分解 核心问题 我们需要高效地表示累积转移矩阵的乘积（注意左乘顺序，从右到左累乘）： $$\\mathbf{P}_{t:1} = \\prod_{i=t}^1 (\\mathbf{D}_i + \\mathbf{b}_i \\mathbf{a}_i^T)$$关键洞察：对角+低秩矩阵的乘积仍然保持\u0026quot;对角+低秩\u0026quot;的结构，可以分解为对角累积加上加权的低秩外积之和。\n定义累积对角衰减 令： $$\\boldsymbol{\\Gamma}_i^t = \\prod_{j=i}^t \\mathbf{D}_j = \\text{diag}\\left(\\exp\\left(\\sum_{j=i}^t \\mathbf{g}_j\\right)\\right)$$当 $i \u003e t$ 时，定义 $\\boldsymbol{\\Gamma}_i^t = \\mathbf{I}$（单位矩阵）。\n定理（DPLR 的 WY 表示） 累积转移矩阵可以分解为：\n$$\\mathbf{P}_{t:1} = \\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot (\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_1^{i-1})$$ 定义动机：为了使 WY 表示更紧凑，我们定义加权向量 $\\mathbf{w}_i^T$（行向量），它将历史所有低秩更新的影响累积到第 $i$ 步。这类似于经典 WY 表示中累积 Householder 变换的权重。\n或等价地，定义 $\\mathbf{w}_i^T = \\mathbf{a}_i^T \\boldsymbol{\\Gamma}_1^{i-1} + \\sum_{j=1}^{i-1} (\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{b}_j) \\cdot \\mathbf{w}_j^T$：\n$$\\mathbf{P}_{t:1} = \\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T$$其中系数 $(\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{b}_j)$ 是标量。\n与经典 WY 表示的联系：经典 WY 表示将 Householder 矩阵的乘积分解为 $\\mathbf{Q} = \\mathbf{I} - \\mathbf{W}\\mathbf{Y}^T$。DPLR 的 WY 表示是其推广：以 $\\boldsymbol{\\Gamma}_1^t$（对角累积）替代 $\\mathbf{I}$，以加权的低秩和替代标准低秩外积。\n证明（归纳法） 基例 $t=1$： $$\\mathbf{P}_1 = \\mathbf{D}_1 + \\mathbf{b}_1 \\mathbf{a}_1^T = \\boldsymbol{\\Gamma}_1^1 + (\\boldsymbol{\\Gamma}_2^1 \\mathbf{b}_1) \\cdot \\mathbf{w}_1^T$$由于 $\\boldsymbol{\\Gamma}_1^1 = \\mathbf{D}_1$，$\\boldsymbol{\\Gamma}_2^1 = \\mathbf{I}$，$\\mathbf{w}_1^T = \\mathbf{a}_1^T$，成立。\n归纳步：假设对 $t$ 成立，证明对 $t+1$ 成立。\n$$ \\begin{aligned} \\mathbf{P}_{t+1:1} \u0026= \\mathbf{P}_{t+1} \\cdot \\mathbf{P}_{t:1} \\\\ \u0026= (\\mathbf{D}_{t+1} + \\mathbf{b}_{t+1} \\mathbf{a}_{t+1}^T)\\left(\\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T\\right) \\\\ \u0026= \\boldsymbol{\\Gamma}_1^{t+1} + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^{t+1} \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T \\\\ \u0026\\quad + \\mathbf{b}_{t+1} \\cdot \\underbrace{\\left(\\mathbf{a}_{t+1}^T \\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\mathbf{a}_{t+1}^T \\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T\\right)}_{\\eqqcolon \\mathbf{w}_{t+1}^T} \\\\ \u0026= \\boldsymbol{\\Gamma}_1^{t+1} + \\sum_{i=1}^{t+1} (\\boldsymbol{\\Gamma}_{i+1}^{t+1} \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T \\end{aligned} $$其中使用了 $\\boldsymbol{\\Gamma}_{t+2}^{t+1} = \\mathbf{I}$。证毕。\n状态的 WY 表示 将 WY 表示代入状态递推，我们可以得到：\n$$\\mathbf{S}_t = \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{k}_i^T \\mathbf{v}_i + \\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i \\mathbf{u}_i^T)$$其中 $\\mathbf{u}_i^T$（$1 \\times V$ 行向量）满足：\n$$ \\mathbf{u}_i^T = \\begin{cases} \\mathbf{0}, \u0026 i=1 \\\\ \\sum_{j=1}^{i-1} (\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{k}_j^T \\mathbf{v}_j + \\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{b}_j \\mathbf{u}_j^T), \u0026 i \\geq 2 \\end{cases} $$矩阵形式的线性系统 定义 chunk 内的矩阵（第 $i$ 行为对应向量，以下计算适用于左乘的 DPLR）：\n$\\mathbf{A}_{ab} \\in \\mathbb{R}^{C \\times C}$：$[\\mathbf{A}_{ab}]_{ij} = \\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{b}_j$ for $i \u003e j$ $\\mathbf{A}_{ak} \\in \\mathbb{R}^{C \\times C}$：$[\\mathbf{A}_{ak}]_{ij} = \\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{k}_j^T$ for $i \u003e j$ 则 $(\\mathbf{I} + \\mathbf{A}_{ab})$ 是单位下三角矩阵。令：\n$\\mathbf{A}^{\\text{gate}} = \\mathbf{A}^{\\text{lr}} \\odot \\exp(\\mathbf{G}^{\\text{cum}}) \\in \\mathbb{R}^{C \\times K}$（门控后的低秩向量矩阵），其中 $\\mathbf{A}^{\\text{lr}} \\in \\mathbb{R}^{C \\times K}$ 的第 $i$ 行为 $\\mathbf{a}_i^T$，$\\mathbf{G}^{\\text{cum}}$ 的第 $i$ 行为 $\\mathbf{g}_i^{\\text{cum}}$ 则 WY 表示的矩阵形式为：\n$$\\mathbf{W} = (\\mathbf{I} + \\mathbf{A}_{ab})^{-1} \\mathbf{A}^{\\text{gate}}$$$$\\mathbf{U} = (\\mathbf{I} + \\mathbf{A}_{ab})^{-1} \\mathbf{A}_{ak} \\mathbf{V}$$这与 KDA 中的 WY 表示形式结构类似，区别在于：KDA 中 $\\tilde{\\mathbf{V}} = \\mathbf{U} - \\mathbf{W}\\mathbf{S}$（减号，来自 Delta Rule 残差），而 DPLR 中 $\\tilde{\\mathbf{U}} = \\mathbf{U} + \\mathbf{W}\\mathbf{S}$（加号，来自低秩叠加）。这导致 Affine 参数 $\\mathbf{M}$ 中的符号也不同：KDA 为 $\\text{diag}(\\cdot) - \\mathbf{K}^T \\mathbf{W}$，DPLR 为 $\\text{diag}(\\cdot) + \\mathbf{B}^T \\mathbf{W}$。\n核心定理：Chunk-wise Affine 形式 定理（DPLR 的 Chunk-wise Affine 形式） 设 chunk 开始时状态为 $\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$，则 chunk 结束时的状态为：\n$$\\mathbf{S}' = \\mathbf{M} \\mathbf{S} + \\mathbf{B}$$其中：\nTransition 矩阵 $\\mathbf{M} \\in \\mathbb{R}^{K \\times K}$： $$\\mathbf{M} = \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) + \\mathbf{B}_{\\text{decayed}}^T \\mathbf{W}$$ Bias 矩阵 $\\mathbf{B} \\in \\mathbb{R}^{K \\times V}$： $$\\mathbf{B} = \\mathbf{K}_{\\text{decayed}}^T \\mathbf{V} + \\mathbf{B}_{\\text{decayed}}^T \\mathbf{U}$$ 且 chunk 的输出为：\n$$\\mathbf{O} = \\mathbf{Q} \\mathbf{S} + \\text{mask}(\\mathbf{A}_{qk}) \\mathbf{V} + \\text{mask}(\\mathbf{A}_{qb}) (\\mathbf{U} + \\mathbf{W} \\mathbf{S})$$证明 状态更新：\n$$ \\begin{aligned} \\mathbf{S}' \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\sum_{i=1}^C \\exp(\\mathbf{g}_{\\text{last}} - \\mathbf{g}_i) \\odot (\\mathbf{k}_i^T \\mathbf{v}_i + \\mathbf{b}_i \\tilde{\\mathbf{u}}_i) \\\\ \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\mathbf{K}_{\\text{decayed}}^T \\mathbf{V} + \\mathbf{B}_{\\text{decayed}}^T \\tilde{\\mathbf{U}} \\end{aligned} $$其中 $\\tilde{\\mathbf{u}}_i = \\mathbf{u}_i + \\mathbf{w}_i \\mathbf{S}$（$1 \\times V$ 行向量）是包含历史状态贡献的修正向量。这里 $\\mathbf{w}_i \\in \\mathbb{R}^{1 \\times K}$（行向量），$\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$，乘积 $\\mathbf{w}_i \\mathbf{S} \\in \\mathbb{R}^{1 \\times V}$，维度匹配。\n代入 WY 表示的矩阵形式 $\\tilde{\\mathbf{U}} = \\mathbf{U} + \\mathbf{W} \\mathbf{S}$（注意这里是加号，与 KDA 中 $\\tilde{\\mathbf{V}} = \\mathbf{U} - \\mathbf{W} \\mathbf{S}$ 的减号不同。原因在于 KDA 的 WY 表示分离的是 Delta Rule 的残差 $\\mathbf{v}_i - \\mathbf{k}_i \\mathbf{S}$，减号来源于\u0026quot;减去历史预测\u0026quot;；而 DPLR 没有 Delta Rule 结构，低秩部分 $\\mathbf{b}_i \\mathbf{a}_i^T$ 是直接叠加到状态上的，因此历史状态的贡献是正向累积的）：\n$$ \\begin{aligned} \\mathbf{S}' \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\mathbf{K}_{\\text{decayed}}^T \\mathbf{V} + \\mathbf{B}_{\\text{decayed}}^T (\\mathbf{U} + \\mathbf{W} \\mathbf{S}) \\\\ \u0026= \\underbrace{(\\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) + \\mathbf{B}_{\\text{decayed}}^T \\mathbf{W})}_{\\mathbf{M}} \\mathbf{S} + \\underbrace{(\\mathbf{K}_{\\text{decayed}}^T \\mathbf{V} + \\mathbf{B}_{\\text{decayed}}^T \\mathbf{U})}_{\\mathbf{B}} \\end{aligned} $$（注：详细的交叉项推导需要考虑 $\\mathbf{W}$ 和 $\\mathbf{K}_{\\text{decayed}}$ 的具体关系，此处给出主要结构。）\n输出计算类似可得。\n算法实现：从理论到代码 基于上述定理，DPLR 的 chunk-wise 算法流程如下：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 def chunk_dplr(K, V, A, B, G, chunk_size=64): \u0026#34;\u0026#34;\u0026#34; K, V: [C, K], [C, V] - keys, values A, B: [C, K] - low-rank vectors a, b G: [C, K] - cumulative log decay \u0026#34;\u0026#34;\u0026#34; # Step 1: 计算门控后的输入 # 注意：代码中使用相对衰减技巧 ag = A * exp(G) # gated a (使用 ge，即 shifted cumsum) bg = B * exp(-G + G[-1]) # gated b (相对衰减) kg = K * exp(-G + G[-1]) # gated k (相对衰减) qg = Q * exp(G) # gated q (正向门控) # Step 2: 计算下三角矩阵 A_ab 和 A_ak # A_ab[i,j] = dot(a_i * exp(g_i - g_j), b_j) for i \u0026gt; j A_ab = (ag @ (B * exp(-G)).T).masked_fill_(triu_mask, 0) A_ak = (ag @ (K * exp(-G)).T).masked_fill_(triu_mask, 0) # Step 3: 计算 (I + A_ab)^{-1} 通过前向替换 A_ab_inv = forward_substitution_inverse(I + A_ab) # Step 4: WY 表示 # w = A_ab_inv @ ag # u = A_ab_inv @ (A_ak @ v) W = A_ab_inv @ ag # [C, K] U = A_ab_inv @ (A_ak @ V) # [C, V] # Step 5: 计算 Affine 参数 decay_last = exp(G[-1]) # [K] K_decayed = K * exp(G[-1] - G) # [C, K] B_decayed = B * exp(G[-1] - G) # [C, K] # Transition 矩阵 M M = diag(decay_last) + B_decayed.T @ W # [K, K] # Bias 矩阵 B（包含 k 和 b 的贡献） B_mat = K_decayed.T @ V + B_decayed.T @ U # [K, V] # Step 6: 状态更新（如果初始状态 S=0，则 S_next = B_mat） S_next = M @ S + B_mat # Step 7: 计算 chunk 输出 # O = Q @ S + masked_attention # 注意：qg 是门控后的 query，与 QG 相同 O_local = mask(qg @ K.T) @ V + mask(qg @ B_lr.T) @ U return M, B_mat, S_next, W, U 关键实现细节 矩阵求逆：$(\\mathbf{I} + \\mathbf{A}_{ab})^{-1}$ 是单位下三角矩阵的逆，可通过前向替换在 $O(C^3)$ 内完成（$C$ 是 chunk size，通常 64 或 128）\n相对衰减技巧：代码中使用 $\\exp(-\\mathbf{g} + \\mathbf{g}_{\\text{last}})$ 而非直接使用 $\\exp(\\mathbf{g})$，这是为了数值稳定性\n索引吸收约定：代码中 ag = A * exp(G) 将 $\\exp(\\mathbf{g}_i)$ 吸收进了 $\\mathbf{a}_i$，因此代码计算的 $\\mathbf{A}_{ab}$ 实际上是 $[\\mathbf{A}_{ab}]_{ij} = \\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i} \\mathbf{b}_j$（包含 $\\mathbf{g}_i$ 因子），而非数学定义中的 $\\mathbf{a}_i^T \\boldsymbol{\\Gamma}_{j+1}^{i-1} \\mathbf{b}_j$。相应地，$\\mathbf{W}$ 的计算结果也吸收了这个额外因子，使得最终的 Affine 参数 $\\mathbf{M}, \\mathbf{B}$ 保持正确。这种吸收简化了代码实现，避免了显式的索引偏移\n分块计算：当 $K$ 较大时，需要将 key/value 维度分块以适配 GPU Shared Memory\n精度控制：类似 KDA，中间计算使用 float32，存储使用 bf16/fp16\nDPLR vs KDA vs IPLR 三种变体的统一视角 变体 转移矩阵 乘法方向 核心特征 IPLR $\\mathbf{I} + \\mathbf{b}\\mathbf{a}^T$ 右乘 Identity + Low Rank，无显式衰减 KDA 隐式（通过 Delta Rule） 左乘 Per-dim decay + Delta Rule DPLR $\\text{diag}(\\exp(\\mathbf{g})) + \\mathbf{b}\\mathbf{a}^T$ 左乘 Diagonal decay + Low Rank 数学联系 IPLR 是 DPLR 的特例：当 $\\mathbf{g}_t = \\mathbf{0}$（即 $\\mathbf{D}_t = \\mathbf{I}$）时，DPLR 退化为 IPLR\nRWKV-7 与 DPLR 的对偶性：\nDPLR（FLA 实现）：$\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$（左乘，column-space 更新） RWKV-7（原生）：$\\mathbf{S}' = \\mathbf{S}\\mathbf{M}^T + \\mathbf{B}^T$（右乘，row-space 更新） 统一框架：两者最终都归结为 Affine 变换形式\nCP 并行与多级并行 Affine 链式法则（左乘版本） DPLR 的状态更新也是 Affine 形式，满足链式复合：\n设：\n$\\mathbf{S}_1 = \\mathbf{M}_0 \\mathbf{S}_0 + \\mathbf{B}_0$ $\\mathbf{S}_2 = \\mathbf{M}_1 \\mathbf{S}_1 + \\mathbf{B}_1$ 则： $$\\mathbf{S}_2 = \\underbrace{(\\mathbf{M}_1 \\mathbf{M}_0)}_{\\mathbf{M}_{01}} \\mathbf{S}_0 + \\underbrace{(\\mathbf{M}_1 \\mathbf{B}_0 + \\mathbf{B}_1)}_{\\mathbf{B}_{01}}$$CP 并行算法 与 KDA 完全类似：\nLocal 计算：每个 rank 假设 $\\mathbf{S} = \\mathbf{0}$，计算 $(\\mathbf{M}_r, \\mathbf{B}_r)$ All-Gather：收集所有 Affine 参数 Prefix Scan：Rank $r$ 计算真正的初始状态 $$\\mathbf{S}_r = \\sum_{j=0}^{r-1} \\left( \\prod_{k=j+1}^{r-1} \\mathbf{M}_k \\right) \\mathbf{B}_j$$ Local 重算：用正确的 $\\mathbf{S}_r$ 重新计算输出 SM 并行 同样适用，将长序列分割为多个 subsequence，通过两级 Affine 复合实现。\n总结 我们从显式转移矩阵的角度建立了 DPLR 的完整数学理论：\nDPLR 的核心：对角+低秩转移矩阵 $\\mathbf{P}_t = \\text{diag}(\\exp(\\mathbf{g}_t)) + \\mathbf{b}_t \\mathbf{a}_t^T$ WY 表示：将累积转移矩阵分解为对角部分与低秩部分之和 $$\\mathbf{P}_{t:1} = \\boldsymbol{\\Gamma}_1^t + \\sum_{i=1}^t (\\boldsymbol{\\Gamma}_{i+1}^t \\mathbf{b}_i) \\cdot \\mathbf{w}_i^T$$ Chunk-wise Affine：$\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$ 统一框架：DPLR、KDA、IPLR 都是 Affine 变换的特例，支持相同的并行范式 本文的数学推导基于我们在 Flash Linear Attention (FLA) 框架中的理论构建与代码实现。\n","permalink":"https://zhiyuan1i.github.io/posts/dplr-mathematics/","summary":"\u003cblockquote\u003e\n\u003cp\u003e本文假设读者熟悉线性代数（矩阵乘法、外积、逆矩阵）和基本的序列模型概念，建议先阅读 \u003ca href=\"/posts/kda-mathematics/\"\u003eKDA 数学原理\u003c/a\u003e。\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003ch2 id=\"摘要\"\u003e摘要\u003c/h2\u003e\n\u003cp\u003e本文推导了 \u003cstrong\u003eDPLR（Diagonal Plus Low Rank）\u003c/strong\u003e 的 chunk-wise 并行算法。DPLR 是广义 Delta Rule 的重要变体，被应用于 \u003cstrong\u003eRWKV-7\u003c/strong\u003e 等架构中。核心贡献：\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e建立 DPLR 的显式转移矩阵形式：$\\mathbf{P}_t = \\text{diag}(\\exp(\\mathbf{g}_t)) + \\mathbf{b}_t \\mathbf{a}_t^T$\u003c/li\u003e\n\u003cli\u003e推导 DPLR 的 \u003cstrong\u003eWY 表示\u003c/strong\u003e，将累积转移矩阵分解为对角部分与低秩部分之和\u003c/li\u003e\n\u003cli\u003e证明 DPLR 同样满足 \u003cstrong\u003eAffine 变换\u003c/strong\u003e形式，天然支持 CP 并行\u003c/li\u003e\n\u003cli\u003e对比 DPLR、KDA、IPLR 的异同，揭示线性注意力家族的统一数学框架\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp\u003eDPLR 相比标准 Delta Rule 的优势：显式控制对角衰减（dim-wise forgetting）和低秩更新，表达力更强，但在 chunk 形式下显著的引入了额外的计算复杂度，需要更多的 HBM 空间来存储中间变量。\u003c/p\u003e\n\u003chr\u003e\n\u003ch2 id=\"目录\"\u003e目录\u003c/h2\u003e\n\u003col\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e5%bc%95%e8%a8%80%e4%bb%8e-delta-rule-%e5%88%b0-dplr\"\u003e引言：从 Delta Rule 到 DPLR\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e7%ac%a6%e5%8f%b7%e8%a1%a8%e4%b8%8e%e7%ba%a6%e5%ae%9a\"\u003e符号表与约定\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e6%a0%b8%e5%bf%83%e5%bc%95%e7%90%86\"\u003e核心引理\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#dplr-%e7%9a%84%e9%80%92%e6%8e%a8%e5%bd%a2%e5%bc%8f\"\u003eDPLR 的递推形式\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#wy-%e8%a1%a8%e7%a4%ba%e7%b4%af%e7%a7%af%e8%bd%ac%e7%a7%bb%e7%9f%a9%e9%98%b5%e7%9a%84%e5%88%86%e8%a7%a3\"\u003eWY 表示：累积转移矩阵的分解\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e6%a0%b8%e5%bf%83%e5%ae%9a%e7%90%86chunk-wise-affine-%e5%bd%a2%e5%bc%8f\"\u003e核心定理：Chunk-wise Affine 形式\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e7%ae%97%e6%b3%95%e5%ae%9e%e7%8e%b0%e4%bb%8e%e7%90%86%e8%ae%ba%e5%88%b0%e4%bb%a3%e7%a0%81\"\u003e算法实现：从理论到代码\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#dplr-vs-kda-vs-iplr\"\u003eDPLR vs KDA vs IPLR\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#cp-%e5%b9%b6%e8%a1%8c%e4%b8%8e%e5%a4%9a%e7%ba%a7%e5%b9%b6%e8%a1%8c\"\u003eCP 并行与多级并行\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/dplr-mathematics/#%e6%80%bb%e7%bb%93\"\u003e总结\u003c/a\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003chr\u003e\n\u003ch2 id=\"引言从-delta-rule-到-dplr\"\u003e引言：从 Delta Rule 到 DPLR\u003c/h2\u003e\n\u003ch3 id=\"delta-rule-的局限性\"\u003eDelta Rule 的局限性\u003c/h3\u003e\n\u003cp\u003e标准 Delta Rule（以及没有遗忘门的 GDN/KDA）的状态更新可以写成：\u003c/p\u003e","title":"DPLR（Diagonal Plus Low Rank）的数学原理：显式转移矩阵的并行计算"},{"content":" 本文假设读者熟悉线性代数（矩阵乘法、外积、逆矩阵）和基本的序列模型概念。\n摘要 本文推导了 KDA（Kimi Delta Attention）的 chunk-wise 并行算法。核心贡献：\n证明 KDA 的 chunk 状态更新可表示为 Affine 变换：$\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$ 通过 WY 表示 将残差计算分解为与历史状态无关的部分，实现并行计算 基于 Affine 变换的复合性质，推导出 CP（Context Parallel，上下文并行） 的数学基础 KDA 相比标准 Attention 的优势：$O(N)$ 复杂度、常数内存状态、适合超长序列。\n目录 引言：从 Transformer 到 Linear Attention Linear Attention 的发展历程 符号表与约定 线性注意力：简单的起点 背景：从 GDN 到 KDA 核心引理 KDA 的状态更新机制 WY 表示：依赖的分离 核心定理：Chunk-wise Affine 形式 算法实现：从理论到代码 CP 并行与 SM 并行 总结 附录：GDN vs KDA 参考资料 引言：从 Transformer 到 Linear Attention 标准 Attention 的瓶颈 Transformer 架构自 2017 年提出以来，已成为自然语言处理和序列建模的主流方法。其核心组件 Self-Attention 机制通过计算序列中所有 token 两两之间的注意力权重来捕获长距离依赖：\n$$ \\text{Attention}(Q, K, V) = \\text{softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right)V$$然而，这种标准的 Softmax Attention 存在显著的计算瓶颈：\n$O(N^2)$ 复杂度：计算注意力矩阵需要 $O(N^2)$ 的时间和空间复杂度 内存墙问题：当序列长度 $N$ 增加时，内存占用呈平方增长 推理效率低：自回归生成时需要缓存所有历史 KV，内存开销巨大 对于长序列任务（如文档理解、代码生成、多轮对话），$N$ 可能达到数十万甚至上百万，这使得标准 Attention 变得不可行。\nLinear Attention 的动机 Linear Attention 1 通过去掉 Softmax，将注意力重写为 RNN 形式。其完整形式包含分子（值累积）和分母（归一化累积）：\n$$\\mathbf{o}_t = \\frac{\\phi(\\mathbf{q}_t)^T \\mathbf{S}_t}{\\phi(\\mathbf{q}_t)^T \\mathbf{Z}_t}$$其中两个状态分别递推更新： $$ \\begin{aligned} \\mathbf{S}_t \u0026= \\mathbf{S}_{t-1} + \\phi(\\mathbf{k}_t) \\otimes \\mathbf{v}_t \\\\ \\mathbf{Z}_t \u0026= \\mathbf{Z}_{t-1} + \\phi(\\mathbf{k}_t) \\end{aligned} $$这里 $\\mathbf{S}_t \\in \\mathbb{R}^{d_k \\times d_v}$ 是状态矩阵，$\\mathbf{Z}_t \\in \\mathbb{R}^{d_k}$ 是归一化向量。在实际应用中，分母的归一化可以通过后续的 RMSNorm 等层近似，因此常被省略以简化计算，得到更简洁的形式：\n$$\\mathbf{S}_t = \\mathbf{S}_{t-1} + \\phi(\\mathbf{k}_t) \\otimes \\mathbf{v}_t, \\quad \\mathbf{o}_t = \\phi(\\mathbf{q}_t)^T \\mathbf{S}_t$$这种形式的复杂度仅为 $O(N)$，且推理时只需要维护固定大小的状态矩阵。\n本文的工作 本文聚焦于 Kimi Linear 2 中提出的 Kimi Delta Attention (KDA)，这是一种新一代 Linear Attention 变体，结合了：\nDelta Rule：仅更新与预测误差相关的信息 Per-dimension Decay：不同维度可以有独立的遗忘速率 Chunk-wise 并行：通过 WY 表示实现硬件高效的并行训练 我们将从最基本的矩阵乘法引理出发，逐步建立 KDA 的完整数学理论。\nLinear Attention 的发展历程 Linear Attention 的研究从早期的模仿 Softmax Attention，到逐渐形成自身特色，再到最近探索更上层的指导原则（如 Delta Rule），经历了多个重要阶段。\n1. 奠基时期 (2020)：从近似到重构 Katharopoulos et al. 1 在 ICML 2020 上发表了开创性工作 \u0026ldquo;Transformers are RNNs\u0026rdquo;，首次将 Transformer 重新表述为 RNN 形式。他们证明了通过特征映射 $\\phi$，可以构造线性复杂度的注意力机制。\n早期的 Linear Attention 主要是模仿和近似 Softmax Attention：\n直接去掉 softmax 的 exp，得到 $O = (QK^\\top \\odot M)V$ 为了数值稳定性，给 Q, K 加上非负激活函数（如 elu+1） Performer 3 使用随机傅里叶特征近似 Softmax 然而后续研究发现，在序列长度维度归一化并不能完全避免数值不稳定性，倒不如直接事后归一化（如 RMSNorm），而且给 Q, K 加激活函数也非必须。\n2. 遗忘机制的引入 (2021-2023) 纯 Linear Attention 本质上是 cumsum，会将所有历史信息等权叠加，导致远距离 token 的信息占比极小。遗忘机制的引入解决了这个问题：\nLRU (2023)：线性循环单元，引入标量 decay（衰减） 因子 RetNet (2023)：首次将遗忘因子与 Linear Attention 结合，$S_t = \\gamma S_{t-1} + v_t k_t^\\top$，其中 $\\gamma \\in (0,1)$ 是常数 decay RWKV-4 4 (2023)：纯 RNN 架构，结合 RNN 的常数推理内存和 Transformer 的并行训练优点，使用 channel-wise decay（通道级衰减） RetNet 的一个细节是给 Q, K 加上 RoPE，相当于将 decay 推广到复数域，从 LRU 角度看是考虑了复数特征值。\n3. Data-Dependent Decay (2023-2024) 将静态 decay 推广为与输入相关的动态 decay，形成了一系列工作：\nMamba 5：引入输入依赖的门控机制 Mamba2 67：提出 SSD 框架，从状态空间模型角度重新解释 GLA 8：使用外积形式的遗忘门，实现 GPU 高效的矩阵乘法并行 RWKV-5/6 9 (2024)：Eagle 和 Finch 架构，引入矩阵值状态和动态递推 这一阶段的工作与 GRU、LSTM 等传统 RNN 的\u0026quot;遗忘门\u0026quot;已经非常相似，只是为了保持线性性，去除了门控对 State 的依赖。\n4. RWKV：独立的纯 RNN 架构 RWKV（Receptance Weighted Key Value）是由 Peng Bo 等人提出的一系列纯 RNN 架构 LLM，与 Linear Attention 的发展并行，但采用了不同的技术路线——RWKV 强调保持纯粹的 RNN 形式（仅通过固定大小的状态传递历史信息），而 Linear Attention 则侧重于利用矩阵乘法实现 chunk-wise 并行计算。\n版本 时间 核心特性 RWKV-4 4 2023 基础架构，引入 Receptance 机制和 channel-wise 时间衰减 RWKV-5 (Eagle) 9 2024 矩阵值状态（Matrix-Valued States），增强表达能力 RWKV-6 (Finch) 9 2024 数据依赖的 token shift 和动态递推 RWKV-7 10 2025 引入广义 Delta Rule（generalized delta rule），向量值门控和上下文学习率 RWKV 的独特之处在于其完全基于 RNN 形式，通过精心设计的状态更新机制实现高效的序列建模。\n5. Delta Rule 的兴起 (2024-2025) Delta Rule 最初是神经网络中的参数更新规则（Widrow-Hoff 规则），近年来被引入序列建模作为\u0026quot;测试时训练\u0026quot;（Test Time Training）的一种形式：\nTTT (2024)：将序列模型构建视为在线学习问题，用优化器构建 RNN DeltaNet 11 (NeurIPS 2024)：将 Delta Rule 应用于 Linear Attention Gated DeltaNet (GDN) 12 (2024)：引入门控机制控制信息流动 RWKV-7 10 (2025)：独立地引入广义 Delta Rule KDA 2 (2025)：在 Kimi Linear 中提出，将标量 decay（衰减） 推广到 per-dimension decay Delta Rule 的核心思想是仅当新信息与历史预测不同时才更新状态，这与人类的增量学习过程相似，也与 TTT 的\u0026quot;在线学习\u0026quot;视角高度契合。\n变体对比 方法 更新规则 复杂度 关键特性 Softmax Attention $\\text{softmax}(QK^T)V$ $O(N^2)$ 全局依赖，准确但慢 Linear Attention $\\phi(Q)^T \\sum \\phi(K)V^T$ $O(N)$ 固定状态，高效但弱表达 RetNet $S_t = \\gamma S_{t-1} + v_t k_t^\\top$ $O(N)$ 常数 decay + RoPE RWKV-4/5/6 Receptance + 时间衰减 $O(N)$ 纯 RNN 架构，并行训练 Mamba 输入依赖的状态转移 $O(N)$ 选择性，硬件优化 GLA 门控线性注意力 $O(N)$ 外积形式，GPU 高效 DeltaNet Delta Rule $O(N)$ 内容感知增量更新 GDN Delta + 标量门控 $O(N)$ 全局遗忘控制 RWKV-7 广义 Delta Rule $O(N)$ 向量值门控 KDA Delta + Per-dim 门控 $O(N)$ 维度选择性遗忘 符号表与约定 符号 维度 含义 $\\mathbf{s}_t$ $\\mathbb{R}^{K \\times V}$ token-level 状态矩阵 $\\mathbf{S}$ $\\mathbb{R}^{K \\times V}$ chunk-level 初始状态 $\\mathbf{S}'$ $\\mathbb{R}^{K \\times V}$ chunk-level 结束状态 $\\mathbf{k}_t, \\mathbf{q}_t$ $\\mathbb{R}^{1 \\times K}$（行向量） token-level key/query $\\mathbf{v}_t$ $\\mathbb{R}^{1 \\times V}$（行向量） token-level value $\\mathbf{K}, \\mathbf{Q}, \\mathbf{V}$ $\\mathbb{R}^{C \\times K}$ / $\\mathbb{R}^{C \\times V}$ chunk-level 矩阵，第 $i$ 行为 $\\mathbf{k}_i$ $\\mathbf{g}_t^{\\text{raw}}$ $\\mathbb{R}^K$ 原始 log decay $\\mathbf{g}_t$ $\\mathbb{R}^K$ 累积 log decay（cumsum 后） $\\boldsymbol{\\lambda}_t = \\exp(\\mathbf{g}_t^{\\text{raw}})$ $\\mathbb{R}^K$ per-dimension decay（逐维衰减） 因子（原始 decay） $\\beta_t$ 标量 Delta Rule 权重 $\\mathbf{A}_{kk}$ $\\mathbb{R}^{C \\times C}$ 严格下三角权重矩阵 $\\mathbf{W}, \\mathbf{U}$ $\\mathbb{R}^{C \\times K}$ / $\\mathbb{R}^{C \\times V}$ WY 表示的加权 keys/values $\\mathbf{M}$ $\\mathbb{R}^{K \\times K}$ Affine transition 矩阵 $\\mathbf{B}$ $\\mathbb{R}^{K \\times V}$ Affine bias 矩阵 $\\otimes$ - 外积：$(\\mathbf{k}\\otimes\\mathbf{v})_{ab} = k_a \\cdot v_b$ $\\odot$ - Hadamard 积（逐元素乘） 约定：\n小写粗体（$\\mathbf{s}, \\mathbf{k}, \\mathbf{v}$）表示 token-level 行向量 大写粗体（$\\mathbf{S}, \\mathbf{K}, \\mathbf{V}$）表示 chunk-level 矩阵 矩阵 $\\mathbf{K} \\in \\mathbb{R}^{C \\times K}$ 的第 $i$ 行为 $\\mathbf{k}_i \\in \\mathbb{R}^{1 \\times K}$ 矩阵 $\\mathbf{V} \\in \\mathbb{R}^{C \\times V}$ 的第 $i$ 行为 $\\mathbf{v}_i \\in \\mathbb{R}^{1 \\times V}$ 状态 $\\mathbf{s}_t \\in \\mathbb{R}^{K \\times V}$ 和 $\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$ 是矩阵（非向量） 关于 Chunk Chunk 是指将长序列分割为固定长度的连续段（通常 $C = 64$ 或 $128$），每段包含 $C$ 个 token。选择 $C = 64$ 或 $128$ 的原因与 GPU Tensor Core 的矩阵乘法维度有关：\nTensor Core 的矩阵乘法最优维度通常满足 $M, N, K \\in \\{64, 128, 256\\}$ Chunk size $C$ 对应矩阵乘的 $M$ 或 $N$ 维度 过大的 $C$（如 256）会增加 Shared Memory 内存占用；过小的 $C$（如 16）无法充分利用 Tensor Core 的并行度 线性注意力：简单的起点 作为热身，我们先看线性注意力（Linear Attention），它是最简单的 recurrent 注意力形式。\n定义 $$\\mathbf{s}_t = \\mathbf{s}_{t-1} + \\mathbf{k}_t \\otimes \\mathbf{v}_t, \\quad \\mathbf{o}_t = \\mathbf{q}_t^\\top \\mathbf{s}_t$$其中 $\\mathbf{s}_t \\in \\mathbb{R}^{K \\times V}$ 是状态矩阵。\nChunk-wise 形式 将序列分成每 $C$ 个 token 为一个 chunk。设 $\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$ 是 chunk 开始时的状态，则 chunk 内第 $i$ 个位置的状态为：\n$$\\mathbf{s}_i = \\mathbf{S} + \\sum_{j=1}^i \\mathbf{k}_j \\otimes \\mathbf{v}_j$$chunk 的输出 $\\mathbf{O} \\in \\mathbb{R}^{C \\times V}$（第 $i$ 行是 $\\mathbf{o}_i^\\top$）：\n$$\\mathbf{O} = \\mathbf{Q} \\mathbf{S} + \\text{mask}(\\mathbf{Q} \\mathbf{K}^\\top) \\mathbf{V}$$其中 $\\text{mask}(\\cdot)$ 表示因果掩码（下三角部分）。上述形式完全由矩阵乘法构成。\n参考资料：线性注意力的奠基性工作见 Katharopoulos et al. (ICML 2020) 1，首次将 Transformer 重新表述为 RNN 形式。硬件高效的 chunk-wise 并行训练方法见 Yang et al. (ICML 2024) 8。\n背景：从 GDN 到 KDA Gated DeltaNet (GDN) Gated DeltaNet (GDN) 是一种基于 Delta Rule 的序列建模方法，使用标量 decay（衰减）：\n$$\\mathbf{s}_t = \\lambda_t \\cdot \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^\\top (\\mathbf{v}_t - \\mathbf{k}_t (\\lambda_t \\cdot \\mathbf{s}_{t-1}))$$其中 $\\lambda_t = \\exp(g_t)$ 是标量（每个 head 一个值），所有维度共享相同的遗忘速率。\nKimi Delta Attention (KDA) KDA 是 GDN 的扩展，将标量 decay（衰减） 推广为per-dimension decay：\n$$\\mathbf{s}_t = \\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^\\top (\\mathbf{v}_t - \\mathbf{k}_t (\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1}))$$其中 $\\boldsymbol{\\lambda}_t \\in \\mathbb{R}^K$ 是向量（每个维度一个值），不同维度可以有独立的遗忘速率。\n本文的目标 本文以 KDA 为主要对象，建立其 chunk-wise 并行和 CP 并行的数学理论。GDN 作为 KDA 的特例（标量 decay（衰减））在附录中讨论。\n核心引理 引理 1：外积累加的矩阵形式 引理 1：设 $\\mathbf{k}_1, \\ldots, \\mathbf{k}_C \\in \\mathbb{R}^K$ 和 $\\mathbf{v}_1, \\ldots, \\mathbf{v}_C \\in \\mathbb{R}^V$ 是两组向量。则\n$$\\sum_{i=1}^C \\mathbf{k}_i \\otimes \\mathbf{v}_i = \\mathbf{K}^\\top \\mathbf{V}$$其中：\n$\\mathbf{K} \\in \\mathbb{R}^{C \\times K}$ 是 $C$ 个 $\\mathbf{k}_i$ 拼起来的矩阵 $\\mathbf{V} \\in \\mathbb{R}^{C \\times V}$ 是 $C$ 个 $\\mathbf{v}_i$ 拼起来的矩阵 $\\otimes$ 表示外积：$(\\mathbf{k} \\otimes \\mathbf{v})_{ab} = k_a \\cdot v_b$ 证明：直接计算右边矩阵的 $(a, b)$ 元素：\n$$(\\mathbf{K}^\\top \\mathbf{V})_{ab} = \\sum_{i=1}^C K_{ia} V_{ib} = \\sum_{i=1}^C k_{i,a} \\cdot v_{i,b} = \\sum_{i=1}^C (\\mathbf{k}_i \\otimes \\mathbf{v}_i)_{ab}$$由引理 1，chunk 内的外积累加可表示为矩阵乘法（GEMM，General Matrix Multiply），这为 chunk-wise 并行提供了数学基础。\n引理 2：下三角矩阵的逆 引理 2：设 $\\mathbf{L} \\in \\mathbb{R}^{C \\times C}$ 是单位下三角矩阵（对角线为 1，上三角为 0），则 $\\mathbf{L}^{-1}$ 也是单位下三角矩阵，且可以通过前向替换计算。\n特别地，若 $\\mathbf{L} = \\mathbf{I} - \\mathbf{N}$，其中 $\\mathbf{N}$ 是严格下三角矩阵（对角线为 0），则\n$$\\mathbf{L}^{-1} = \\mathbf{I} + \\mathbf{N} + \\mathbf{N}^2 + \\cdots + \\mathbf{N}^{C-1}$$证明：直接验证 $(\\mathbf{I} - \\mathbf{N})(\\mathbf{I} + \\mathbf{N} + \\cdots + \\mathbf{N}^{C-1}) = \\mathbf{I} - \\mathbf{N}^C = \\mathbf{I}$（因为 $\\mathbf{N}^C = 0$，严格下三角矩阵的 $C$ 次幂为零）。\n引理 3：对数衰减矩阵的线性分解（exp g 与 exp -g） 引理 3：对于给定的累积对数衰减向量 $\\mathbf{g}_1, \\dots, \\mathbf{g}_C \\in \\mathbb{R}^K$（已通过 cumsum 计算），Attention 矩阵中的衰减项可以分解为：\n$$\\exp(\\mathbf{g}_i - \\mathbf{g}_j) = \\exp(\\mathbf{g}_i) \\odot \\exp(-\\mathbf{g}_j)$$这使得原本需要针对每个位置进行循环计算的逻辑可以直接写为两个\u0026quot;门控矩阵\u0026quot;的标准矩阵乘法：\n$$\\mathbf{A} = (\\mathbf{K} \\odot \\exp(\\mathbf{G})) \\cdot (\\mathbf{K} \\odot \\exp(-\\mathbf{G}))^\\top$$维度说明：\n$\\mathbf{K} \\in \\mathbb{R}^{C \\times K}$：chunk 内的 keys 矩阵，第 $i$ 行为 $\\mathbf{k}_i$ $\\mathbf{G} \\in \\mathbb{R}^{C \\times K}$：累积 log decay 矩阵，第 $i$ 行为 $\\mathbf{g}_i$ $\\mathbf{A} \\in \\mathbb{R}^{C \\times C}$：中间 Attention 矩阵（尚未应用 $\\beta$ 和因果 mask） 分解形式：\n$\\mathbf{K}_{\\text{exp}} = \\mathbf{K} \\odot \\exp(\\mathbf{G})$：Forward decay（累积衰减后的 keys） $\\mathbf{K}_{\\text{inv}} = \\mathbf{K} \\odot \\exp(-\\mathbf{G})$：Reverse decay（逆向衰减后的 keys） $$\\mathbf{A} = \\mathbf{K}_{\\text{exp}} \\cdot \\mathbf{K}_{\\text{inv}}^\\top$$ 意义：\n消除循环：将 $O(C)$ 的循环和复杂的 einsum 转化为了单次标准的 矩阵乘法 (GEMM) 硬件加速：利用 GPU 的 Tensor Core 硬件加速，计算效率从访存受限（Memory-bound）转为计算受限（Compute-bound） 内存节省：不需要存储 $C \\times C \\times K$ 的中间张量，只需要存储 $C \\times K$ 的门控矩阵 KDA 的状态更新机制 Delta Rule 的来源 Delta Rule（又称 Widrow-Hoff 学习规则或 LMS 算法）最初是神经网络中的参数更新规则：\n$$\\Delta w = \\eta \\cdot (y - \\hat{y}) \\cdot x$$其中 $(y - \\hat{y})$ 是预测误差（delta），$\\eta$ 是学习率。该规则用误差信号修正权重。\n在序列模型中，Delta Rule 被重新诠释为状态更新机制：\n将历史状态 $\\mathbf{s}_{t-1}$ 视为对当前输入的\u0026quot;预测\u0026quot; 用 $\\mathbf{k}_t^\\top \\mathbf{s}_{t-1}$ 计算\u0026quot;预期 value\u0026quot; 残差 $\\mathbf{v}_t - \\mathbf{k}_t \\mathbf{s}_{t-1}$（行向量 $\\mathbb{R}^{1 \\times V}$）表示\u0026quot;新信息\u0026quot;与\u0026quot;历史预期\u0026quot;的差异，外积 $\\mathbf{k}_t^\\top (\\cdot)$ 将结果映射回状态矩阵 $\\mathbb{R}^{K \\times V}$ 仅用这个差异（而非完整 value）更新状态 KDA 的递推公式 KDA 的状态更新机制（Delta Rule + per-dim gate）：\n$$\\mathbf{s}_t = \\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^\\top (\\mathbf{v}_t - \\mathbf{k}_t (\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1}))$$其中：\n$\\boldsymbol{\\lambda}_t = \\exp(\\mathbf{g}_t^{\\text{raw}}) \\in \\mathbb{R}^K$ 是 per-dimension decay（逐维衰减） 因子（向量） $\\beta_t$ 是 delta rule 的权重 残差项 $\\mathbf{v}_t - \\mathbf{k}_t (\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1})$ 中： $\\mathbf{k}_t (\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1}) \\in \\mathbb{R}^{1 \\times V}$（行向量）是预期 value 与 $\\mathbf{v}_t$ 对比得到残差（行向量形式） 乘积 $\\mathbf{k}_t^\\top (\\cdot)$ 将结果映射回状态矩阵 $\\mathbb{R}^{K \\times V}$ 注意：\n残差中的预期 value 是用 gate 之后的状态 $\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1}$ 计算的 $\\boldsymbol{\\lambda}_t$ 是向量，每个维度 $i$ 有独立的 decay 率 $\\lambda_{t,i}$ 当 $\\boldsymbol{\\lambda}_t = \\lambda_t \\cdot \\mathbf{1}$（所有维度相同），KDA 退化为 GDN 对比：Linear Attention vs KDA 机制 更新规则 特性 Linear Attention $\\mathbf{s}_t = \\mathbf{s}_{t-1} + \\mathbf{k}_t \\otimes \\mathbf{v}_t$ 累积所有历史信息 GDN $\\mathbf{s}_t = \\lambda_t \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^\\top (\\mathbf{v}_t - \\mathbf{k}_t (\\lambda_t \\mathbf{s}_{t-1}))$ 标量 decay（衰减），全局遗忘 KDA $\\mathbf{s}_t = \\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1} + \\beta_t \\cdot \\mathbf{k}_t^\\top (\\mathbf{v}_t - \\mathbf{k}_t (\\boldsymbol{\\lambda}_t \\odot \\mathbf{s}_{t-1}))$ per-dimension decay（逐维衰减），维度选择性遗忘 问题：残差依赖于历史状态 展开 recurrent 的前两步（注意残差中用的是 gated 状态）：\n$$\\mathbf{s}_1 = \\boldsymbol{\\lambda}_1 \\odot \\mathbf{s}_0 + \\beta_1 \\cdot \\mathbf{k}_1^\\top (\\mathbf{v}_1 - \\mathbf{k}_1 (\\boldsymbol{\\lambda}_1 \\odot \\mathbf{s}_0))$$ $$\\mathbf{s}_2 = \\boldsymbol{\\lambda}_2 \\odot \\mathbf{s}_1 + \\beta_2 \\cdot \\mathbf{k}_2^\\top (\\mathbf{v}_2 - \\mathbf{k}_2 (\\boldsymbol{\\lambda}_2 \\odot \\mathbf{s}_1))$$每个 $\\mathbf{s}_i$ 都复杂地依赖于 $\\mathbf{S}$，无法直接用引理 1 写成 $\\mathbf{K}^\\top \\mathbf{V}$ 的形式。\n需要解决的问题：将\u0026quot;依赖于 $\\mathbf{S}$\u0026ldquo;和\u0026quot;不依赖于 $\\mathbf{S}$\u0026ldquo;的部分分离开。\nWY 表示：依赖的分离 目标 让我们把 $\\mathbf{s}_i$ 对 $\\mathbf{S}$ 的依赖显式写出来。定义修正后的 value：\n$$\\tilde{\\mathbf{v}}_i = \\mathbf{v}_i - \\mathbf{k}_i (\\boldsymbol{\\lambda}_i \\odot \\mathbf{s}_{i-1}) \\in \\mathbb{R}^{1 \\times V}$$由于 $\\mathbf{s}_{i-1}$ 本身依赖于 $\\mathbf{S}$，需要找到满足下式的表示：\n$$\\tilde{\\mathbf{v}}_i = \\mathbf{u}_i - \\mathbf{w}_i \\mathbf{S}$$其中 $\\mathbf{u}_i, \\mathbf{w}_i$ 仅依赖于 chunk 内的 $\\{\\mathbf{k}_j, \\mathbf{v}_j\\}$，与 $\\mathbf{S}$ 无关。\n推导 WY 表示 步骤 1：写出 $\\mathbf{s}_i$ 的递推式\n$$\\mathbf{s}_i = \\boldsymbol{\\lambda}_i \\odot \\mathbf{s}_{i-1} + \\beta_i \\cdot \\mathbf{k}_i^\\top (\\mathbf{v}_i - \\mathbf{k}_i (\\boldsymbol{\\lambda}_i \\odot \\mathbf{s}_{i-1}))$$ 步骤 2：定义累积量\n令 $\\boldsymbol{\\Lambda}^{(i)} = \\prod_{j=1}^i \\text{diag}(\\boldsymbol{\\lambda}_j) \\in \\mathbb{R}^{K \\times K}$（对角累积 decay 矩阵），并定义归一化状态：\n$$\\hat{\\mathbf{s}}_i = (\\boldsymbol{\\Lambda}^{(i)})^{-1} \\mathbf{s}_i$$ 步骤 3：转化为下三角线性系统\n将归一化状态 $\\hat{\\mathbf{s}}_i = (\\boldsymbol{\\Lambda}^{(i)})^{-1} \\mathbf{s}_i$ 代入递推式，整理得到：\n$$\\hat{\\mathbf{s}}_i = \\hat{\\mathbf{s}}_{i-1} + \\beta_i \\cdot \\hat{\\mathbf{k}}_i^\\top (\\hat{\\mathbf{v}}_i - \\hat{\\mathbf{k}}_i \\hat{\\mathbf{s}}_{i-1})$$定义归一化后的 key/value（注意 value 不需要相对于状态的 decay）： $$\\hat{\\mathbf{k}}_i = \\mathbf{k}_i \\odot \\exp(\\mathbf{g}_i), \\quad \\hat{\\mathbf{v}}_i = \\mathbf{v}_i$$则残差可写为（行向量）： $$\\tilde{\\mathbf{v}}_i = \\hat{\\mathbf{v}}_i - \\hat{\\mathbf{k}}_i \\hat{\\mathbf{s}}_{i-1} \\in \\mathbb{R}^{1 \\times V}$$展开 $\\hat{\\mathbf{s}}_{i-1}$ 的递归形式（以 $\\hat{\\mathbf{s}}_0 = \\mathbf{S}$ 为初始状态）： $$\\hat{\\mathbf{s}}_{i-1} = \\mathbf{S} + \\sum_{j=1}^{i-1} \\beta_j \\cdot \\hat{\\mathbf{k}}_j \\otimes \\tilde{\\mathbf{v}}_j$$代入残差表达式： $$\\tilde{\\mathbf{v}}_i = \\hat{\\mathbf{v}}_i - \\hat{\\mathbf{k}}_i \\mathbf{S} - \\sum_{j=1}^{i-1} \\beta_j \\cdot \\hat{\\mathbf{k}}_i \\hat{\\mathbf{k}}_j^\\top \\cdot \\tilde{\\mathbf{v}}_j$$注：这里 $\\tilde{\\mathbf{v}}_j \\in \\mathbb{R}^{1 \\times V}$ 是行向量，$\\hat{\\mathbf{k}}_i \\hat{\\mathbf{k}}_j^\\top$ 是标量（$K$ 维内积）。\n整理为矩阵形式。定义：\n矩阵 $\\tilde{\\mathbf{V}}, \\hat{\\mathbf{V}} \\in \\mathbb{R}^{C \\times V}$ 分别以 $\\tilde{\\mathbf{v}}_i, \\hat{\\mathbf{v}}_i$ 为第 $i$ 行 矩阵 $\\mathbf{A}_{kk} \\in \\mathbb{R}^{C \\times C}$ 为严格下三角矩阵，对于 $i \u003e j$：$A_{ij} = \\beta_j (\\mathbf{k}_i \\odot \\exp(\\mathbf{g}_i)) (\\mathbf{k}_j \\odot \\exp(-\\mathbf{g}_j))^\\top$ 则得到线性系统： $$\\tilde{\\mathbf{V}} = \\hat{\\mathbf{V}} - \\mathbf{K}_{\\text{gated}} \\mathbf{S} - \\mathbf{A}_{kk} \\tilde{\\mathbf{V}}$$即： $$(\\mathbf{I} + \\mathbf{A}_{kk}) \\tilde{\\mathbf{V}} = \\hat{\\mathbf{V}} - \\mathbf{K}_{\\text{gated}} \\mathbf{S}$$其中 $\\mathbf{K}_{\\text{gated}}$ 的第 $i$ 行为 $\\mathbf{k}_i \\odot \\exp(\\mathbf{g}_i)$。\n步骤 4：应用引理 2\n由引理 2，$\\mathbf{L} = \\mathbf{I} + \\mathbf{A}_{kk}$ 是单位下三角矩阵，其逆 $\\mathbf{L}^{-1} = (\\mathbf{I} + \\mathbf{A}_{kk})^{-1}$ 也是单位下三角矩阵。求解线性系统：\n$$\\tilde{\\mathbf{V}} = (\\mathbf{I} + \\mathbf{A}_{kk})^{-1} \\cdot \\hat{\\mathbf{V}} - (\\mathbf{I} + \\mathbf{A}_{kk})^{-1} \\cdot \\mathbf{K} \\mathbf{S}$$ 步骤 5：定义 WY 表示\n定义加权矩阵（对应代码中的 u = A @ v 和 w = A @ (exp(g) * k)）： $$\\mathbf{U} = (\\mathbf{I} + \\mathbf{A}_{kk})^{-1} \\text{diag}(\\boldsymbol{\\beta}) \\mathbf{V}$$ $$\\mathbf{W} = (\\mathbf{I} + \\mathbf{A}_{kk})^{-1} \\text{diag}(\\boldsymbol{\\beta}) (\\mathbf{K} \\odot \\exp(\\mathbf{G}))$$其中 $\\hat{\\mathbf{V}}$ 是归一化后的 values（包含 $\\beta$ 和相对 decay），则得到分离形式： $$\\tilde{\\mathbf{V}} = \\mathbf{U} - \\mathbf{W} \\mathbf{S}$$这就是 WY 表示。\n参考资料：WY 表示最初由 Bischof \u0026amp; Van Loan (1987) 13 提出用于 Householder 矩阵乘积的表示，后被 Schreiber \u0026amp; Van Loan (1989) 14 改进为紧凑形式。在序列模型中，DeltaNet 11 首次将这一技术应用于线性注意力的并行计算，Gated DeltaNet 12 进一步引入了门控机制。\nWY 表示的说明 $\\mathbf{W} \\in \\mathbb{R}^{C \\times K}$：加权 keys，第 $i$ 行为 $\\mathbf{w}_i \\in \\mathbb{R}^{1 \\times K}$ $\\mathbf{U} \\in \\mathbb{R}^{C \\times V}$：加权 values，第 $i$ 行为 $\\mathbf{u}_i \\in \\mathbb{R}^{1 \\times V}$ $\\tilde{\\mathbf{v}}_i = \\mathbf{u}_i - \\mathbf{w}_i \\mathbf{S}$：修正后的 value（行向量 $\\mathbb{R}^{1 \\times V}$） 由上述推导，$\\mathbf{U}, \\mathbf{W}$ 与 $\\mathbf{S}$ 无关，可在计算 $\\mathbf{S}$ 之前预先算出。\n核心定理：Chunk-wise Affine 形式 现在我们可以陈述核心定理了。\n定理（KDA/GDN 的 Chunk-wise Affine 形式） 设 chunk 开始时状态为 $\\mathbf{S} \\in \\mathbb{R}^{K \\times V}$，则 chunk 结束时的状态为：\n$$\\mathbf{S}' = \\mathbf{M} \\cdot \\mathbf{S} + \\mathbf{B}$$其中：\nTransition 矩阵 $\\mathbf{M} \\in \\mathbb{R}^{K \\times K}$： $$\\mathbf{M} = \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) - \\mathbf{K}_{\\text{decayed}}^\\top \\mathbf{W}$$ Bias 矩阵：$\\mathbf{B} = \\mathbf{K}_{\\text{decayed}}^\\top \\mathbf{U} \\in \\mathbb{R}^{K \\times V}$ 其中 $\\mathbf{K}_{\\text{decayed}}$ 的第 $i$ 行为 $\\mathbf{k}_i \\odot \\exp(\\mathbf{g}_{\\text{last}} - \\mathbf{g}_i)$，$\\mathbf{g}_{\\text{last}}$ 表示 chunk 最后一个位置的累积 log decay 且 chunk 的输出为：\n$$\\mathbf{O} = (\\mathbf{Q} \\odot \\exp(\\mathbf{g}_q)) \\cdot \\mathbf{S} + \\text{mask}(\\mathbf{A}_{qk}) \\cdot (\\mathbf{U} - \\mathbf{W} \\mathbf{S})$$其中 $\\mathbf{g}_q$ 是 query 的累积 gate，$\\odot$ 表示 广播（broadcasting）乘法。\n证明 状态更新（以 KDA 为例）：\n$$\\begin{aligned} \\mathbf{S}' \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\sum_{i=1}^C \\exp(\\mathbf{g}_{\\text{last}} - \\mathbf{g}_i) \\odot (\\mathbf{k}_i^\\top \\tilde{\\mathbf{v}}_i) \\\\ \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\mathbf{K}_{\\text{decayed}}^\\top \\tilde{\\mathbf{V}} \\quad \\text{（引理 1：外积累加 = 矩阵乘）} \\\\ \u0026= \\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) \\mathbf{S} + \\mathbf{K}_{\\text{decayed}}^\\top (\\mathbf{U} - \\mathbf{W} \\mathbf{S}) \\quad \\text{（代入 WY 表示 } \\tilde{\\mathbf{V}} = \\mathbf{U} - \\mathbf{W} \\mathbf{S} \\text{）} \\\\ \u0026= (\\text{diag}(\\exp(\\mathbf{g}_{\\text{last}})) - \\mathbf{K}_{\\text{decayed}}^\\top \\mathbf{W}) \\mathbf{S} + \\mathbf{K}_{\\text{decayed}}^\\top \\mathbf{U} \\\\ \u0026= \\mathbf{M} \\mathbf{S} + \\mathbf{B} \\end{aligned}$$对于 GDN，将对角矩阵 $\\text{diag}(\\boldsymbol{\\lambda}^{\\text{last}})$ 替换为标量 $\\lambda^{\\text{last}} \\mathbf{I}$ 即可。\n输出计算类似可得。\nAffine 变换的形式 $$\\mathbf{S}' = \\underbrace{\\mathbf{M}}_{K \\times K} \\cdot \\underbrace{\\mathbf{S}}_{K \\times V} + \\underbrace{\\mathbf{B}}_{K \\times V}$$上述形式为仿射变换（Affine Transformation）：\n线性部分：$\\mathbf{M} \\cdot \\mathbf{S}$ 表示历史状态的衰减与投影 平移部分：$\\mathbf{B}$ 表示当前 chunk 引入的新信息 算法实现：从理论到代码 基于上述定理，我们可以写出 chunk-wise 算法：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 def chunk_kda(K, V, Q, g, beta): \u0026#34;\u0026#34;\u0026#34; K, V, Q: [C, K] or [C, V] # chunk 内的 keys, values, queries g: [C, K] # 累积 gate (cumsum of log decay) beta: [C] # delta rule 的权重 \u0026#34;\u0026#34;\u0026#34; # Step 1: 计算下三角矩阵 A (不含 beta) # 利用引理 3 的分解：A = (K * exp(g)) @ (K * exp(-g)).T K_exp = K * exp(g) K_inv = K * exp(-g) A = (K_exp @ K_inv.T).masked_fill(diagonal_mask, 0) # Step 2: 计算 (I + A)^{-1} 通过前向替换（引理 2） # 实际上由于 A = K_exp @ K_inv.T，这就是典型的 WY 表示形式 L = I + A * beta[:, None] # 包含 beta 的单位下三角矩阵 # Step 3: 准备 gated 输入 K_gated = K * exp(g) # [C, K], gated keys V_weighted = V * beta[:, None] # [C, V], V * beta K_weighted = K_gated * beta[:, None] # [C, K], gated K * beta # Step 4: WY 表示（通过前向替换求解 L @ X = Y） # U = L^{-1} @ (V * beta) # W = L^{-1} @ (K * exp(g) * beta) U = forward_substitution(L, V_weighted) # [C, V] W = forward_substitution(L, K_weighted) # [C, K] # Step 5: 计算 Affine 参数 # 注意：K_decayed 的第 i 行为 k_i * exp(g_last - g_i) K_decayed = K * exp(g[-1] - g) # [C, K] decay_last = exp(g[-1]) # [K], 最后一个位置的累积 decay (per-dim) M = diag(decay_last) - K_decayed.T @ W # [K, K] B = K_decayed.T @ U # [K, V] # Step 6: 假设初始状态 S=0，计算 local 状态 S_next = B # 如果 S=0 # Step 7: 计算 chunk 输出（假设 S=0，实际需加上 S 的贡献） Q_gated = Q * exp(g) # [C, K], gated queries O_local = mask(Q_gated @ K.T) @ U # [C, V] return M, B, O_local, S_next, W, U 说明：\nKDA 使用 per-dimension decay（逐维衰减） diag(decay_last)，GDN 使用标量 decay_last * I Query 和 Key 都需要应用 gate，分别用于输出计算和残差计算 g 是累积 gate，维度 [C, K]，表示 per-dim 的 log decay CP 并行与 SM 并行 CP 并行：Affine 链式法则 现在我们有了一致的 Affine 接口，可以自然地扩展到 Context Parallel (CP)。\nAffine 变换的复合性质 引理 4：两个 Affine 变换的复合仍是 Affine 变换。\n设：\n$\\mathbf{S}_1 = \\mathbf{M}_0 \\mathbf{S}_0 + \\mathbf{B}_0$ $\\mathbf{S}_2 = \\mathbf{M}_1 \\mathbf{S}_1 + \\mathbf{B}_1$ 则： $$\\mathbf{S}_2 = \\underbrace{(\\mathbf{M}_1 \\mathbf{M}_0)}_{\\mathbf{M}_{01}} \\mathbf{S}_0 + \\underbrace{(\\mathbf{M}_1 \\mathbf{B}_0 + \\mathbf{B}_1)}_{\\mathbf{B}_{01}}$$CP 算法 假设有 $R$ 个 rank，rank $r$ 持有 chunk $r$。\n步骤 1：Local 计算\n每个 rank 假设 $\\mathbf{S} = \\mathbf{0}$，计算：\n$(\\mathbf{M}_r, \\mathbf{B}_r)$：Affine 参数 $\\mathbf{B}_r$：假设零初始状态时的最终状态（即 local accumulation，对应 KCP 中的 $h_{ext}$） 步骤 2：All-Gather\n收集所有 rank 的 $\\{ (\\mathbf{M}_r, \\mathbf{B}_r) \\}_{r=0}^{R-1}$。\n步骤 3：Prefix Scan（Fold）\nRank $r$ 计算真正的初始状态：\n$$\\mathbf{S}_r = \\sum_{j=0}^{r-1} \\left( \\prod_{k=j+1}^{r-1} \\mathbf{M}_k \\right) \\mathbf{B}_j$$步骤 4：Local 重算\n用正确的 $\\mathbf{S}_r$ 重新计算 chunk 输出：\n$$\\mathbf{O}_r = \\mathbf{O}_r^{\\text{local}} + \\mathbf{Q}_r \\mathbf{S}_r - \\text{mask}(\\mathbf{A}_{qk}) \\mathbf{W}_r \\mathbf{S}_r$$CP 并行的数学基础 CP 并行能够实现，其数学基础在于 Affine 变换的复合性质：\n每个 chunk 是一个 Affine 变换 多个 chunk 的连续作用 = Affine 变换的乘积 跨 rank 的状态传递 = Affine 参数的累积 SM 并行：单卡内的细粒度并行 问题背景 在单卡（Intra-Card）推理场景中，当序列很长时会出现 SM 利用率不足 的问题：\nGPU 有固定数量的 SM（Streaming Multiprocessors，如 A100 有 108 个 SM） 每个 head 的 chunk 数量 = $T / (H \\times C)$，其中 $T$ 是序列长度，$H$ 是 head 数，$C$ 是 chunk size 当序列很长但 head 数较少时，单个 head 的 chunk 数可能超过 SM 数，导致部分 SM 空闲 解决方案：Subsequence 分割 SM 并行（SM Parallel）将长序列分割为多个 subsequence，使得：\n$$\\text{subseq\\_len} = \\text{target\\_chunks} \\times C \\approx \\text{num\\_sms} \\times C$$其中：\n$\\text{num\\_sms}$：GPU 的 SM 数量 $C$：chunk size（通常为 64） 每个 subsequence 包含足够多的 chunks 来饱和所有 SM 数学形式 设原始序列被分割为 $M$ 个 subsequence，每个 subsequence $m$ 有初始状态 $\\mathbf{S}_m$。\n步骤 1：Intra-subsequence CP\n每个 subsequence 内部执行标准的 CP Pre-process：\n计算 $(\\mathbf{M}_m^{\\text{local}}, \\mathbf{B}_m^{\\text{local}})$：假设 $\\mathbf{S}_m = \\mathbf{0}$ 时的 local accumulation 步骤 2：Inter-subsequence Merge\n同一原始序列的多个 subsequence 之间进行状态合并： $$\\mathbf{S}_{m+1} = \\mathbf{M}_m^{\\text{local}} \\cdot \\mathbf{S}_m + \\mathbf{B}_m^{\\text{local}}$$这仍然是 Affine 变换的链式复合。\n步骤 3：Final Computation\n用正确的初始状态重新计算每个 subsequence 的输出。\n与 CP 并行的关系 并行级别 分割维度 通信方式 适用场景 CP 并行 跨 GPU（inter-card） NCCL All-Gather 多卡训练/推理 SM 并行 单卡内（intra-card） 共享内存 单卡长序列推理 两者的数学本质相同：都是 Affine 变换的链式复合，只是粒度不同：\nCP 并行：rank 级别 SM 并行：subsequence 级别 实现要点 动态分割：根据序列长度和 SM 数量动态计算 subseq_len Split Info 管理：维护 subsequence 与原序列的映射关系 两级计算： intracard_pre_scan：并行计算所有 subsequence 的 local $(\\mathbf{M}, \\mathbf{B})$ intracard_merge：合并同一原序列的 subsequence 状态 实现参考：fla/ops/common/intracard_cp.py\n总结 我们从最基本的引理出发，建立了 KDA（及作为其特例的 GDN）的完整数学框架：\n引理 1：外积累加 = 矩阵乘 → chunk-wise 并行的动机 引理 2：下三角矩阵的逆 → WY 表示的理论基础 引理 3：对数衰减的分解 → 矩阵乘法形式的 decay 计算 KDA 的挑战：残差依赖于历史状态 WY 表示：分离依赖，得到 $\\tilde{\\mathbf{V}} = \\mathbf{U} - \\mathbf{W} \\mathbf{S}$ 核心定理：Chunk-wise Affine 形式 $\\mathbf{S}' = \\mathbf{M} \\mathbf{S} + \\mathbf{B}$ CP 并行：Affine 变换的链式复合 关键洞察 WY 表示的本质：将依赖于历史状态 $\\mathbf{S}$ 的部分显式分离，使得并行计算成为可能 Affine 形式的作用：提供统一的状态更新接口，天然支持多级并行（CP、SM） Per-dim decay的优势：允许不同特征维度有独立的遗忘速率，增强表达能力 符号约定 小写 $\\mathbf{s}, \\mathbf{k}, \\mathbf{v}$：token-level 向量 大写 $\\mathbf{S}, \\mathbf{K}, \\mathbf{V}, \\mathbf{M}, \\mathbf{B}$：chunk-level 矩阵 区分 GDN（标量 decay（衰减））和 KDA（per-dimension decay（逐维衰减））只在 transition 矩阵的对角部分 附录：GDN vs KDA 特性 GDN KDA Decay 标量 $\\lambda$ 向量 $\\boldsymbol{\\lambda} \\in \\mathbb{R}^K$ Transition $\\mathbf{M} = \\lambda \\mathbf{I} - \\mathbf{K}^\\top \\mathbf{W}$ $\\mathbf{M} = \\text{diag}(\\boldsymbol{\\lambda}) - \\mathbf{K}^\\top \\mathbf{W}$ 表达力 全局遗忘 维度选择性遗忘 计算 稍快 稍慢 两者都是 Affine 形式，只是 $\\mathbf{M}$ 的对角部分不同。\n参考资料：Gated DeltaNet 详见 Yang et al. (2024) 12，Kimi Delta Attention (KDA) 是其在 per-dimension decay（逐维衰减） 方向的扩展。\n参考资料 本文的数学推导和算法描述基于 Flash Linear Attention (FLA) 框架的实现。\nKatharopoulos, A., et al. (2020). \u0026ldquo;Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention\u0026rdquo;. ICML 2020. https://arxiv.org/abs/2006.16236\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nKimi Team. (2025). \u0026ldquo;Kimi Linear: An Expressive, Efficient Attention Architecture\u0026rdquo;. arXiv:2510.26692. https://arxiv.org/abs/2510.26692\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nChoromanski, K., et al. (2021). \u0026ldquo;Rethinking Attention with Performers\u0026rdquo;. ICLR 2021. https://arxiv.org/abs/2009.14794\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nPeng, B., et al. (2023). \u0026ldquo;RWKV: Reinventing RNNs for the Transformer Era\u0026rdquo;. EMNLP 2023. https://arxiv.org/abs/2305.13048\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nGu, A., \u0026amp; Dao, T. (2023). \u0026ldquo;Mamba: Linear-Time Sequence Modeling with Selective State Spaces\u0026rdquo;. https://arxiv.org/abs/2312.00752\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nDao, T., \u0026amp; Gu, A. (2024). \u0026ldquo;Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality\u0026rdquo;. https://arxiv.org/abs/2405.21060\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nDao, T., \u0026amp; Gu, A. (2024). \u0026ldquo;Mamba2\u0026rdquo; (in \u0026ldquo;Transformers are SSMs\u0026rdquo;). https://arxiv.org/abs/2405.21060\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nYang, S., et al. (2024). \u0026ldquo;Gated Linear Attention Transformers with Hardware-Efficient Training\u0026rdquo;. ICML 2024. https://arxiv.org/abs/2312.06635\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nPeng, B., et al. (2024). \u0026ldquo;Eagle and Finch: RWKV with Matrix-Valued States and Dynamic Recurrence\u0026rdquo;. arXiv:2404.05892. https://arxiv.org/abs/2404.05892\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nPeng, B., et al. (2025). \u0026ldquo;RWKV-7 \u0026lsquo;Goose\u0026rsquo; with Expressive Dynamic State Evolution\u0026rdquo;. arXiv:2503.14456. https://arxiv.org/abs/2503.14456\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nYang, S., et al. (NeurIPS 2024). \u0026ldquo;Parallelizing Linear Transformers with the Delta Rule over Sequence Length\u0026rdquo;. NeurIPS 2024. https://arxiv.org/abs/2406.06484\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nYang, S., Kautz, J., \u0026amp; Hatamizadeh, A. (2024). \u0026ldquo;Gated Delta Networks: Improving Mamba2 with Delta Rule\u0026rdquo;. arXiv:2412.06464. https://arxiv.org/abs/2412.06464\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nBischof, C., \u0026amp; Van Loan, C. (1987). \u0026ldquo;The WY Representation for Products of Householder Matrices\u0026rdquo;. SIAM Journal on Scientific and Statistical Computing, 8(1). https://epubs.siam.org/doi/abs/10.1137/0908009\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nSchreiber, R., \u0026amp; Van Loan, C. (1989). \u0026ldquo;A Storage-Efficient WY Representation for Products of Householder Transformations\u0026rdquo;. SIAM Journal on Scientific and Statistical Computing, 10(1). https://epubs.siam.org/doi/10.1137/0910005\u0026#160;\u0026#x21a9;\u0026#xfe0e;\n","permalink":"https://zhiyuan1i.github.io/posts/kda-mathematics/","summary":"\u003cblockquote\u003e\n\u003cp\u003e本文假设读者熟悉线性代数（矩阵乘法、外积、逆矩阵）和基本的序列模型概念。\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003ch2 id=\"摘要\"\u003e摘要\u003c/h2\u003e\n\u003cp\u003e本文推导了 KDA（Kimi Delta Attention）的 chunk-wise 并行算法。核心贡献：\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e证明 KDA 的 chunk 状态更新可表示为 \u003cstrong\u003eAffine 变换\u003c/strong\u003e：$\\mathbf{S}' = \\mathbf{M}\\mathbf{S} + \\mathbf{B}$\u003c/li\u003e\n\u003cli\u003e通过 \u003cstrong\u003eWY 表示\u003c/strong\u003e 将残差计算分解为与历史状态无关的部分，实现并行计算\u003c/li\u003e\n\u003cli\u003e基于 Affine 变换的复合性质，推导出 \u003cstrong\u003eCP（Context Parallel，上下文并行）\u003c/strong\u003e 的数学基础\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp\u003eKDA 相比标准 Attention 的优势：$O(N)$ 复杂度、常数内存状态、适合超长序列。\u003c/p\u003e\n\u003chr\u003e\n\u003ch2 id=\"目录\"\u003e目录\u003c/h2\u003e\n\u003col\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e5%bc%95%e8%a8%80%e4%bb%8e-transformer-%e5%88%b0-linear-attention\"\u003e引言：从 Transformer 到 Linear Attention\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#linear-attention-%e7%9a%84%e5%8f%91%e5%b1%95%e5%8e%86%e7%a8%8b\"\u003eLinear Attention 的发展历程\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e7%ac%a6%e5%8f%b7%e8%a1%a8%e4%b8%8e%e7%ba%a6%e5%ae%9a\"\u003e符号表与约定\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e7%ba%bf%e6%80%a7%e6%b3%a8%e6%84%8f%e5%8a%9b%e7%ae%80%e5%8d%95%e7%9a%84%e8%b5%b7%e7%82%b9\"\u003e线性注意力：简单的起点\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e8%83%8c%e6%99%af%e4%bb%8e-gdn-%e5%88%b0-kda\"\u003e背景：从 GDN 到 KDA\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e6%a0%b8%e5%bf%83%e5%bc%95%e7%90%86\"\u003e核心引理\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#kda-%e7%9a%84%e7%8a%b6%e6%80%81%e6%9b%b4%e6%96%b0%e6%9c%ba%e5%88%b6\"\u003eKDA 的状态更新机制\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#wy-%e8%a1%a8%e7%a4%ba%e4%be%9d%e8%b5%96%e7%9a%84%e5%88%86%e7%a6%bb\"\u003eWY 表示：依赖的分离\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e6%a0%b8%e5%bf%83%e5%ae%9a%e7%90%86chunk-wise-affine-%e5%bd%a2%e5%bc%8f\"\u003e核心定理：Chunk-wise Affine 形式\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e7%ae%97%e6%b3%95%e5%ae%9e%e7%8e%b0%e4%bb%8e%e7%90%86%e8%ae%ba%e5%88%b0%e4%bb%a3%e7%a0%81\"\u003e算法实现：从理论到代码\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#cp-%e5%b9%b6%e8%a1%8c%e4%b8%8e-sm-%e5%b9%b6%e8%a1%8c\"\u003eCP 并行与 SM 并行\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e6%80%bb%e7%bb%93\"\u003e总结\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e9%99%84%e5%bd%95gdn-vs-kda\"\u003e附录：GDN vs KDA\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"/posts/kda-mathematics/#%e5%8f%82%e8%80%83%e8%b5%84%e6%96%99\"\u003e参考资料\u003c/a\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003chr\u003e\n\u003ch2 id=\"引言从-transformer-到-linear-attention\"\u003e引言：从 Transformer 到 Linear Attention\u003c/h2\u003e\n\u003ch3 id=\"标准-attention-的瓶颈\"\u003e标准 Attention 的瓶颈\u003c/h3\u003e\n\u003cp\u003eTransformer 架构自 2017 年提出以来，已成为自然语言处理和序列建模的主流方法。其核心组件 \u003cstrong\u003eSelf-Attention\u003c/strong\u003e 机制通过计算序列中所有 token 两两之间的注意力权重来捕获长距离依赖：\u003c/p\u003e","title":"KDA（Kimi Delta Attention）的数学原理：从矩阵乘法到 Affine 变换"},{"content":"技术栈 本站使用以下技术构建：\n技术 用途 Hugo 极速静态网站生成器 PaperMod 简洁优雅的 Hugo 主题 GitHub Pages 免费静态网站托管 GitHub Actions 自动部署 特点 极速构建：Hugo 的 Go 实现确保秒级构建 SEO 友好：内置 Open Graph、Twitter Cards、结构化数据 暗/亮模式：自动跟随系统主题 全文搜索：基于 Fuse.js 的站内搜索 响应式设计：完美适配移动端 部署流程 1 本地写作 → Git Push → GitHub Actions → GitHub Pages → 线上访问 完全自动化的部署流程，专注于内容创作。\nPowered by Kimi K2.5 🌙\n","permalink":"https://zhiyuan1i.github.io/posts/tech-stack/","summary":"\u003ch2 id=\"技术栈\"\u003e技术栈\u003c/h2\u003e\n\u003cp\u003e本站使用以下技术构建：\u003c/p\u003e\n\u003ctable\u003e\n  \u003cthead\u003e\n      \u003ctr\u003e\n          \u003cth\u003e技术\u003c/th\u003e\n          \u003cth\u003e用途\u003c/th\u003e\n      \u003c/tr\u003e\n  \u003c/thead\u003e\n  \u003ctbody\u003e\n      \u003ctr\u003e\n          \u003ctd\u003e\u003ca href=\"https://gohugo.io/\"\u003eHugo\u003c/a\u003e\u003c/td\u003e\n          \u003ctd\u003e极速静态网站生成器\u003c/td\u003e\n      \u003c/tr\u003e\n      \u003ctr\u003e\n          \u003ctd\u003e\u003ca href=\"https://github.com/adityatelange/hugo-PaperMod\"\u003ePaperMod\u003c/a\u003e\u003c/td\u003e\n          \u003ctd\u003e简洁优雅的 Hugo 主题\u003c/td\u003e\n      \u003c/tr\u003e\n      \u003ctr\u003e\n          \u003ctd\u003e\u003ca href=\"https://pages.github.com/\"\u003eGitHub Pages\u003c/a\u003e\u003c/td\u003e\n          \u003ctd\u003e免费静态网站托管\u003c/td\u003e\n      \u003c/tr\u003e\n      \u003ctr\u003e\n          \u003ctd\u003e\u003ca href=\"https://github.com/features/actions\"\u003eGitHub Actions\u003c/a\u003e\u003c/td\u003e\n          \u003ctd\u003e自动部署\u003c/td\u003e\n      \u003c/tr\u003e\n  \u003c/tbody\u003e\n\u003c/table\u003e\n\u003ch2 id=\"特点\"\u003e特点\u003c/h2\u003e\n\u003cul\u003e\n\u003cli\u003e\u003cstrong\u003e极速构建\u003c/strong\u003e：Hugo 的 Go 实现确保秒级构建\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003eSEO 友好\u003c/strong\u003e：内置 Open Graph、Twitter Cards、结构化数据\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003e暗/亮模式\u003c/strong\u003e：自动跟随系统主题\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003e全文搜索\u003c/strong\u003e：基于 Fuse.js 的站内搜索\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003e响应式设计\u003c/strong\u003e：完美适配移动端\u003c/li\u003e\n\u003c/ul\u003e\n\u003ch2 id=\"部署流程\"\u003e部署流程\u003c/h2\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cdiv class=\"chroma\"\u003e\n\u003ctable class=\"lntable\"\u003e\u003ctr\u003e\u003ctd class=\"lntd\"\u003e\n\u003cpre tabindex=\"0\" class=\"chroma\"\u003e\u003ccode\u003e\u003cspan class=\"lnt\"\u003e1\n\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/td\u003e\n\u003ctd class=\"lntd\"\u003e\n\u003cpre tabindex=\"0\" class=\"chroma\"\u003e\u003ccode class=\"language-fallback\" data-lang=\"fallback\"\u003e\u003cspan class=\"line\"\u003e\u003cspan class=\"cl\"\u003e本地写作 → Git Push → GitHub Actions → GitHub Pages → 线上访问\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/td\u003e\u003c/tr\u003e\u003c/table\u003e\n\u003c/div\u003e\n\u003c/div\u003e\u003cp\u003e完全自动化的部署流程，专注于内容创作。\u003c/p\u003e\n\u003chr\u003e\n\u003cp\u003e\u003cem\u003ePowered by \u003ca href=\"https://www.moonshot.cn/\"\u003eKimi K2.5\u003c/a\u003e\u003c/em\u003e 🌙\u003c/p\u003e","title":"本站技术栈"},{"content":"Zhiyuan Li AI Infra 工程师，目前就职于 Moonshot AI。\n工作以来一直专注于 Linear Attention 方向的高效实现与优化，很荣幸能参与到 Kimi Linear 和 Kimi Delta Attention (KDA) 的开发工作中，向团队里的优秀同事们学习了很多。\n🔬 关注领域 Linear Attention：探索次二次复杂度的序列建模方法，让长序列更高效 高效推理优化：CUDA 内核优化、内存带宽优化、Tensor Core 加速 模型架构：RWKV-6/7、Gated DeltaNet 等新型注意力机制 🚀 开源贡献 参与了 flash-linear-attention 社区项目 - Efficient implementations of state-of-the-art linear attention models 📝 文章分享 从零开始学 KDA-1 - 以 Infra 视角理解 KDA 并行化 💬 关于本站 这里记录我在 AI Infra 领域的学习心得、技术笔记和一些不成熟的想法。水平有限，如有错误欢迎指出，期待与大家的交流。\n联系方式：\nGitHub: @zhiyuan1i 知乎: @lizhiyuan Email: lizhiyuan@moonshot.cn ","permalink":"https://zhiyuan1i.github.io/about/","summary":"\u003ch2 id=\"zhiyuan-li\"\u003eZhiyuan Li\u003c/h2\u003e\n\u003cp\u003eAI Infra 工程师，目前就职于 \u003ca href=\"https://www.moonshot.cn/\"\u003eMoonshot AI\u003c/a\u003e。\u003c/p\u003e\n\u003cp\u003e工作以来一直专注于 \u003cstrong\u003eLinear Attention\u003c/strong\u003e 方向的高效实现与优化，很荣幸能参与到 \u003ca href=\"https://github.com/MoonshotAI/Kimi-Linear\"\u003eKimi Linear\u003c/a\u003e 和 \u003cstrong\u003eKimi Delta Attention (KDA)\u003c/strong\u003e 的开发工作中，向团队里的优秀同事们学习了很多。\u003c/p\u003e\n\u003chr\u003e\n\u003ch3 id=\"-关注领域\"\u003e🔬 关注领域\u003c/h3\u003e\n\u003cul\u003e\n\u003cli\u003e\u003cstrong\u003eLinear Attention\u003c/strong\u003e：探索次二次复杂度的序列建模方法，让长序列更高效\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003e高效推理优化\u003c/strong\u003e：CUDA 内核优化、内存带宽优化、Tensor Core 加速\u003c/li\u003e\n\u003cli\u003e\u003cstrong\u003e模型架构\u003c/strong\u003e：RWKV-6/7、Gated DeltaNet 等新型注意力机制\u003c/li\u003e\n\u003c/ul\u003e\n\u003ch3 id=\"-开源贡献\"\u003e🚀 开源贡献\u003c/h3\u003e\n\u003cul\u003e\n\u003cli\u003e参与了 \u003ca href=\"https://github.com/fla-org/flash-linear-attention\"\u003e\u003cstrong\u003eflash-linear-attention\u003c/strong\u003e\u003c/a\u003e 社区项目 - Efficient implementations of state-of-the-art linear attention models\u003c/li\u003e\n\u003c/ul\u003e\n\u003ch3 id=\"-文章分享\"\u003e📝 文章分享\u003c/h3\u003e\n\u003cul\u003e\n\u003cli\u003e\u003ca href=\"https://zhuanlan.zhihu.com/p/1989809041849988324\"\u003e从零开始学 KDA-1\u003c/a\u003e - 以 Infra 视角理解 KDA 并行化\u003c/li\u003e\n\u003c/ul\u003e\n\u003chr\u003e\n\u003ch3 id=\"-关于本站\"\u003e💬 关于本站\u003c/h3\u003e\n\u003cp\u003e这里记录我在 AI Infra 领域的学习心得、技术笔记和一些不成熟的想法。水平有限，如有错误欢迎指出，期待与大家的交流。\u003c/p\u003e\n\u003cp\u003e\u003cstrong\u003e联系方式：\u003c/strong\u003e\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003eGitHub: \u003ca href=\"https://github.com/zhiyuan1i\"\u003e@zhiyuan1i\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e知乎: \u003ca href=\"https://www.zhihu.com/people/f6hoks\"\u003e@lizhiyuan\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003eEmail: \u003ca href=\"mailto:lizhiyuan@moonshot.cn\"\u003elizhiyuan@moonshot.cn\u003c/a\u003e\u003c/li\u003e\n\u003c/ul\u003e","title":"关于我"}]