Upload README.md with huggingface_hub

README.md

@@ -16,28 +16,26 @@ size_categories:
   - 1K<n<10K
 ---
 
-# Wan2.2 Production Values — VSA Block-Sparse Attention Inputs
+# Wan2.2 Production Values — VSA Block-Sparse Attention Inputs + Reference
 
 Real, captured **production** inputs for the Video Sparse Attention (VSA) fine
 block-sparse attention stage of **Wan2.2 T2V-A14B**, recorded from an actual
-`generate.py` run at **832×480 / 81 frames**. These are intended as a *fixed,
-non-gameable* benchmark for anyone proposing a faster VSA forward-attention
-kernel: optimize on **these tensors**, score against the reference at the stated
-tolerance.
+`generate.py` run at **832×480 / 81 frames**, plus the **reference Triton kernel**
+and the **scoring rule**.
 
-## Why this exists
+This is a *fixed, non-gameable* benchmark for proposing a faster VSA forward
+kernel: **optimize on these exact tensors, score against the reference at the
+tolerance below.** You do **not** get to substitute your own input generator —
+that loophole (sliding-window / head-broadcast `q2k_idx`, small-magnitude N(0,1)
+q/k, all-full blocks, loose tolerance) is exactly what these captures close.
 
-VSA fine attention is non-causal 64×64 block-sparse attention. A kernel can look
-fast in a microbenchmark by exploiting an *input generator* (sliding-window /
-head-broadcast `q2k_idx`, small-magnitude `N(0,1)` q/k, all-full blocks, loose
-tolerance) — and then be wrong on real data. These captures remove that escape
-hatch:
+## Files
 
-- **Real per-head, content-dependent `topk_idx`** (not a sliding window, not
-  broadcast across heads).
-- **Partial cubes** via `variable_block_sizes` (cube-major padding; not all-full).
-- **Real large-magnitude logits**, including a capture with an **outlier head
-  that overflows a one-pass softmax** (see `call_outlier.pt`).
+| file | contents |
+|---|---|
+| `standalone_kernel.py` | **reference kernel** `_attn_fwd_sparse` (`wan22:triton64`, verbatim from production) + host launcher `triton_block_sparse_attn_forward(q,k,v,topk_idx,vbs) -> (o, M)` |
+| `call_0021.pt` / `call_0101.pt` / `call_0139.pt` | clean captures (steps 0/2/3): `q,k,v,topk_idx,vbs` (+ `call,step,block`) |
+| `call_outlier.pt` | **outlier/overflow** capture: `q,k,v,idx,vbs` **plus bundled `o_triton`/`m_triton` ground truth** (`idx` == `topk_idx`). A one-pass softmax (no row-max subtraction) produces **833,360 non-finite values in 1 of 40 heads** here — the case any deployable kernel must survive. |
 
 ## Shapes (t2v-A14B @ 832×480 / 81f)
 
@@ -51,18 +49,9 @@ hatch:
 S_padded = 39936 = 624 cubes × 64        (cube-major tiled/padded)
 real tokens = 32760 = 21 × 30 × 52       (before cube padding)
 Nq = Nkv  = 624 = ceil(21/4)·ceil(30/4)·ceil(52/4) = 6 × 8 × 13
-topk = 78  (87.5% sparsity: 78/624),  D = 128,  sm_scale = 1/sqrt(128)
+topk = 78  (87.5% sparsity),  D = 128,  sm_scale = 1/sqrt(128)
 ```
 
-## Files
-
-| file | schema | notes |
-|---|---|---|
-| `call_0021.pt` | `q,k,v,topk_idx,vbs` + `call,step,block` | step 0, block 21 |
-| `call_0101.pt` | same | step 2, block 21 |
-| `call_0139.pt` | same | step 3, block 19 |
-| `call_outlier.pt` | `q,k,v,idx,vbs` + `o_cuda,o_triton,m_cuda,m_triton` | **outlier/overflow** capture; `idx` == `topk_idx`. Bundles the Triton reference output. A one-pass (no row-max-subtraction) kernel produces **833,360 non-finite values in 1 of 40 heads** here — the case any deployable kernel must survive. |
-
 ## Operator contract
 
 Non-causal block-sparse attention, BSHD:
@@ -70,24 +59,57 @@ Non-causal block-sparse attention, BSHD:
 out = softmax((q @ k_selected^T) / sqrt(D)) @ v_selected
 ```
 For each `(batch, head, query_cube)`, `topk_idx` names the selected KV cubes;
-`vbs[c]` masks padded tokens inside cube `c` (attend only the first `vbs[c]`
-of 64). Reference: the production Triton kernel `_attn_fwd_sparse`
-(`wan22:triton64`) — 64×64 block-sparse FlashAttention-2 with TMA descriptors,
-online softmax with row-max subtraction.
+`vbs[c]` masks padded tokens inside cube `c` (attend only the first `vbs[c]` of 64).
+
+## Scoring / loss  (the rule)
 
-## Suggested acceptance bar (what "as good as production" means)
+A candidate kernel `cand(q, k, v, topk_idx, vbs) -> o` (bf16, `(1,39936,40,128)`)
+**passes** a capture iff, against the reference output `o_ref`:
 
-Match the Triton reference **at least as tightly as our deployed CUDA kernel does**:
+1. **finite:** every element of `o` is finite (no NaN/Inf) — enforced on **every**
+   capture, including `call_outlier.pt`;
+2. **per-head cosine ≥ 0.9999:** `min over (b,h)` of `cos(o[b,:,h,:], o_ref[b,:,h,:]) ≥ 0.9999`
+   (a global average can hide a few wrong heads — it is checked **per head**);
+3. **elementwise:** `max|o − o_ref| ≤ 3e-2` and `mean|o − o_ref| ≤ 1e-4` (bf16-level).
 
-- **cosine ≥ 0.9999** vs the Triton reference output, **checked per (batch, head)**
-  (a global average can hide a few wrong heads),
-- **elementwise** max|Δ| ≤ ~3e-2, mean|Δ| ≤ ~1e-4 (bf16-level),
-- **all outputs finite on every capture, including `call_outlier.pt`** (no NaN/Inf),
-- timing measured warmed, kernel-only (CUDA events), same GPU (B200 / sm_100a).
+`o_ref` is `triton_block_sparse_attn_forward(...)[0]` for the clean captures, and
+the bundled `o_triton` for `call_outlier.pt`.
 
-For reference, our deployed CUDA kernel hits cosine ≈ 0.999999 on the clean
-captures and stays finite on the outlier head (via an exact fallback for the
-overflowing slice).
+**Win condition:** pass all four captures, and have lower **warmed, kernel-only**
+latency (CUDA events, B200 / sm_100a) than the deployed baseline. For reference,
+the deployed CUDA kernel hits **cosine ≈ 0.999999** on the clean captures, stays
+finite on the outlier head, and runs at **~4.7–5.0 ms** on these inputs.
+
+### Reference scorer
+
+```python
+import torch, glob, os
+from standalone_kernel import triton_block_sparse_attn_forward
+
+def per_head_cos(a, b):              # a,b: (1, S, H, D)
+    a = a.float(); b = b.float()
+    a = a.permute(0,2,1,3).reshape(a.shape[2], -1)   # (H, S*D)
+    b = b.permute(0,2,1,3).reshape(b.shape[2], -1)
+    return torch.nn.functional.cosine_similarity(a, b, dim=1)   # (H,)
+
+def score(cand, path):
+    d = torch.load(path, weights_only=True)
+    q, k, v = d["q"].cuda(), d["k"].cuda(), d["v"].cuda()
+    idx = d.get("topk_idx", d.get("idx")).cuda().contiguous()
+    vbs = d["vbs"].cuda().contiguous()
+    o_ref = d["o_triton"].cuda() if "o_triton" in d else \
+            triton_block_sparse_attn_forward(q, k, v, idx, vbs)[0]
+    o = cand(q, k, v, idx, vbs)                       # <-- your kernel
+    finite = bool(torch.isfinite(o).all())
+    coss   = per_head_cos(o, o_ref)
+    diff   = (o.float() - o_ref.float()).abs()
+    ok = finite and coss.min() >= 0.9999 and diff.max() <= 3e-2 and diff.mean() <= 1e-4
+    print(f"{os.path.basename(path):16s} finite={finite} "
+          f"min_head_cos={coss.min():.6f} max|Δ|={diff.max():.2e} -> {'PASS' if ok else 'FAIL'}")
+    return ok
+
+# all(score(my_kernel, f) for f in sorted(glob.glob('call_*.pt')))
+```
 
 ## Load
 
@@ -97,8 +119,7 @@ d = torch.load("call_0021.pt", weights_only=True)
 q, k, v = d["q"], d["k"], d["v"]            # (1, 39936, 40, 128) bf16
 topk_idx = d["topk_idx"]                     # (1, 40, 624, 78) int32
 vbs = d["vbs"]                               # (624,) int32
-# call_outlier.pt uses key "idx" instead of "topk_idx" and also ships
-# o_triton / m_triton as ground truth.
+# call_outlier.pt uses key "idx" instead of "topk_idx" and ships o_triton/m_triton.
 ```
 
 Captured from Wan2.2 T2V-A14B (Apache-2.0 model). Tensors are intermediate