HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

Kimi Delta Attentionはあなたも考案できたはず

You Could Have Come Up with Kimi Delta Attention (blog.doubleword.ai)

269 pointsby AnhTho_FR110 コメント

要約

この記事は、最新のQwenやKimiモデルで使用されているKimi Delta Attention (KDA) を含む、線形アテンションの進化を解説しています。従来のソフトマックスアテンションの計算量の問題を解決するために、線形アテンション、DeltaNet、Gated DeltaNetを経てKDAに至るまでの導出プロセスを、数式を追いつつ平易な言葉で説明しています。最終的には、隠れ状態に関する単純な仮定からKDAの複雑な数式を理解する方法を示します。

全文翻訳

Kimi Delta Attentionはあなたも考案できたはず

注記:この記事では、導出過程の形状を非常に明確にするため(私の量子インスピレーションによる意見として)、ブレケット記法をデフォルトで使用します。上記の数式表記スイッチは、従来の太字ベクトルと明示的な転置を使用して、すべての数式を書き換えます。ブレケットモードでは、∣q⟩\lvert q\rangle は列ベクトル、⟨k∣\langle k\rvert は行ベクトル、⟨k∣q⟩\langle k\rvert q\rangle は数値、そして ∣v⟩⟨k∣\lvert v\rangle\langle k\rvert は行列です。ベクトルはデフォルトで右向きですが、線形アテンションの状態に書き込まれる際、キーは左向きになります。ここでは、1つの因果的アテンションヘッドと実数値ベクトルを使用し、DeltaNetのキーが正規化されていると仮定し、状態がキー空間から値空間へのマッピングを行うものとします。

現代の線形アテンションのバリアントは複雑であり、一見しただけではそれが何を達成しようとしているのかを容易に理解することはできません。参考までに、Kimi Delta Attention(KDA)の状態更新方程式を以下に示します。

\tilde S_t = S_{t-1}\operatorname{Diag}(\alpha_t)
\lvert\widehat v_t\rangle = \tilde S_t\lvert k_t\rangle
\lvert e_t\rangle = \beta_t \left( \lvert v_t\rangle-\lvert\widehat v_t\rangle \right)
S_t = \tilde S_t+\lvert e_t\rangle\langle k_t\rvert
\lvert o_t\rangle = S_t\left(d_k^{-1/2}\lvert q_t\rangle\right)

それらが理解しにくい理由は、過去数年間に開発されてきた線形アテンションのバリアントのファミリーの最新版であり、その複雑さが必然的に膨れ上がっているため、外部からは最新のバリアントはアクセスしにくいように見えるからです。

この記事では、DeltaNetファミリーの線形アテンションバリアントを順を追って説明し、そのうち2つは最新のQwenおよびKimiモデルファミリーで使用されていますが、どのようにして隠れ状態について単純なことを主張することで、同じ方程式に至る可能性があるかを示します。

これが私たちが取るルートです。

smoftmax attention  →  linear attention  →  DeltaNet  →  Gated DeltaNet  →  KDA

KDAを導出した後になって初めて、それを実行する再帰型およびチャンクワイズのTritonプログラムに目を向けます。

1. 二次アテンションから始める

トークン t におけるクエリに対して、通常の因果的ソフトマックスアテンションは次のようになります。

a_{ti} &= \frac{ \exp\!\left(s\langle k_i\rvert q_t\rangle\right) }{ \sum
_{j\leq t} \exp\!\left(s\langle k_j\rvert q_t\rangle\right) }, \qquad s=d_k^{-1/2},\\
\lvert o_t\rangle &= \sum
_{i\leq t}a_{ti}\lvert v_i\rangle.

すべてのアテンション重みはスカラーです。それは1つのキーと1つのクエリの類似性を測定し、その後ソフトマックスがそのクエリのすべてのスコアを分布に変換します。出力は値ベクトルの加重合計です。

長さ T のシーケンス全体で、T^2 のキー・クエリペアが存在します。自己回帰推論中、キーと値を再計算する代わりにキャッシュできますが、キャッシュはシーケンスとともに成長し、新しいクエリごとに履歴全体を検査する必要があります。

この計算を再編成する際の障害はソフトマックスです。その分母は、現在のクエリと以前のすべてのキーに共同で依存します。したがって、今のところ、それを削除します。

1.1 ソフトマックスを削除する

明確にするために、定数スケール s をクエリに吸収します。アテンションの意図的に裸にしたバージョンは次のようになります。

\lvert o_t\rangle = \sum
_{i\leq t} \langle k_i\rvert q_t\rangle \lvert v_i\rangle.

スカラー内積は右に移動できます。

\begin{aligned}
\lvert o_t\rangle &= \sum
_{i\leq t} \lvert v_i\rangle \langle k_i\rvert q_t\rangle\\ &= \left( \sum
_{i\leq t} \lvert v_i\rangle\langle k_i\rvert \right) \lvert q_t\rangle.
\end{aligned}

過去に依存するすべては、固定サイズ V×K の1つの行列に収集できるようになりました。

S_t = \sum
_{i\leq t} \lvert v_i\rangle\langle k_i\rvert

そしてアテンションは、再帰的な書き込みとそれに続く読み取りになります。

\boxed{ \begin{aligned}
S_t &= S_{t-1} + \lvert v_t\rangle\langle k_t\rvert,\\ \lvert o_t\rangle &= S_t\lvert q_t\rangle.
\end{aligned} }

恒等式

(\lvert v\rangle\langle k\rvert)\lvert q\rangle = \langle k\rvert q\rangle\lvert v\rangle

がトリック全体です。外積は行列であり、内積は数値です。もはや過去のすべてのキーと値を保存しません。それらの合計外積を固定サイズの状態 S_t に保存します。

これはシーケンス長に対して二次ではなく線形になります:トークンを1回スキャンし、各ステップで同じ dv×dk の状態を更新します。その効率のために、ソフトマックスの正規化と選択性を破棄しました。より洗練された線形アテンション手法は、特徴マップと正規化を使用しますが、この飾り気のない形式は、DeltaNetを動機付けるメモリの問題を露呈します。

1.2 加算は代入ではない

ペア |v_t⟩⟨k_t| を書き込み、その同じキーで新しい状態をすぐにクエリすると仮定します。

\begin{aligned}
S_t\lvert k_t\rangle &= \left( S_{t-1} + \lvert v_t\rangle\langle k_t\rvert \right) \lvert k_t\rangle\\ &= S_{t-1}\lvert k_t\rangle + \lvert v_t\rangle \underbrace{\langle k_t\rvert k_t\rangle}_{1}\\ &= S_{t-1}\lvert k_t\rangle+\lvert v_t\rangle.
\end{aligned}

書き込みは状態を |v_t⟩ にしません。それは、メモリが既に返した値に |v_t⟩ を追加します。

古い状態が既に正しい値を返していた場合、加算的な書き込みにより新しい状態はその値の2倍を返します。より一般的には、キーは互いに直交しないため、各書き込みは以前の書き込みに干渉する可能性があります。線形アテンションはコンパクトな連想メモリを提供してくれましたが、その更新は、私たちが望むものよりも = に近い動作である += のように振る舞います。

2. DeltaNet:値ではなく誤差を書き込む

DeltaNet は、条件なしの線形アテンション書き込みをデルタルール補正に置き換えます。それを導出するには2つの有用な方法があります。

2.1 導出1:書き込みが読み戻せることを要求する

トークン t を書き込む前に、メモリに新しいキーが現在何と関連付けられているかを尋ねます。

\lvert\widehat v_t\rangle = S_{t-1}\lvert k_t\rangle.

メモリに |v_t⟩ を返してほしい場合、値全体を追加するのではなく、差分のみを追加する必要があります。

\lvert v_t\rangle-\lvert\widehat v_t\rangle.

学習可能な書き込み強度 β_t ∈ [0,1] を導入し、次のように定義します。

\lvert e_t\rangle = \beta_t \left( \lvert v_t\rangle - S_{t-1}\lvert k_t\rangle \right).

次に、この誤差を現在のキーで書き込みます。

\boxed{ S_t = S_{t-1} + \lvert e_t\rangle\langle k_t\rvert. }

そしてすぐに同じキーを読み取ります。

\begin{aligned}
S_t\lvert k_t\rangle &= S_{t-1}\lvert k_t\rangle + \lvert e_t\rangle \langle k_t\rvert k_t\rangle\\ &= (1-\beta_t)S_{t-1}\lvert k_t\rangle + \beta_t\lvert v_t\rangle.
\end{aligned}

β_t = 1 の場合、結果は正確に |v_t⟩ になります。より小さい β_t は、古い予測部分をターゲットに近づけます。

補正はキー空間でも局所的です。現在のキーに直交する任意のクエリ |x⟩ に対して、

\langle k_t\rvert x\rangle=0 \quad\Longrightarrow\quad (S_t-S_{t-1})\lvert x\rangle = \lvert e_t\rangle \underbrace{\langle k_t\rvert x\rangle}_{0} =0.

したがって、ランク1の書き込みは、選択されたキー方向の応答を変更し、直交するすべての方向はそのままにします。

2.2 導出2:再構築損失で1ステップ取る

同じ更新は、オンライン学習の目的から導き出されます。現在のキー・値ペアを線形マップ S の1つのトレーニング例として扱います。

\mathcal L_t(S) = \frac12 \left\| S\lvert k_t\rangle-\lvert v_t\rangle \right\|_2^2.

状態に対する勾配は次のようになります。

\nabla_S\mathcal L_t(S) = \left( S\lvert k_t\rangle-\lvert v_t\rangle \right) \langle k_t\rvert.

これは明らかに外積です:値空間の予測誤差に、その誤差が観測されたキーのブラを掛けたものです。S_{t-1} からサイズ β_t の1つの勾配降下ステップを取ります。

\begin{aligned}
S_t &= S_{t-1} - \beta_t\nabla_S\mathcal L_t(S_{t-1})\\ &= S_{t-1} - \beta_t \left( S_{t-1}\lvert k_t\rangle-\lvert v_t\rangle \right) \langle k_t\rvert\\ &= S_{t-1} + \beta_t \left( \lvert v_t\rangle-S_{t-1}\lvert k_t\rangle \right) \langle k_t\rvert.
\end{aligned}

これは、即時再構築を要求することによって得られた更新と正確に一致します。2つの解釈は同じです。

  • メモリ操作として、β_t は古い関連付けをどれだけ強く置き換えるかを制御します。
  • オンライン学習として、β_t はステップサイズです。
  • 線形代数として、変化はランク1の外積です。
2.3 DeltaNetの状態遷移

誤差を展開すると、DeltaNetは構造化された状態遷移と新しい入力の組み合わせとして現れます。

\begin{aligned}
S_t &= S_{t-1} + \beta_t \left( \lvert v_t\rangle-S_{t-1}\lvert k_t\rangle \right) \langle k_t\rvert\\ &= S_{t-1} \left( I-\beta_t\lvert k_t\rangle\langle k_t\rvert \right) + \beta_t\lvert v_t\rangle\langle k_t\rvert.
\end{aligned}

単位キーの場合、I - β_t|k_t⟩⟨k_t| は現在のキー方向で固有値 1 - β_t を持ち、すべての直交方向で固有値 1 を持ちます。これは、新しいものを追加する前に、現在のキーに沿った古い関連付けを削除します。

DeltaNetは書き込みを修正します。まだ状態の寿命は修正していません。

3. Gated DeltaNet:古い情報は時々消えるべき

線形状態は、履歴全体を1つの行列に圧縮します。読み取り

S_t\lvert q\rangle = \sum
_{i\leq t} \langle k_i\rvert q\rangle\lvert v_i\rangle

は、S_t に折りたたまれた個々の古いトークンをスキップすることを選択できません。重なり合うすべての保存された方向が寄与します。デルタルールは現在のキーの周りの状態を修正できますが、他の方向の古い情報は利用可能であり、将来の読み取りを歪める可能性があります。

したがって、古い状態を使用する前に忘れる方法が必要です。学習済みのスカラー保持ゲート α_t ∈ [0,1] を導入します。

\tilde S_t = \alpha_t S_{t-1}.

このゲート付き状態に対して同じデルタルールを実行します。

\begin{aligned}
\tilde S_t &= \alpha_tS_{t-1}, &&\text{forget},\\ \lvert\widehat v_t\rangle &= \tilde S_t\lvert k_t\rangle, &&\text{predict},\\ \lvert e_t\rangle &= \beta_t \left( \lvert v_t\rangle-\lvert\widehat v_t\rangle \right), &&\text{correct},\\ S_t &= \tilde S_t+\lvert e_t\rangle\langle k_t\rvert, &&\text{write}.
\end{aligned}

これはGated DeltaNetです。順序が重要です:最初に忘却し、保持された状態から予測し、その予測を補正します。忘却する前に予測した場合、誤差は更新するメモリとは異なるメモリを表します。

再帰を展開すると、次のようになります。

S_t = \alpha_tS_{t-1} \left( I-\beta_t\lvert k_t\rangle\langle k_t\rvert \right) + \beta_t\lvert v_t\rangle\langle k_t\rvert.

デルタルールはターゲットを絞った置換を提供し、スカラーゲートは全体的な消去を提供します。それらは異なる問題を解決し、補完的です。

しかし、α_t は依然として行列全体に対して1つの決定を下します。モデルは、すべてのキーチャネルを同じレートで保持または忘却する必要があります。

4. Kimi Delta Attention:各チャネルを独立に忘れる

Kimi Delta Attention は、Gated DeltaNetのスカラー保持をベクトル α_t ∈ [0,1]^{d_k} に置き換えます。ベクトルを対角に配置します。

D_t = \operatorname{Diag}(\alpha_t) \in\mathbb R^{d_k\times d_k}.

状態はキーを値にマッピングするため、キーチャネルは S の列です。右乗算は、各列に異なる保持係数を適用します。

\tilde S_t = S_{t-1}D_t.

それ以外はすべて、既に導出したデルタルールです。

\begin{aligned}
\tilde S_t &= S_{t-1}D_t, &&\text{forget each key channel},\\ \lvert\widehat v_t\rangle &= \tilde S_t\lvert k_t\rangle, &&\text{predict},\\ \lvert e_t\rangle &= \beta_t \left( \lvert v_t\rangle-\lvert\widehat v_t\rangle \right), &&\text{correct},\\ S_t &= \tilde S_t+\lvert e_t\rangle\langle k_t\rvert, &&\text{write},\\ \lvert o_t\rangle &= S_t(s\lvert q_t\rangle), \qquad s=d_k^{-1/2}, &&\text{read}.
\end{aligned}

これがKDAです。Gated DeltaNetと比較して、概念的な変更は単なる昇格です。

\alpha_t \quad\longrightarrow\quad D_t=\operatorname{Diag}(\alpha_t).

その効果は顕著です:1つのチャネルをクリアしながら、別のチャネルを保持できます。

4.1 なぜ遷移が対角行列プラス低ランクなのか

KDAの補正を展開します。

\begin{aligned}
S_t &= S_{t-1}D_t + \beta_t \left( \lvert v_t\rangle - S_{t-1}D_t\lvert k_t\rangle \right) \langle k_t\rvert\\ &= S_{t-1} \underbrace{ D_t \left( I-\beta_t\lvert k_t\rangle\langle k_t\rvert \right) }_{A_t} + \beta_t\lvert v_t\rangle\langle k_t\rvert.
\end{aligned}

キー空間の遷移は次のようになります。

\begin{aligned}
A_t &= D_t-\beta_tD_t\lvert k_t\rangle\langle k_t\rvert\\ &= D_t-\lvert b_t\rangle\langle a_t\rvert,
\end{aligned}

ここで

\lvert b_t\rangle=D_t\lvert k_t\rangle, \qquad \langle a_t\rvert=\beta_t\langle k_t\rvert.

したがって、A_t は対角行列からランク1の行列を引いたものです:対角行列プラス低ランク(DPLR)遷移。「DPLR」は、キー空間に作用する dk×dk の遷移を表します。メモリ状態自体は依然として dv×dk の行列 S_t です。

旅全体をコンパクトに要約できます。

メカニズム状態更新追加するもの
線形アテンション`S +v⟩⟨k
DeltaNet`S + β(v⟩ - S
Gated DeltaNetαS を適用し、デルタ更新を実行全体状態の忘却
KDASD を適用し、デルタ更新を実行キーチャネルごとの忘却

実装では通常、g_t = log α_t を g_t ≤ 0 として格納し、保持係数を exp(g_t) として取得します。参照コードで使用される転置された dk×dv レイアウトでは、再帰はわずか5行です。

state = state * g_t.exp().unsqueeze(-1)
prediction = einsum("bhkv,bhk->bhv", state, k_t)
residual = beta_t.unsqueeze(-1) * (v_t - prediction)
state = state + einsum("bhk,bhv->bhkv", k_t, residual)
output = einsum("bhk,bhkv->bhv", q_t * scale, state)

公式のnaive_recurrent_kda を参照してください。

5. 融合再帰型Tritonカーネル

上記の再帰は、自己回帰デコードの自然な実装です。KDAには2つの主要な実行モードがあります。

モード最適な用途並列単位
融合再帰型デコード、短いシーケンス、ステートフルサービング1つのシーケンス、値ヘッド、値タイル
チャンクワイズトレーニングと長いプリフィルチャンク、トークンサブチャンク、キー/値タイル

Tritonの再帰型起動は、シーケンス、値ヘッド、および32幅の値タイルごとに1つのプログラムを使用します。

BK = triton.next_power_of_2(K)
BV = 32
grid = (triton.cdiv(V, BV) * N * HV,)

fused_recurrent_kda_fwd の起動コードを参照してください。

BK は、通常のサポート構成でキー次元をカバーします。各プログラムは、実装の転置状態の [BK, BV] タイルを所有し、順序でトークンをループします。異なる値タイル、ヘッド、およびシーケンスは独立して実行されます。

カーネルは、再帰のほぼ文字通りの転写です。

state *= tl.exp(g_t[:, None])
prediction = tl.sum(state * k_t[:, None], axis=0)
residual = beta_t * (v_t - prediction)
state += k_t[:, None] * residual[None, :]
out_t = tl.sum(state * (q_t * SCALE)[:, None], axis=0)

予測と読み取りは削減であり、書き込みは外積です。これはデコードに最適です。その場合、一度に1つの新しいトークンしか利用できません。トレーニングや長いプリフィルにはあまり魅力的ではありません。なぜなら、これらのベクトル操作は、テンソルコアが最も効率的な大規模行列乗算にならないからです。

これが、同じ再帰を別の視点から見る動機となります。

6. チャンクワイズKDA

チャンクワイズKDAは、CC トークンをまとめて処理します。それは、トークンごとの再帰と同じ状態と出力を生成する必要がありますが、作業を行列積に再編成します。

各チャンク c について、2つの結果が必要です。

  1. 入力状態 S_c を与えられたチャンク全体の後の状態 S_{c+1}。
  2. チャンク内のすべての因果的トークン出力。

唯一の難しさは、トークン i のデルタ誤差が、同じチャンク内の前のトークンによる書き込みに依存することです。4トークンの例で、それらの依存関係を明確にします。

6.1 4トークンチャンクの減衰表記

トークン 0, 1, 2, 3 を取り、

D_i = \operatorname{Diag}(\alpha_i).

チャンク境界とトークン i 間の累積減衰は次のようになります。

D_{0:i} = D_0D_1\cdots D_i.

トークン j での書き込みをトークン i まで伝搬させる減衰は次のようになります。

D_{j+1:i} = D_{j+1}D_{j+2}\cdots D_i, \qquad j<i,

介入する減衰がない場合、D_{i+1:i} = I となります。これらの行列はすべて対角行列なので、互いに可換です。

6.2 仮の誤差から始める

まず、各トークンが適切に減衰された入力状態を見ることができるが、チャンク内の他の書き込みはどれも見ることができないと仮定します。

\lvert\bar e_i\rangle = \beta_i \left( \lvert v_i\rangle - S_cD_{0:i}\lvert k_i\rangle \right).

4つのトークンでは、これは4つの仮の値空間誤差ケットを生成します。

|ē_0⟩, |ē_1⟩, |ē_2⟩, |ē_3⟩。

これらは並列に計算するのは簡単ですが、最初のもの以外はすべて間違っています。同じチャンク内の前の書き込みも、それらの予測に寄与します。

6.3 因果関係を復元する

トークン 0 にはチャンク内の先行する書き込みがないため、

\lvert e_0\rangle = \lvert\bar e_0\rangle.

トークン 1 は、D_1 を通過した後のトークン 0 の書き込みを見ます。

\lvert e_1\rangle = \lvert\bar e_1\rangle - \beta_1 \langle k_0\rvert D_1\lvert k_1\rangle \lvert e_0\rangle.

トークン 2 は、先行する両方の書き込みを見ます。

\begin{aligned}
\lvert e_2\rangle &= \lvert\bar e_2\rangle\\ &\quad- \beta_2 \langle k_0\rvert D_1D_2\lvert k_2\rangle \lvert e_0\rangle\\ &\quad- \beta_2 \langle k_1\rvert D_2\lvert k_2\rangle \lvert e_1\rangle.
\end{aligned}

トークン 3 は、すべて3つを見ます。

\begin{aligned}
\lvert e_3\rangle &= \lvert\bar e_3\rangle\\ &\quad- \beta_3 \langle k_0\rvert D_1D_2D_3\lvert k_3\rangle \lvert e_0\rangle\\ &\quad- \beta_3 \langle k_1\rvert D_2D_3\lvert k_3\rangle \lvert e_1\rangle\\ &\quad- \beta_3 \langle k_2\rvert D_3\lvert k_3\rangle \lvert e_2\rangle.
\end{aligned}

各ブラケット ⟨k_j∣D_{j+1:i}∣k_i⟩ はスカラーです。因果的キー・キー係数を定義します。

\rho_{ij} = \beta_i \langle k_j\rvert D_{j+1:i}\lvert k_i\rangle, \qquad j<i.

すると、すべての4つの式はコンパクトな形式になります。

\begin{aligned}
\lvert e_0\rangle &=\lvert\bar e_0\rangle,\\ \lvert e_1\rangle &=\lvert\bar e_1\rangle-\rho_{10}\lvert e_0\rangle,\\ \lvert e_2\rangle &=\lvert\bar e_2\rangle-\rho_{20}\lvert e_0\rangle -\rho_{21}\lvert e_1\rangle,\\ \lvert e_3\rangle &=\lvert\bar e_3\rangle-\rho_{30}\lvert e_0\rangle -\rho_{31}\lvert e_1\rangle-\rho_{32}\lvert e_2\rangle.
\end{aligned}

係数を厳密に下三角行列に収集します。

R_c = \begin{bmatrix} 0&0&0&0\\ \rho_{10}&0&0&0\\ \rho_{20}&\rho_{21}&0&0\\ \rho_{30}&\rho_{31}&\rho_{32}&0 \end{bmatrix}, \qquad A^{kk}_c=(I+R_c)^{-1}.

誤差ケットを列としてスタックします。

\bar E_c = \begin{bmatrix} \lvert\bar e_0\rangle& \lvert\bar e_1\rangle& \lvert\bar e_2\rangle& \lvert\bar e_3\rangle \end{bmatrix},

E_c についても同様です。因果的代入は次のようになります。

E_c = \bar E_c\left(A^{kk}_c\right)^\mathsf T.

実装は、一般的な密な逆行列を形成する必要はありません。I + R_c は対角線に1を持つ三角行列であるため、この操作は因果的三角ソルブであり、各値チャネルに独立に適用されます。

6.4 状態を高速転送する

チャンクの終わりに、入力状態は4つの減衰すべてを通過しました。チャンク内の各書き込みは、それ以降の減衰のみを通過しました。

S_{c+1} = S_cD_0D_1D_2D_3 + \lvert e_0\rangle\langle k_0\rvert D_1D_2D_3 + \lvert e_1\rangle\langle k_1\rvert D_2D_3 + \lvert e_2\rangle\langle k_2\rvert D_3 + \lvert e_3\rangle\langle k_3\rvert.

チャンク境界に到着したキーを行とする行列を定義します。

K_c^{\mathrm{end}} = \begin{bmatrix} \langle k_0\rvert D_1D_2D_3\\ \langle k_1\rvert D_2D_3\\ \langle k_2\rvert D_3\\ \langle k_3\rvert \end{bmatrix}.

E_c が誤差ケットを列としてスタックするため、4つの外積書き込みはすべて1つの行列乗算になります。

\boxed{ S_{c+1} = S_cD_{0:3} + E_cK_c^{\mathrm{end}}. }

これは必要な最初のチャンク結果です:再帰状態を一度に4トークン進めます。

6.5 すべての因果的出力を計算する

KDAは書き込み後に読み取ります。S^{[i+1]} がトークン i の後のローカル状態である場合、

\lvert o_i\rangle = sS^{[i+1]}\lvert q_i\rangle.

4つの出力を展開します。

\begin{aligned}
\lvert o_0\rangle &= sS_cD_0\lvert q_0\rangle + s\langle k_0\rvert q_0\rangle\lvert e_0\rangle,\\ \lvert o_1\rangle &= sS_cD_0D_1\lvert q_1\rangle\\ &\quad+ s\langle k_0\rvert D_1\lvert q_1\rangle\lvert e_0\rangle + s\langle k_1\rvert q_1\rangle\lvert e_1\rangle,\\ \lvert o_2\rangle &= sS_cD_0D_1D_2\lvert q_2\rangle\\ &\quad+ s\langle k_0\rvert D_1D_2\lvert q_2\rangle\lvert e_0\rangle\\ &\quad+ s\langle k_1\rvert D_2\lvert q_2\rangle\lvert e_1\rangle + s\langle k_2\rvert q_2\rangle\lvert e_2\rangle,\\ \lvert o_3\rangle &= sS_cD_0D_1D_2D_3\lvert q_3\rangle\\ &\quad+ s\langle k_0\rvert D_1D_2D_3\lvert q_3\rangle\lvert e_0\rangle\\ &\quad+ s\langle k_1\rvert D_2D_3\lvert q_3\rangle\lvert e_1\rangle\\ &\quad+ s\langle k_2\rvert D_3\lvert q_3\rangle\lvert e_2\rangle + s\langle k_3\rvert q_3\rangle\lvert e_3\rangle.
\end{aligned}

因果的クエリ・キー係数を定義します。

\chi_{ij} = s\langle k_j\rvert D_{j+1:i}\lvert q_i\rangle, \qquad j\leq i,

そして、係数を下三角読み取り行列に配置します。

A^{qk}_c = \begin{bmatrix} \chi_{00}&0&0&0\\ \chi_{10}&\chi_{11}&0&0\\ \chi_{20}&\chi_{21}&\chi_{22}&0\\ \chi_{30}&\chi_{31}&\chi_{32}&\chi_{33} \end{bmatrix}.

ゼロは因果関係を強制します。対角線は、トークン i が自身の書き込みを行った後に読み取るため、含まれています。

境界減衰クエリケットを列としてスタックし、

Q_c^{\mathrm{boundary}} = \begin{bmatrix} D_0\lvert q_0\rangle& D_0D_1\lvert q_1\rangle& D_0D_1D_2\lvert q_2\rangle& D_0D_1D_2D_3\lvert q_3\rangle \end{bmatrix},

出力ケットも同様にスタックします。4つの出力すべては次のようになります。

O_c = sS_cQ_c^{\mathrm{boundary}} + E_c\left(A^{qk}_c\right)^\mathsf T.

最初の行列乗算は、適切に減衰された入力状態を読み取ります。2番目は、チャンク内で行われた書き込みの因果的寄与を追加します。これが2番目に要求されるチャンク結果です。

6.6 Tritonパイプラインの構成方法

チャンクワイズ実装は、上記の数式を単一のモノリシックカーネルではなく、カーネル起動のパイプラインに変換します。

まず、チャンクローカルな累積対数減衰を計算します。2つのプレフィックスサム間の差は、保持ベクトルの長いチェーンを明示的に乗算することなく、D_{j+1:i} をエンコードします。次に、因果的 A^{qk} および A^{kk} インタラクション行列を構築します。A^{kk} は、チャンクの修正された書き込みのWYスタイル表現を形成するために使用されます。

状態カーネルは、唯一のチャンク間スキャンを実行し、各チャンクの入力状態を生成し、そのデルタ誤差を解決します。これらの入力状態がわかると、出力カーネルは異なるチャンクとタイルのトークンを並列に計算できます。

実際のソースには、これらのステージの融合およびタイル化されたバリアントが含まれています。特に、チャンクオフ対角線と三角ソルブカーネルを融合する前に、16トークンの対角インタラクションブロックを計算します。フォワードデータフローはおおよそ次のようになります。

def chunkwise_kda(q, k, v, log_decay, beta, initial_state, scale):
    # Within-chunk prefix sums. G[i] - G[j] encodes the decay
    # carrying a state or write from token j to token i.
    G = chunk_local_cumsum(log_decay)

    # Build causal query-key interactions and the triangular system
    # that resolves dependencies between delta errors.
    A_qk_diag, A_kk_diag = intra_token_parallel(
        q, k, G, beta, scale
    )
    A_qk, A_kk = inter_and_triangular_solve(
        q, k, G, beta, A_qk_diag, A_kk_diag, scale
    )

    # Convert the chunk into its WY pseudo-key/pseudo-value form.
    W, U, K_to_end = build_wy_factors(k, v, G, beta, A_kk)

    # The only recurrence left is over chunk boundaries.
    H, E, final_state = scan_chunk_states(
        K_to_end, W, U, G, initial_state
    )

    # Combine reads from each incoming chunk state with causal
    # contributions from writes made inside that chunk.
    output = calculate_outputs(q, E, G, A_qk, H, scale)
    return output, final_state

参照ソースでは、これらのステージはchunk_kda_fwd によってオーケストレーションされています。その主要な実装エントリポイントは chunk_kda_fwd_intra、chunk_gated_delta_rule_fwd_h、および chunk_gla_fwd_o_gk です。コード内の v_new、h、kg のような名前は、解決された誤差、入力チャンク状態、およびチャンクの終わりに減衰されたキーに対応します。

したがって、再帰型カーネルとチャンクワイズカーネルは、2つの異なるアテンションメカニズムではありません。それらは同じKDA再帰に対する2つのスケジュールです:低遅延デコードのためのシリアルベクトル演算、およびテンソルコアを多用するトレーニングとプリフィルのためのチャンク化された行列演算です。