update gdn definitions

definitions/gdn/{gdn_decode_qk16_v32_d128_k_last.json → gdn_decode_qk4_v8_d128_k_last.json}

@@ -1,6 +1,6 @@
 {
-  "name": "gdn_decode_qk16_v32_d128_k_last",
-  "description": "Gated Delta Net decode with GVA configuration and k-last state layout. Single-token generation with recurrent state update. Captured from Qwen3 Next linear attention layers.",
+  "name": "gdn_decode_qk4_v8_d128_k_last",
+  "description": "Gated Delta Net decode with GVA configuration and k-last state layout. Single-token generation with recurrent state update. Captured from Qwen3 Next linear attention layers (TP=4).",
   "op_type": "gdn",
   "tags": [
     "stage:decode",
@@ -20,18 +20,18 @@
     },
     "num_q_heads": {
       "type": "const",
-      "value": 16,
-      "description": "Number of query heads (same as key heads in GVA mode)."
+      "value": 4,
+      "description": "Number of query heads (same as key heads in GVA mode, TP=4, 16/4=4)."
     },
     "num_k_heads": {
       "type": "const",
-      "value": 16,
-      "description": "Number of key heads."
+      "value": 4,
+      "description": "Number of key heads (TP=4, 16/4=4)."
     },
     "num_v_heads": {
       "type": "const",
-      "value": 32,
-      "description": "Number of value heads (GVA: more value heads than query heads)."
+      "value": 8,
+      "description": "Number of value heads (GVA: more value heads than query heads, TP=4, 32/4=8)."
     },
     "head_size": {
       "type": "const",
@@ -45,43 +45,75 @@
   ],
   "inputs": {
     "q": {
-      "shape": ["batch_size", "seq_len", "num_q_heads", "head_size"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_q_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Query tensor for single token decode."
     },
     "k": {
-      "shape": ["batch_size", "seq_len", "num_k_heads", "head_size"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_k_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Key tensor for single token decode."
     },
     "v": {
-      "shape": ["batch_size", "seq_len", "num_v_heads", "head_size"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_v_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Value tensor for single token decode."
     },
     "state": {
-      "shape": ["batch_size", "num_v_heads", "head_size", "head_size"],
+      "shape": [
+        "batch_size",
+        "num_v_heads",
+        "head_size",
+        "head_size"
+      ],
       "dtype": "float32",
       "description": "Recurrent state in k-last layout [B, H, V, K].",
       "optional": true
     },
     "A_log": {
-      "shape": ["num_v_heads"],
+      "shape": [
+        "num_v_heads"
+      ],
       "dtype": "float32",
       "description": "Log decay parameter (learnable). Used to compute g = exp(-exp(A_log) * softplus(a + dt_bias))."
     },
     "a": {
-      "shape": ["batch_size", "seq_len", "num_v_heads"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_v_heads"
+      ],
       "dtype": "bfloat16",
       "description": "Input-dependent decay from projection."
     },
     "dt_bias": {
-      "shape": ["num_v_heads"],
+      "shape": [
+        "num_v_heads"
+      ],
       "dtype": "float32",
       "description": "Decay bias (learnable). Added to 'a' before softplus."
     },
     "b": {
-      "shape": ["batch_size", "seq_len", "num_v_heads"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_v_heads"
+      ],
       "dtype": "bfloat16",
       "description": "Update gate input from projection. beta = sigmoid(b)."
     },
@@ -93,15 +125,25 @@
   },
   "outputs": {
     "output": {
-      "shape": ["batch_size", "seq_len", "num_v_heads", "head_size"],
+      "shape": [
+        "batch_size",
+        "seq_len",
+        "num_v_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Attention output. Shape follows num_v_heads in GVA mode."
     },
     "new_state": {
-      "shape": ["batch_size", "num_v_heads", "head_size", "head_size"],
+      "shape": [
+        "batch_size",
+        "num_v_heads",
+        "head_size",
+        "head_size"
+      ],
       "dtype": "float32",
       "description": "Updated recurrent state in k-last layout [B, H, V, K]."
     }
   },
-  "reference": "import math\nimport torch\nimport torch.nn.functional as F\n\n\ndef matmul(a: torch.Tensor, b: torch.Tensor):\n    \"\"\"Float32 matmul for numerical stability.\"\"\"\n    return a.float() @ b.float()\n\n\n@torch.no_grad()\ndef run(q, k, v, state, A_log, a, dt_bias, b, scale):\n    \"\"\"\n    Gated Delta Net decode reference implementation (k-last layout).\n    \n    State layout: [B, H, V, K] (k-last, K dimension at the end)\n    \n    Gate computation:\n    g = exp(-exp(A_log) * softplus(a + dt_bias))\n    beta = sigmoid(b)\n    \n    Delta rule update:\n    state_new = g * state_old + k^T @ (beta * v + (1-beta) * k @ state_old) - k^T @ (k @ state_old)\n    output = scale * q @ state_new\n    \"\"\"\n    B, T, num_q_heads, K = q.shape\n    _, _, num_k_heads, _ = k.shape\n    _, _, num_v_heads, V = v.shape\n    num_heads = num_v_heads\n    device = q.device\n    \n    assert num_q_heads == 16\n    assert num_k_heads == 16\n    assert num_v_heads == 32\n    assert K == 128 and V == 128\n    assert T == 1\n    \n    if scale is None or scale == 0.0:\n        scale = 1.0 / math.sqrt(K)\n    \n    # Compute g and beta from raw parameters\n    x = a.float() + dt_bias.float()  # [B, 1, HV]\n    g = torch.exp(-torch.exp(A_log.float()) * F.softplus(x))  # [B, 1, HV]\n    beta = torch.sigmoid(b.float())  # [B, 1, HV]\n    \n    q_f32 = q.squeeze(1).float()\n    k_f32 = k.squeeze(1).float()\n    v_f32 = v.squeeze(1).float()\n    g_f32 = g.squeeze(1).float()\n    beta_f32 = beta.squeeze(1).float()\n    \n    if state is not None:\n        state_f32 = state.float()\n    else:\n        state_f32 = torch.zeros(B, num_heads, V, K, dtype=torch.float32, device=device)\n    \n    q_exp = q_f32.repeat_interleave(num_v_heads // num_q_heads, dim=1)\n    k_exp = k_f32.repeat_interleave(num_v_heads // num_k_heads, dim=1)\n    \n    new_state = torch.zeros_like(state_f32)\n    output = torch.zeros(B, num_heads, V, dtype=torch.float32, device=device)\n    \n    for b_idx in range(B):\n        for h_idx in range(num_heads):\n            q_h = q_exp[b_idx, h_idx]\n            k_h = k_exp[b_idx, h_idx]\n            v_h = v_f32[b_idx, h_idx]\n            h_state = state_f32[b_idx, h_idx].clone().transpose(-1, -2)  # [V,K] -> [K,V]\n            g_val = g_f32[b_idx, h_idx]\n            beta_val = beta_f32[b_idx, h_idx]\n            \n            old_state = g_val * h_state\n            old_v = k_h @ old_state\n            new_v = beta_val * v_h + (1 - beta_val) * old_v\n            state_remove = k_h.unsqueeze(1) @ old_v.unsqueeze(0)\n            state_update = k_h.unsqueeze(1) @ new_v.unsqueeze(0)\n            h_state = old_state - state_remove + state_update\n            \n            output[b_idx, h_idx] = scale * (q_h @ h_state)\n            new_state[b_idx, h_idx] = h_state.transpose(-1, -2)  # [K,V] -> [V,K]\n    \n    output = output.unsqueeze(1).to(torch.bfloat16)\n    return {\"output\": output, \"new_state\": new_state}"
+  "reference": "import math\nimport torch\nimport torch.nn.functional as F\n\n\ndef matmul(a: torch.Tensor, b: torch.Tensor):\n    \"\"\"Float32 matmul for numerical stability.\"\"\"\n    return a.float() @ b.float()\n\n\n@torch.no_grad()\ndef run(q, k, v, state, A_log, a, dt_bias, b, scale):\n    \"\"\"\n    Gated Delta Net decode reference implementation (k-last layout).\n    \n    State layout: [B, H, V, K] (k-last, K dimension at the end)\n    \n    Gate computation:\n    g = exp(-exp(A_log) * softplus(a + dt_bias))\n    beta = sigmoid(b)\n    \n    Delta rule update:\n    state_new = g * state_old + k^T @ (beta * v + (1-beta) * k @ state_old) - k^T @ (k @ state_old)\n    output = scale * q @ state_new\n    \"\"\"\n    B, T, num_q_heads, K = q.shape\n    _, _, num_k_heads, _ = k.shape\n    _, _, num_v_heads, V = v.shape\n    num_heads = num_v_heads\n    device = q.device\n    \n    assert num_q_heads == 4\n    assert num_k_heads == 4\n    assert num_v_heads == 8\n    assert K == 128 and V == 128\n    assert T == 1\n    \n    if scale is None or scale == 0.0:\n        scale = 1.0 / math.sqrt(K)\n    \n    # Compute g and beta from raw parameters\n    x = a.float() + dt_bias.float()  # [B, 1, HV]\n    g = torch.exp(-torch.exp(A_log.float()) * F.softplus(x))  # [B, 1, HV]\n    beta = torch.sigmoid(b.float())  # [B, 1, HV]\n    \n    q_f32 = q.squeeze(1).float()\n    k_f32 = k.squeeze(1).float()\n    v_f32 = v.squeeze(1).float()\n    g_f32 = g.squeeze(1).float()\n    beta_f32 = beta.squeeze(1).float()\n    \n    if state is not None:\n        state_f32 = state.float()\n    else:\n        state_f32 = torch.zeros(B, num_heads, V, K, dtype=torch.float32, device=device)\n    \n    q_exp = q_f32.repeat_interleave(num_v_heads // num_q_heads, dim=1)\n    k_exp = k_f32.repeat_interleave(num_v_heads // num_k_heads, dim=1)\n    \n    new_state = torch.zeros_like(state_f32)\n    output = torch.zeros(B, num_heads, V, dtype=torch.float32, device=device)\n    \n    for b_idx in range(B):\n        for h_idx in range(num_heads):\n            q_h = q_exp[b_idx, h_idx]\n            k_h = k_exp[b_idx, h_idx]\n            v_h = v_f32[b_idx, h_idx]\n            h_state = state_f32[b_idx, h_idx].clone().transpose(-1, -2)  # [V,K] -> [K,V]\n            g_val = g_f32[b_idx, h_idx]\n            beta_val = beta_f32[b_idx, h_idx]\n            \n            old_state = g_val * h_state\n            old_v = k_h @ old_state\n            new_v = beta_val * v_h + (1 - beta_val) * old_v\n            state_remove = k_h.unsqueeze(1) @ old_v.unsqueeze(0)\n            state_update = k_h.unsqueeze(1) @ new_v.unsqueeze(0)\n            h_state = old_state - state_remove + state_update\n            \n            output[b_idx, h_idx] = scale * (q_h @ h_state)\n            new_state[b_idx, h_idx] = h_state.transpose(-1, -2)  # [K,V] -> [V,K]\n    \n    output = output.unsqueeze(1).to(torch.bfloat16)\n    return output, new_state"
 }

definitions/gdn/{gdn_prefill_qk16_v32_d128_k_last.json → gdn_prefill_qk4_v8_d128_k_last.json}

@@ -1,6 +1,6 @@
 {
-  "name": "gdn_prefill_qk16_v32_d128_k_last",
-  "description": "Gated Delta Net prefill with GVA configuration and k-last state layout. The state is in k-last layout [N, H, V, K]. Captured from Qwen3 Next linear attention layers.",
+  "name": "gdn_prefill_qk4_v8_d128_k_last",
+  "description": "Gated Delta Net prefill with GVA configuration and k-last state layout. The state is in k-last layout [N, H, V, K]. Captured from Qwen3 Next linear attention layers (TP=4).",
   "op_type": "gdn",
   "tags": [
     "stage:prefill",
@@ -17,18 +17,18 @@
     },
     "num_q_heads": {
       "type": "const",
-      "value": 16,
-      "description": "Number of query heads (same as key heads in GVA mode)."
+      "value": 4,
+      "description": "Number of query heads (same as key heads in GVA mode, TP=4, 16/4=4)."
     },
     "num_k_heads": {
       "type": "const",
-      "value": 16,
-      "description": "Number of key heads."
+      "value": 4,
+      "description": "Number of key heads (TP=4, 16/4=4)."
     },
     "num_v_heads": {
       "type": "const",
-      "value": 32,
-      "description": "Number of value heads (GVA: more value heads than query heads)."
+      "value": 8,
+      "description": "Number of value heads (GVA: more value heads than query heads, TP=4, 32/4=8)."
     },
     "head_size": {
       "type": "const",
@@ -45,48 +45,77 @@
   ],
   "inputs": {
     "q": {
-      "shape": ["total_seq_len", "num_q_heads", "head_size"],
+      "shape": [
+        "total_seq_len",
+        "num_q_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Query tensor."
     },
     "k": {
-      "shape": ["total_seq_len", "num_k_heads", "head_size"],
+      "shape": [
+        "total_seq_len",
+        "num_k_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Key tensor."
     },
     "v": {
-      "shape": ["total_seq_len", "num_v_heads", "head_size"],
+      "shape": [
+        "total_seq_len",
+        "num_v_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Value tensor."
     },
     "state": {
-      "shape": ["num_seqs", "num_v_heads", "head_size", "head_size"],
+      "shape": [
+        "num_seqs",
+        "num_v_heads",
+        "head_size",
+        "head_size"
+      ],
       "dtype": "float32",
       "description": "Recurrent state in k-last layout [N, H, V, K].",
       "optional": true
     },
     "A_log": {
-      "shape": ["num_v_heads"],
+      "shape": [
+        "num_v_heads"
+      ],
       "dtype": "float32",
       "description": "Log decay parameter (learnable). Used to compute g = exp(-exp(A_log) * softplus(a + dt_bias))."
     },
     "a": {
-      "shape": ["total_seq_len", "num_v_heads"],
+      "shape": [
+        "total_seq_len",
+        "num_v_heads"
+      ],
       "dtype": "bfloat16",
       "description": "Input-dependent decay from projection."
     },
     "dt_bias": {
-      "shape": ["num_v_heads"],
+      "shape": [
+        "num_v_heads"
+      ],
       "dtype": "float32",
       "description": "Decay bias (learnable). Added to 'a' before softplus."
     },
     "b": {
-      "shape": ["total_seq_len", "num_v_heads"],
+      "shape": [
+        "total_seq_len",
+        "num_v_heads"
+      ],
       "dtype": "bfloat16",
       "description": "Update gate input from projection. beta = sigmoid(b)."
     },
     "cu_seqlens": {
-      "shape": ["len_cu_seqlens"],
+      "shape": [
+        "len_cu_seqlens"
+      ],
       "dtype": "int64",
       "description": "Cumulative sequence lengths for variable-length batching."
     },
@@ -98,15 +127,24 @@
   },
   "outputs": {
     "output": {
-      "shape": ["total_seq_len", "num_v_heads", "head_size"],
+      "shape": [
+        "total_seq_len",
+        "num_v_heads",
+        "head_size"
+      ],
       "dtype": "bfloat16",
       "description": "Attention output. Shape follows num_v_heads in GVA mode."
     },
     "new_state": {
-      "shape": ["num_seqs", "num_v_heads", "head_size", "head_size"],
+      "shape": [
+        "num_seqs",
+        "num_v_heads",
+        "head_size",
+        "head_size"
+      ],
       "dtype": "float32",
       "description": "Updated recurrent state in k-last layout [N, H, V, K]."
     }
   },
-  "reference": "import math\nimport torch\nimport torch.nn.functional as F\n\n\ndef matmul(a: torch.Tensor, b: torch.Tensor):\n    \"\"\"Float32 matmul for numerical stability.\"\"\"\n    return a.float() @ b.float()\n\n\n@torch.no_grad()\ndef run(q, k, v, state, A_log, a, dt_bias, b, cu_seqlens, scale):\n    \"\"\"\n    Gated Delta Net prefill reference implementation (k-last layout).\n    \n    State layout: [H, V, K] (k-last, K dimension at the end)\n    \n    Gate computation:\n    g = exp(-exp(A_log) * softplus(a + dt_bias))\n    beta = sigmoid(b)\n    \n    Delta rule update:\n    state_new = g * state_old + k^T @ (beta * v + (1-beta) * k @ state_old) - k^T @ (k @ state_old)\n    output = scale * q @ state_new\n    \"\"\"\n    total_seq_len, num_q_heads, head_size = q.shape\n    num_v_heads = v.shape[1]\n    num_k_heads = k.shape[1]\n    num_sab_heads = max(num_q_heads, num_v_heads)\n    num_seqs = cu_seqlens.size(0) - 1\n    device = q.device\n\n    assert num_q_heads == 16\n    assert num_k_heads == 16\n    assert num_v_heads == 32\n    assert head_size == 128\n\n    if scale is None or scale == 0.0:\n        scale = 1.0 / math.sqrt(head_size)\n\n    # Compute g and beta from raw parameters\n    x = a.float() + dt_bias.float()  # [total_seq_len, HV]\n    g = torch.exp(-torch.exp(A_log.float()) * F.softplus(x))  # [total_seq_len, HV]\n    beta = torch.sigmoid(b.float())  # [total_seq_len, HV]\n\n    q_exp = q.repeat_interleave(num_v_heads // num_q_heads, dim=1)\n    k_exp = k.repeat_interleave(num_v_heads // num_k_heads, dim=1)\n\n    output = torch.zeros(\n        (total_seq_len, num_sab_heads, head_size), dtype=torch.bfloat16, device=device\n    )\n    new_state = torch.zeros(\n        (num_seqs, num_sab_heads, head_size, head_size), dtype=torch.float32, device=device\n    )\n\n    for seq_idx in range(num_seqs):\n        seq_start = int(cu_seqlens[seq_idx].item())\n        seq_end = int(cu_seqlens[seq_idx + 1].item())\n        seq_len = seq_end - seq_start\n\n        if seq_len <= 0:\n            continue\n\n        if state is not None:\n            state_HKV = state[seq_idx].clone().float().transpose(-1, -2)  # [H,V,K] -> [H,K,V]\n        else:\n            state_HKV = torch.zeros(\n                (num_sab_heads, head_size, head_size), dtype=torch.float32, device=device\n            )\n\n        for i in range(seq_len):\n            t = seq_start + i\n            q_H1K = q_exp[t].unsqueeze(1).float()\n            k_H1K = k_exp[t].unsqueeze(1).float()\n            v_H1V = v[t].unsqueeze(1).float()\n            g_H11 = g[t].unsqueeze(1).unsqueeze(2)\n            beta_H11 = beta[t].unsqueeze(1).unsqueeze(2)\n\n            old_state_HKV = g_H11 * state_HKV\n            old_v_H1V = matmul(k_H1K, old_state_HKV)\n            new_v_H1V = beta_H11 * v_H1V + (1 - beta_H11) * old_v_H1V\n            state_remove = torch.einsum('hkl,hlv->hkv', k_H1K.transpose(-1, -2), old_v_H1V)\n            state_update = torch.einsum('hkl,hlv->hkv', k_H1K.transpose(-1, -2), new_v_H1V)\n            state_HKV = old_state_HKV - state_remove + state_update\n\n            o_H1V = scale * matmul(q_H1K, state_HKV)\n            output[t] = o_H1V.squeeze(1).to(torch.bfloat16)\n\n        new_state[seq_idx] = state_HKV.transpose(-1, -2)  # [H,K,V] -> [H,V,K]\n\n    return {\"output\": output, \"new_state\": new_state}"
+  "reference": "import math\nimport torch\nimport torch.nn.functional as F\n\n\ndef matmul(a: torch.Tensor, b: torch.Tensor):\n    \"\"\"Float32 matmul for numerical stability.\"\"\"\n    return a.float() @ b.float()\n\n\n@torch.no_grad()\ndef run(q, k, v, state, A_log, a, dt_bias, b, cu_seqlens, scale):\n    \"\"\"\n    Gated Delta Net prefill reference implementation (k-last layout).\n    \n    State layout: [H, V, K] (k-last, K dimension at the end)\n    \n    Gate computation:\n    g = exp(-exp(A_log) * softplus(a + dt_bias))\n    beta = sigmoid(b)\n    \n    Delta rule update:\n    state_new = g * state_old + k^T @ (beta * v + (1-beta) * k @ state_old) - k^T @ (k @ state_old)\n    output = scale * q @ state_new\n    \"\"\"\n    total_seq_len, num_q_heads, head_size = q.shape\n    num_v_heads = v.shape[1]\n    num_k_heads = k.shape[1]\n    num_sab_heads = max(num_q_heads, num_v_heads)\n    num_seqs = cu_seqlens.size(0) - 1\n    device = q.device\n\n    assert num_q_heads == 4\n    assert num_k_heads == 4\n    assert num_v_heads == 8\n    assert head_size == 128\n\n    if scale is None or scale == 0.0:\n        scale = 1.0 / math.sqrt(head_size)\n\n    # Compute g and beta from raw parameters\n    x = a.float() + dt_bias.float()  # [total_seq_len, HV]\n    g = torch.exp(-torch.exp(A_log.float()) * F.softplus(x))  # [total_seq_len, HV]\n    beta = torch.sigmoid(b.float())  # [total_seq_len, HV]\n\n    q_exp = q.repeat_interleave(num_v_heads // num_q_heads, dim=1)\n    k_exp = k.repeat_interleave(num_v_heads // num_k_heads, dim=1)\n\n    output = torch.zeros(\n        (total_seq_len, num_sab_heads, head_size), dtype=torch.bfloat16, device=device\n    )\n    new_state = torch.zeros(\n        (num_seqs, num_sab_heads, head_size, head_size), dtype=torch.float32, device=device\n    )\n\n    for seq_idx in range(num_seqs):\n        seq_start = int(cu_seqlens[seq_idx].item())\n        seq_end = int(cu_seqlens[seq_idx + 1].item())\n        seq_len = seq_end - seq_start\n\n        if seq_len <= 0:\n            continue\n\n        if state is not None:\n            state_HKV = state[seq_idx].clone().float().transpose(-1, -2)  # [H,V,K] -> [H,K,V]\n        else:\n            state_HKV = torch.zeros(\n                (num_sab_heads, head_size, head_size), dtype=torch.float32, device=device\n            )\n\n        for i in range(seq_len):\n            t = seq_start + i\n            q_H1K = q_exp[t].unsqueeze(1).float()\n            k_H1K = k_exp[t].unsqueeze(1).float()\n            v_H1V = v[t].unsqueeze(1).float()\n            g_H11 = g[t].unsqueeze(1).unsqueeze(2)\n            beta_H11 = beta[t].unsqueeze(1).unsqueeze(2)\n\n            old_state_HKV = g_H11 * state_HKV\n            old_v_H1V = matmul(k_H1K, old_state_HKV)\n            new_v_H1V = beta_H11 * v_H1V + (1 - beta_H11) * old_v_H1V\n            state_remove = torch.einsum('hkl,hlv->hkv', k_H1K.transpose(-1, -2), old_v_H1V)\n            state_update = torch.einsum('hkl,hlv->hkv', k_H1K.transpose(-1, -2), new_v_H1V)\n            state_HKV = old_state_HKV - state_remove + state_update\n\n            o_H1V = scale * matmul(q_H1K, state_HKV)\n            output[t] = o_H1V.squeeze(1).to(torch.bfloat16)\n\n        new_state[seq_idx] = state_HKV.transpose(-1, -2)  # [H,K,V] -> [H,V,K]\n\n    return output, new_state"
 }