Add loader + taxonomy tools

tools/sass_dataloader_stub.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""
+SASS-augmented trace dataloader stub.
+
+Cross-attention architecture: trace queries, SASS keys/values -> per-timestep
+features.
+
+This stub is the data-side contract for that architecture. It loads
+`tensor_input.npz` (the [24, T] ViT input) and `sass_modality.npz` (per-kernel
+[N_pc, F] SASS matrices) for a single motif and yields the tensors a future
+torch `nn.Module` would consume. No torch dependency — this host is CPU-only
+and torch isn't installed; the same shapes carry over to PyTorch one-to-one.
+
+Shape contract per sample:
+
+  trace_input          : float32 [C=24, T=512]              ViT input image
+  regime_family        : float32 [T=512, F=4]               per-bin one-hot family
+  subregime            : float32 [T=512, Z=20]              multi-hot within family
+  structural           : float32 [T=512, K=17]              per-kernel structural attrs
+  boundaries           : float32 [T=512]                    Gaussian-smoothed transition target
+  gt_segments          : list[(start, end, fam, sub[20], struct[17])]  TAS transcript
+  workload_l1          : int64   [T=512]                    per-bin single L1 id (-1 idle)
+  workload_l2          : int64   [T=512]                    per-bin single L2 id (-1 idle)
+  workload_l1_multihot : float32 [T=512, 12]                per-bin multi-hot L1 (overlap)
+  workload_l2_multihot : float32 [T=512, 73]                per-bin multi-hot L2 (overlap)
+  multihot_n_active    : float32 [T=512]                    # concurrent L1 classes per bin
+  mask_any             : float32 [T=512]                    1 = some kernel runs
+  bin_kernel_id        : int64   [T=512]                    which kernel (-1 = idle)
+  sass_matrix          : float32 [K, N_pc_max, F=9]         per-kernel SASS, padded
+  sass_pc_mask         : float32 [K, N_pc_max]              1 on real PCs, 0 on pad
+
+Cross-attention wiring (forward-pass pseudocode in the docstring below):
+  Q = trace_patch_embeddings              [B, S_q, d]   from the ViT trunk
+  K = sass_proj(sass_matrix[bin_k])       [B, N_pc, d]  per-bin kernel lookup
+  V = sass_proj(sass_matrix[bin_k])       [B, N_pc, d]
+  attn = softmax(Q K^T / sqrt(d)) * sass_pc_mask
+  out  = attn @ V                         [B, S_q, d]
+
+The per-bin kernel index is the bridge between the time grid (from nsys
+kernel_intervals) and the SASS matrix store (per-kernel-function). For
+unprofiled bins (`bin_kernel_id == -1`) the convention is to set Q's attention
+output to zero — i.e. the trace-only path is preserved when SASS isn't
+applicable.
+
+Usage:
+  python tools/sass_dataloader_stub.py kernels/vector_add/_out
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+
+@dataclass
+class SASSSample:
+    """One motif's worth of data, in the shape a SASS-augmented ViT consumes."""
+
+    trace_input: np.ndarray      # float32 [C, T]   — tensor_input.npz `data`
+    counter_names: list[str]
+    time_edges_ns: np.ndarray    # int64   [T+1]
+    regime_family: Optional[np.ndarray]            # float32 [T, F=4]
+    regime_family_names: Optional[list[str]]
+    subregime: Optional[np.ndarray]                # float32 [T, Z=20]
+    subregime_names: Optional[list[str]]
+    subregime_family_idx: Optional[np.ndarray]     # int64   [Z]
+    structural: Optional[np.ndarray]               # float32 [T, K=17]
+    structural_names: Optional[list[str]]
+    boundaries: Optional[np.ndarray]               # float32 [T]
+    gt_segments: Optional[np.ndarray]              # object [S] of 5-tuples
+    mask_any: Optional[np.ndarray]                 # float32 [T]
+    mask_profiled: Optional[np.ndarray]            # float32 [T]
+    # Single-label + additive multi-hot (overlapping-label) workload targets.
+    workload_l1: Optional[np.ndarray]              # int64   [T]   (-1 = unlabeled)
+    workload_l2: Optional[np.ndarray]              # int64   [T]   (-1 = unlabeled)
+    workload_l1_multihot: Optional[np.ndarray]     # float32 [T, 12]  multi-label head target
+    workload_l2_multihot: Optional[np.ndarray]     # float32 [T, 73]
+    multihot_n_active: Optional[np.ndarray]        # float32 [T]   # concurrent L1 classes
+    mask_multilabel: Optional[np.ndarray]          # float32 [T]   1 where >=1 class active
+    vocab_l1: Optional[list[str]]
+    vocab_l2: Optional[list[str]]
+    bin_kernel_id: np.ndarray    # int64   [T]      — -1 for idle bins
+    sass_matrix: np.ndarray      # float32 [K, N_pc_max, F]
+    sass_pc_mask: np.ndarray     # float32 [K, N_pc_max]
+    sass_column_names: list[str]
+    sass_kernel_names: list[str]  # length K (functions, demangled)
+
+
+def _bin_kernel_index(time_edges_ns: np.ndarray,
+                      kernels: np.ndarray) -> np.ndarray:
+    """For each time bin, return the index (into `kernels`) of the kernel that
+    overlaps the bin's center, or -1 if no kernel overlaps.
+
+    Bins are half-open [edges[t], edges[t+1]); kernel intervals are inclusive.
+    """
+    if kernels.size == 0:
+        return np.full(time_edges_ns.shape[0] - 1, -1, dtype=np.int64)
+    centers = (time_edges_ns[:-1] + time_edges_ns[1:]) // 2
+    starts = kernels[:, 0]
+    ends = kernels[:, 1]
+    idx = np.clip(np.searchsorted(starts, centers, side="right") - 1,
+                  0, len(kernels) - 1)
+    inside = (centers >= starts[idx]) & (centers <= ends[idx])
+    return np.where(inside, idx, -1).astype(np.int64)
+
+
+def _bin_kernel_function_index(
+    bin_kernel_id: np.ndarray, kernels: np.ndarray,
+    sass_kernel_names: list[str],
+    nsys_kernel_names: Optional[list[str]],
+    launch_function_index: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """Map per-bin kernel-launch index -> per-bin kernel-function index.
+
+    SASS matrices are keyed by kernel *function*, not by individual launch.
+    Two precomputed inputs let us avoid the legacy "function-0 for every
+    active bin" fallback on heterogeneous traces:
+      - `launch_function_index[K]`: the per-launch function index already
+        baked into `tensor_input.npz` (post-migration). When present, every
+        active bin's index is just a gather from this array.
+      - `nsys_kernel_names[K]`: per-launch mangled name, used to compute the
+        function index from `sass_kernel_names` when no precomputed index is
+        attached.
+    Final fallback: function-0 for every active bin.
+    """
+    T = bin_kernel_id.shape[0]
+    out = np.full(T, -1, dtype=np.int64)
+    if not sass_kernel_names:
+        return out
+    if launch_function_index is not None and len(launch_function_index) > 0:
+        active = bin_kernel_id >= 0
+        if active.any():
+            out[active] = launch_function_index[bin_kernel_id[active]]
+        return out
+    if nsys_kernel_names is None:
+        out[bin_kernel_id >= 0] = 0
+        return out
+    name_to_fn = {n: i for i, n in enumerate(sass_kernel_names)}
+    for t in range(T):
+        k = int(bin_kernel_id[t])
+        if k < 0 or k >= len(nsys_kernel_names):
+            continue
+        out[t] = name_to_fn.get(nsys_kernel_names[k], -1)
+    return out
+
+
+def _pad_sass_matrices(matrices: list[np.ndarray]) -> tuple[np.ndarray, np.ndarray]:
+    """Stack per-kernel [N_pc_k, F] matrices into one padded [K, N_pc_max, F].
+
+    Returns (sass_matrix, sass_pc_mask).
+    """
+    if not matrices:
+        return (np.zeros((0, 0, 0), dtype=np.float32),
+                np.zeros((0, 0), dtype=np.float32))
+    F = matrices[0].shape[1]
+    N_pc_max = max(M.shape[0] for M in matrices)
+    K = len(matrices)
+    out = np.zeros((K, N_pc_max, F), dtype=np.float32)
+    mask = np.zeros((K, N_pc_max), dtype=np.float32)
+    for k, M in enumerate(matrices):
+        out[k, :M.shape[0]] = M.astype(np.float32)
+        mask[k, :M.shape[0]] = 1.0
+    return out, mask
+
+
+def load_motif(out_dir: Path) -> SASSSample:
+    """Load tensor_input + (optional) labels + sass_modality for one motif."""
+    tin_path = out_dir / "input" / "tensor_input.npz"
+    sass_path = out_dir / "sass" / "sass_modality.npz"
+    if not tin_path.exists():
+        raise FileNotFoundError(tin_path)
+    if not sass_path.exists():
+        raise FileNotFoundError(sass_path)
+
+    tin = np.load(tin_path, allow_pickle=True)
+    trace_input = tin["data"].astype(np.float32)
+    counter_names = list(tin["counter_names"])
+    edges = tin["time_edges_ns"].astype(np.int64)
+    kernels = tin["kernels"].astype(np.int64)
+    nsys_kernel_names = (
+        list(tin["kernel_names"]) if "kernel_names" in tin.files else None
+    )
+    launch_function_index = (
+        tin["kernel_function_index"].astype(np.int64)
+        if "kernel_function_index" in tin.files else None
+    )
+
+    labels_path = out_dir / "labels" / "labels.npz"
+    regime_family = subregime = structural = None
+    regime_family_names = subregime_names = structural_names = None
+    subregime_family_idx = None
+    boundaries = None
+    gt_segments = None
+    mask_any = mask_prof = None
+    workload_l1 = workload_l2 = None
+    workload_l1_multihot = workload_l2_multihot = None
+    multihot_n_active = mask_multilabel = None
+    vocab_l1 = vocab_l2 = None
+    if labels_path.exists():
+        lab = np.load(labels_path, allow_pickle=True)
+        # Every label key is loaded present-aware so the loader works across
+        # the schema's additive evolution: a labels.npz that lacks a key
+        # leaves the corresponding target None instead of raising.
+        def _opt(key, cast=None):
+            if key not in lab.files:
+                return None
+            v = lab[key]
+            return v.astype(cast) if cast is not None else v
+
+        regime_family = _opt("regime_family", np.float32)
+        regime_family_names = list(lab["regime_family_names"]) \
+            if "regime_family_names" in lab.files else None
+        subregime = _opt("subregime", np.float32)
+        subregime_names = list(lab["subregime_names"]) \
+            if "subregime_names" in lab.files else None
+        subregime_family_idx = _opt("subregime_family_idx", np.int64)
+        structural = _opt("structural", np.float32)
+        structural_names = list(lab["structural_names"]) \
+            if "structural_names" in lab.files else None
+        mask_any = _opt("mask_any_kernel", np.float32)
+        mask_prof = _opt("mask_profiled", np.float32)
+        boundaries = _opt("boundaries", np.float32)
+        if "gt_segments" in lab.files:
+            gt_segments = lab["gt_segments"]
+
+        # Single-label workload ids (the existing softmax-head targets).
+        workload_l1 = _opt("workload_l1", np.int64)
+        workload_l2 = _opt("workload_l2", np.int64)
+        # Additive multi-hot (overlapping-label) tracks — the sigmoid /
+        # multi-label head targets. float32 so they drop straight into a
+        # BCEWithLogits loss. For the sequential corpus these are the one-hot
+        # of workload_l{1,2}; in genuinely fused traces (e.g. a warp-
+        # specialized GEMM) a bin can carry >=2 active classes.
+        workload_l1_multihot = _opt("workload_l1_multihot", np.float32)
+        workload_l2_multihot = _opt("workload_l2_multihot", np.float32)
+        multihot_n_active = _opt("multihot_n_active", np.float32)
+        if multihot_n_active is not None:
+            # multi-label analog of mask_labeled: 1 where >=1 class is active.
+            mask_multilabel = (multihot_n_active > 0).astype(np.float32)
+        vocab_l1 = list(lab["vocab_l1"]) if "vocab_l1" in lab.files else None
+        vocab_l2 = list(lab["vocab_l2"]) if "vocab_l2" in lab.files else None
+
+    sass = np.load(sass_path, allow_pickle=True)
+    sass_matrices = [np.asarray(m) for m in sass["matrices"]]
+    sass_kernel_names = list(sass["kernel_names"])
+    sass_column_names = list(sass["column_names"])
+    sass_matrix, sass_pc_mask = _pad_sass_matrices(sass_matrices)
+
+    launch_idx = _bin_kernel_index(edges, kernels)
+    bin_kernel_id = _bin_kernel_function_index(
+        launch_idx, kernels, sass_kernel_names, nsys_kernel_names,
+        launch_function_index=launch_function_index,
+    )
+
+    return SASSSample(
+        trace_input=trace_input,
+        counter_names=counter_names,
+        time_edges_ns=edges,
+        regime_family=regime_family,
+        regime_family_names=regime_family_names,
+        subregime=subregime,
+        subregime_names=subregime_names,
+        subregime_family_idx=subregime_family_idx,
+        structural=structural,
+        structural_names=structural_names,
+        boundaries=boundaries,
+        gt_segments=gt_segments,
+        mask_any=mask_any,
+        mask_profiled=mask_prof,
+        workload_l1=workload_l1,
+        workload_l2=workload_l2,
+        workload_l1_multihot=workload_l1_multihot,
+        workload_l2_multihot=workload_l2_multihot,
+        multihot_n_active=multihot_n_active,
+        mask_multilabel=mask_multilabel,
+        vocab_l1=vocab_l1,
+        vocab_l2=vocab_l2,
+        bin_kernel_id=bin_kernel_id,
+        sass_matrix=sass_matrix,
+        sass_pc_mask=sass_pc_mask,
+        sass_column_names=sass_column_names,
+        sass_kernel_names=sass_kernel_names,
+    )
+
+
+def cross_attention_shapes_demo(sample: SASSSample,
+                                d_model: int = 64,
+                                patch_shape: tuple[int, int] = (4, 16)) -> None:
+    """Print the shapes a forward pass would touch. No actual attention is run."""
+    C, T = sample.trace_input.shape
+    P_c, P_t = patch_shape
+    assert C % P_c == 0 and T % P_t == 0, \
+        f"patch {patch_shape} doesn't divide ({C}, {T})"
+    n_tokens = (C // P_c) * (T // P_t)
+    K, N_pc_max, F = sample.sass_matrix.shape
+
+    print(f"trace_input        {sample.trace_input.shape}  dtype={sample.trace_input.dtype}")
+    print(f"  -> patches       ({n_tokens}, {P_c * P_t})  "
+          f"= ({C // P_c} * {T // P_t}, {P_c} * {P_t})")
+    print(f"  -> Q             ({n_tokens}, {d_model})  via patch_embed Linear")
+    print(f"sass_matrix        ({K}, {N_pc_max}, {F})")
+    print(f"  -> K = V         ({K}, {N_pc_max}, {d_model})  via sass_proj Linear")
+    print(f"bin_kernel_id      {sample.bin_kernel_id.shape}  "
+          f"range=[{sample.bin_kernel_id.min()}, {sample.bin_kernel_id.max()}]")
+    print(f"  -> per-token kernel index: ({n_tokens},) "
+          f"(replicate the time-bin's kernel across the {C // P_c} channel patches)")
+    print(f"attn output        ({n_tokens}, {d_model})  "
+          f"= softmax(Q K^T / sqrt(d)) @ V, masked by sass_pc_mask")
+
+    # Multi-label (overlapping-class) head targets, when present.
+    if sample.workload_l1_multihot is not None:
+        mh1 = sample.workload_l1_multihot
+        mh2 = sample.workload_l2_multihot
+        na = sample.multihot_n_active
+        n_overlap = int((na >= 2).sum()) if na is not None else 0
+        print(f"workload_l1_multihot {mh1.shape}  dtype={mh1.dtype}  "
+              f"(sigmoid head target; BCEWithLogits over {mh1.shape[1]} L1 classes)")
+        print(f"workload_l2_multihot {mh2.shape}  dtype={mh2.dtype}  "
+              f"({mh2.shape[1]} L2 classes)")
+        print(f"  -> bins with >=2 concurrent L1 classes: {n_overlap}/{mh1.shape[0]} "
+              f"(0 for the sequential corpus; >0 only on fused/overlapping traces)")
+    else:
+        print("workload_l*_multihot  (absent — labels.npz pre-dates the "
+              "multi-hot fields; re-run tools/build_labels.py)")
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    ap.add_argument("out_dir", type=Path)
+    ap.add_argument("--d-model", type=int, default=64)
+    args = ap.parse_args()
+    sample = load_motif(args.out_dir.resolve())
+    print(f"motif: {args.out_dir}")
+    print(f"  counter_names ({len(sample.counter_names)}): "
+          f"{sample.counter_names[:3]} ... {sample.counter_names[-2:]}")
+    print(f"  sass kernel functions ({len(sample.sass_kernel_names)}): "
+          f"{sample.sass_kernel_names}")
+    print(f"  sass columns ({len(sample.sass_column_names)}): "
+          f"{sample.sass_column_names}")
+    print()
+    cross_attention_shapes_demo(sample, d_model=args.d_model)
+
+
+if __name__ == "__main__":
+    main()

tools/workload_taxonomy.py

@@ -0,0 +1,1023 @@
+#!/usr/bin/env python3
+"""Single source of truth for the KernelSight workload taxonomy.
+
+Defines L1 (12 coarse) + L2 (~73 fine) workload categories, plus the
+8-flag implementation-style ``ATTRIBUTE_FLAGS`` (multi-label) and the 5-class
+``SPATIAL_STATE_VOCAB`` (single-label). L2 derivation lives behind
+``parse_l2_sequence`` and ``infer_from_filename_l2``; per-bin spatial-state
+derivation is out of scope (no fused kernels in the corpus), but the vocab
+is exposed here so downstream label tooling can pin its head.
+
+Public surface (consumed by ``tools/build_labels.py``, ``tools/build_splits.py``,
+``tests/test_tensor_invariants.py`` and the KernelBench harness):
+
+  VOCAB_L1: list[str]
+      12 L1 names. Indexes downstream as ``L1_TO_ID``.
+
+  VOCAB_L2: list[str]
+      ~73 L2 names. Sorted by ``(l1_index, l2_name)`` — VOCAB_L1's order is
+      preserved at the L1 group level, names sort alphabetically inside each
+      group. Indexes downstream as ``L2_TO_ID``.
+
+  L2_PARENT_L1: dict[str, str]
+      Each L2 -> its L1 parent. ``L2_PARENT_L1[l2] in L1_TO_ID`` is asserted
+      at module import; the hierarchy invariant test in
+      ``tests/test_tensor_invariants.py`` enforces it per-bin / per-segment.
+
+  TAXONOMY: dict[str, list[str]]
+      L1 -> sorted list of L2 children. Equivalent shape to L2_PARENT_L1
+      inverted; kept for callers that want to enumerate by L1.
+
+  ATTRIBUTE_FLAGS: list[str]
+      8 implementation-style multi-label flags
+      (sparse / tma / cluster / masked / persistent / vectorized_store /
+      atomic_accum / ldgsts). Each is independent — the model side gets a
+      binary head per flag.
+
+  SPATIAL_STATE_VOCAB: list[str]
+      5-class spatial-state taxonomy
+      (uniform / wavefront_transition / tail_effect / load_imbalanced /
+      hotspot). Per-bin ``spatial_state[T]`` derivation is out of scope
+      (no fused kernels in the corpus); the vocab is pinned here so the
+      model side can structure its head.
+
+  ANCHOR_OVERRIDES: dict[str, str]
+      Exact-basename -> L1. The same entries live in
+      ``ANCHOR_OVERRIDES_L2`` (with an L2 attached).
+
+  ANCHOR_OVERRIDES_L2: dict[str, tuple[str, str]]
+      Exact-basename -> (L1, L2). Covers:
+        * the 5 microbench motif directory names,
+        * the 4 outer ``phase_X_*`` NVTX names emitted by the megakernel host,
+        * the 4 inner ``op_*`` NVTX names emitted by the megakernel host
+          (nested NVTX shape from ``kernels/megakernel/main.cc``).
+
+  FILENAME_RULES: list[tuple[re.Pattern, str]]
+      Regex fallback for L1 inference on basenames that miss
+      ``ANCHOR_OVERRIDES`` and the KB L1 problem-id table.
+
+  infer_from_filename(basename: str) -> str
+      L1 label resolution entry point. Resolution order:
+        1. ``ANCHOR_OVERRIDES``
+        2. KB L1 problem-id table (``_KB_L1_PROBLEM_TO_L1``)
+        3. ``FILENAME_RULES`` regex fallback
+        4. "other"
+
+  infer_from_filename_l2(basename: str) -> tuple[str, str]
+      (L1, L2) label resolution entry point. Resolution order:
+        1. ``ANCHOR_OVERRIDES_L2``
+        2. KB L1 problem-id table -> ``_KB_L1_PROBLEM_TO_OPS`` (single op)
+        3. KB L2 problem-id table -> ``_KB_L2_PROBLEM_TO_OPS`` (override)
+        4. Token rule fallback (uses ``_OP_TOKEN_TO_L2`` per CamelCase token)
+        5. ``("other", "other_misc")``
+
+  parse_l2_sequence(basename: str) -> list[tuple[str, str]]
+      Sequence-aware version of ``infer_from_filename_l2``. Returns the
+      ordered list of (L1, L2) pairs implied by the filename:
+        * L1 problems return a length-1 list,
+        * L2 problems return a length-N list (one per op token),
+        * anchor basenames return a length-1 list,
+        * unknown basenames return ``[("other", "other_misc")]``.
+
+  infer_from_aten(aten_op: str) -> str
+      Stub for an aten-op label path. Returns "other".
+
+  multihot_from_ids(ids, dim: int) -> list[int]
+      Canonical multi-hot primitive (OR of one-hots). Ignores ids outside
+      ``[0, dim)`` (e.g. the -1 unlabeled sentinel), so it subsumes the
+      single-label one-hot case. Used by ``tools/build_labels.py`` to build
+      the additive ``workload_l1_multihot`` / ``workload_l2_multihot`` tracks.
+
+  l1_multihot_from_l2_multihot(l2_multihot) -> list[int]
+      Project an L2 multi-hot row onto its implied L1 multi-hot row (set the
+      ``L2_PARENT_L1`` parent of every active L2). Encodes the L1/L2
+      hierarchy invariant the CI enforces on the multi-hot tracks.
+
+Smoke check: ``python tools/workload_taxonomy.py`` walks both the KB L1 and
+KB L2 directories and reports per-L1 / per-L2 coverage. The target is
+100/100 coverage on both levels with no ``other_misc`` fallthrough.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+
+VOCAB_L1: list[str] = [
+    "matmul",
+    "conv",
+    "activation",
+    "normalization",
+    "softmax",
+    "pooling",
+    "reduction",
+    "attention",
+    "loss",
+    "elementwise",
+    "memory_movement",
+    "other",
+]
+assert len(VOCAB_L1) == 12, "VOCAB_L1 must hold 12 L1 categories"
+assert len(set(VOCAB_L1)) == len(VOCAB_L1), "VOCAB_L1 has duplicate entries"
+
+L1_TO_ID: dict[str, int] = {n: i for i, n in enumerate(VOCAB_L1)}
+
+
+# ---------------------------------------------------------------------------
+# L2 taxonomy
+# ---------------------------------------------------------------------------
+
+# Per-L1 list of L2 children. Each L2 name is prefixed with its L1 parent
+# for traceability and to make the parent recoverable from the name in
+# emergency debugging. The flattened VOCAB_L2 below is the canonical order
+# downstream code keys against; the dict is the authoring shape.
+_L2_BY_L1: dict[str, list[str]] = {
+    "matmul": [
+        "matmul_bmm",
+        "matmul_gemm",
+        "matmul_matvec",
+    ],
+    "conv": [
+        "conv_conv1d_standard",
+        "conv_conv2d_depthwise",
+        "conv_conv2d_pointwise",
+        "conv_conv2d_standard",
+        "conv_conv3d_standard",
+        "conv_convtranspose1d",
+        "conv_convtranspose2d",
+        "conv_convtranspose3d",
+    ],
+    "activation": [
+        "activation_elu",
+        "activation_gelu",
+        "activation_hardsigmoid",
+        "activation_hardswish",
+        "activation_hardtanh",
+        "activation_leaky_relu",
+        "activation_mish",
+        "activation_other",
+        "activation_relu",
+        "activation_selu",
+        "activation_sigmoid",
+        "activation_softplus",
+        "activation_softsign",
+        "activation_swish",
+        "activation_tanh",
+    ],
+    "normalization": [
+        "normalization_batchnorm",
+        "normalization_frobeniusnorm",
+        "normalization_groupnorm",
+        "normalization_instancenorm",
+        "normalization_l1norm",
+        "normalization_l2norm",
+        "normalization_layernorm",
+        "normalization_rmsnorm",
+    ],
+    "softmax": [
+        "softmax_log_softmax",
+        "softmax_logsumexp",
+        "softmax_softmax",
+    ],
+    "pooling": [
+        "pooling_avg_pool",
+        "pooling_global_avg_pool",
+        "pooling_max_pool",
+    ],
+    "reduction": [
+        "reduction_argmax",
+        "reduction_argmin",
+        "reduction_cumprod",
+        "reduction_cumsum",
+        "reduction_max",
+        "reduction_mean",
+        "reduction_min",
+        "reduction_prod",
+        "reduction_sum",
+    ],
+    "attention": [
+        "attention_scaled_dot_product",
+    ],
+    "loss": [
+        "loss_cross_entropy",
+        "loss_hinge",
+        "loss_huber",
+        "loss_kldiv",
+        "loss_mse",
+        "loss_triplet_margin",
+    ],
+    "elementwise": [
+        "elementwise_add",
+        "elementwise_bias_add",
+        "elementwise_cast",
+        "elementwise_clamp",
+        "elementwise_div",
+        "elementwise_mul",
+        "elementwise_residual_add",
+        "elementwise_scalar_multiplication",
+        "elementwise_scaling",
+        "elementwise_sub",
+    ],
+    "memory_movement": [
+        "memory_movement_copy",
+        "memory_movement_embedding",
+        "memory_movement_gather",
+        "memory_movement_scatter",
+        "memory_movement_transpose",
+    ],
+    "other": [
+        "other_dropout",
+        "other_misc",
+    ],
+}
+for _l1, _children in _L2_BY_L1.items():
+    assert _l1 in L1_TO_ID, f"_L2_BY_L1 key {_l1!r} is not in VOCAB_L1"
+    assert _children == sorted(_children), \
+        f"_L2_BY_L1[{_l1!r}] is not sorted alphabetically"
+    for _c in _children:
+        assert _c.startswith(_l1 + "_"), \
+            f"L2 name {_c!r} must be prefixed with its L1 parent {_l1!r}"
+
+# Flatten in VOCAB_L1 order so L2 ids cluster by L1 family.
+VOCAB_L2: list[str] = []
+for _l1 in VOCAB_L1:
+    VOCAB_L2.extend(_L2_BY_L1[_l1])
+assert len(VOCAB_L2) == len(set(VOCAB_L2)), "VOCAB_L2 has duplicate entries"
+
+L2_TO_ID: dict[str, int] = {n: i for i, n in enumerate(VOCAB_L2)}
+
+L2_PARENT_L1: dict[str, str] = {l2: _l1
+                                for _l1, children in _L2_BY_L1.items()
+                                for l2 in children}
+for _l2, _parent in L2_PARENT_L1.items():
+    assert _parent in L1_TO_ID, \
+        f"L2_PARENT_L1[{_l2!r}] = {_parent!r} not in VOCAB_L1"
+
+# Public alias. ``TAXONOMY[l1]`` yields the sorted L2 child list.
+TAXONOMY: dict[str, list[str]] = {l1: list(_L2_BY_L1[l1]) for l1 in VOCAB_L1}
+
+
+# L2 ops that launch NO device kernel during inference (model.eval()). They
+# appear in problem names / parsed op sequences but produce no observable
+# launch, so ``tools/build_labels.py`` drops them from the op sequence before
+# aligning kernel launches to ops -- otherwise an iter with launches < ops is
+# skipped (e.g. ``66_Matmul_Dropout_Softmax``: 2 launches vs 3 ops) or a real
+# kernel is mislabeled. Extend as new inference-no-op ops appear.
+INFERENCE_NOOP_L2: frozenset[str] = frozenset({"other_dropout"})
+for _l2 in INFERENCE_NOOP_L2:
+    assert _l2 in L2_TO_ID, f"INFERENCE_NOOP_L2 entry {_l2!r} not in VOCAB_L2"
+
+
+# ---------------------------------------------------------------------------
+# Auxiliary vocabs (attribute flags + spatial state)
+# ---------------------------------------------------------------------------
+
+# Multi-label flags describing kernel *implementation style*. Each is a
+# separate binary head on the model side; new variants extend without
+# retraining the L1/L2 heads. Order is fixed: indexing matches the
+# ``attribute_flags[S, 8]`` columns in ``labels.npz`` and the
+# ``EXPECTED_ATTRIBUTE_FLAGS`` invariant in ``tests/test_tensor_invariants.py``.
+ATTRIBUTE_FLAGS: list[str] = [
+    "sparse",
+    "tma",
+    "cluster",
+    "masked",
+    "persistent",
+    "vectorized_store",
+    "atomic_accum",
+    "ldgsts",
+]
+assert len(ATTRIBUTE_FLAGS) == 8, "ATTRIBUTE_FLAGS must hold exactly 8 flags"
+assert len(set(ATTRIBUTE_FLAGS)) == len(ATTRIBUTE_FLAGS), \
+    "ATTRIBUTE_FLAGS has duplicate entries"
+
+# Single-label spatial-state classes (5-class). Per-bin derivation is out
+# of scope; the vocab is pinned here so the model side can structure its
+# head.
+SPATIAL_STATE_VOCAB: list[str] = [
+    "uniform",
+    "wavefront_transition",
+    "tail_effect",
+    "load_imbalanced",
+    "hotspot",
+]
+assert len(SPATIAL_STATE_VOCAB) == 5, \
+    "SPATIAL_STATE_VOCAB must hold exactly 5 classes"
+assert len(set(SPATIAL_STATE_VOCAB)) == len(SPATIAL_STATE_VOCAB), \
+    "SPATIAL_STATE_VOCAB has duplicate entries"
+
+
+# ---------------------------------------------------------------------------
+# Multi-hot helpers (overlapping / concurrent per-bin labels)
+# ---------------------------------------------------------------------------
+#
+# The single-label corpus carries one class id per bin. Genuine concurrency
+# (e.g. a Hopper warp-specialized GEMM whose producer TMA-load phase
+# overlaps its consumer WGMMA phase in wall-clock time) needs >=2 classes
+# active in the same bin. ``multihot_from_ids`` is the canonical primitive
+# used to build the per-bin ``workload_l1_multihot[T, 12]`` /
+# ``workload_l2_multihot[T, 73]`` tracks in ``tools/build_labels.py`` and to
+# inject externally-provided overlapping spans. It is numpy-free so this
+# module keeps its stdlib-only import surface; the label builder does the
+# vectorized construction. ``l1_multihot_from_l2_multihot`` enforces the
+# L1/L2 hierarchy on a multi-hot row the same way ``L2_PARENT_L1`` does for
+# the single-label path.
+
+def multihot_from_ids(ids, dim: int) -> list[int]:
+    """Return a length-``dim`` list of 0/1 ints, 1 at each id in ``ids``.
+
+    The canonical multi-hot primitive (OR of one-hots). ``ids`` may repeat
+    (idempotent). Ids outside ``[0, dim)`` -- notably the ``-1`` unlabeled
+    sentinel -- are ignored, so:
+
+      * ``multihot_from_ids([single_label_id], dim)`` is the one-hot of a
+        single-label bin (this is why the multi-hot schema subsumes the
+        single-label corpus as a degenerate one-hot),
+      * ``multihot_from_ids([-1], dim)`` is the all-zero (unlabeled) row,
+      * ``multihot_from_ids([a, b], dim)`` is the two-class overlap row.
+    """
+    vec = [0] * dim
+    for i in ids:
+        j = int(i)
+        if 0 <= j < dim:
+            vec[j] = 1
+    return vec
+
+
+def l1_multihot_from_l2_multihot(l2_multihot) -> list[int]:
+    """Project an L2 multi-hot row onto its implied L1 multi-hot row.
+
+    For every active L2 class, its unique L1 parent (``L2_PARENT_L1``) is set
+    in the returned ``len(VOCAB_L1)`` vector. This is the hierarchy invariant
+    the CI enforces on the multi-hot tracks: ``l2_parent_l1[j]`` must be set
+    in L1 wherever L2 ``j`` is set. ``l2_multihot`` is any length-|VOCAB_L2|
+    sequence of truthy/falsy values.
+    """
+    parents = []
+    for j, on in enumerate(l2_multihot):
+        if on:
+            parents.append(L1_TO_ID[L2_PARENT_L1[VOCAB_L2[j]]])
+    return multihot_from_ids(parents, len(VOCAB_L1))
+
+
+# ---------------------------------------------------------------------------
+# Anchor overrides (microbench / CUTLASS)
+# ---------------------------------------------------------------------------
+
+# basename -> L1. Kept so callers that only need L1 (e.g.
+# ``infer_from_filename``) have a direct lookup.
+ANCHOR_OVERRIDES: dict[str, str] = {
+    "vector_add":              "elementwise",
+    "reduction":               "reduction",
+    "gather":                  "memory_movement",
+    "scatter":                 "memory_movement",
+    "wgmma":                   "matmul",
+    "cutlass_gemm":            "matmul",
+    "cutlass_fmha":            "attention",
+    "cutlass_fp8_gemm":        "matmul",
+    "cutlass_sparse_gemm":     "matmul",
+    "cutlass_grouped_gemm":    "matmul",
+    # Device-marker overlap PoC (WGMMA-dominated GEMM op identity). The anchor
+    # is the single-label baseline; the genuine intra-launch phase overlap is
+    # OR'd in by the corpus label driver from %globaltimer markers.
+    "cutlass_ws_overlap":      "matmul",
+}
+for _l1 in ANCHOR_OVERRIDES.values():
+    assert _l1 in L1_TO_ID, f"ANCHOR_OVERRIDES references unknown L1 {_l1!r}"
+
+# basename -> (L1, L2). Covers the same set as ANCHOR_OVERRIDES. The microbench
+# entries duplicate ANCHOR_OVERRIDES on the L1 axis by construction (asserted
+# below). cutlass_grouped_gemm anchors as matmul_bmm (many small GEMMs scheduled
+# on-device), the other CUTLASS GEMM variants as matmul_gemm.
+ANCHOR_OVERRIDES_L2: dict[str, tuple[str, str]] = {
+    "vector_add":              ("elementwise",     "elementwise_add"),
+    "reduction":               ("reduction",       "reduction_sum"),
+    "gather":                  ("memory_movement", "memory_movement_gather"),
+    "scatter":                 ("memory_movement", "memory_movement_scatter"),
+    "wgmma":                   ("matmul",          "matmul_gemm"),
+    "cutlass_gemm":            ("matmul",          "matmul_gemm"),
+    "cutlass_fmha":            ("attention",       "attention_scaled_dot_product"),
+    "cutlass_fp8_gemm":        ("matmul",          "matmul_gemm"),
+    "cutlass_sparse_gemm":     ("matmul",          "matmul_gemm"),
+    "cutlass_grouped_gemm":    ("matmul",          "matmul_bmm"),
+    "cutlass_ws_overlap":      ("matmul",          "matmul_gemm"),
+}
+for _name, (_l1, _l2) in ANCHOR_OVERRIDES_L2.items():
+    assert _l1 in L1_TO_ID, \
+        f"ANCHOR_OVERRIDES_L2[{_name!r}] L1 {_l1!r} not in VOCAB_L1"
+    assert _l2 in L2_TO_ID, \
+        f"ANCHOR_OVERRIDES_L2[{_name!r}] L2 {_l2!r} not in VOCAB_L2"
+    assert L2_PARENT_L1[_l2] == _l1, \
+        f"ANCHOR_OVERRIDES_L2[{_name!r}]: L2 {_l2!r}'s parent " \
+        f"{L2_PARENT_L1[_l2]!r} != declared L1 {_l1!r}"
+for _name, _l1 in ANCHOR_OVERRIDES.items():
+    assert _name in ANCHOR_OVERRIDES_L2, \
+        f"ANCHOR_OVERRIDES_L2 missing {_name!r}"
+    assert ANCHOR_OVERRIDES_L2[_name][0] == _l1, \
+        f"ANCHOR_OVERRIDES_L2[{_name!r}] L1 axis drifts from ANCHOR_OVERRIDES"
+
+
+# ---------------------------------------------------------------------------
+# KernelBench L1 problem-id rule table
+# ---------------------------------------------------------------------------
+#
+# ``_KB_L1_PROBLEM_TO_OPS`` maps id -> [(L1, L2)] (length 1 since L1
+# problems are single-op). ``_KB_L1_PROBLEM_TO_L1`` is projected from
+# the OPS table for callers that only need L1. The two stay in lockstep
+# -- the assertion at the bottom of this section enforces it.
+
+_KB_L1_PROBLEM_TO_OPS: dict[int, list[tuple[str, str]]] = {
+    # 1-18 (except 5): matmul variants
+    1:  [("matmul", "matmul_gemm")],
+    2:  [("matmul", "matmul_gemm")],
+    3:  [("matmul", "matmul_bmm")],
+    4:  [("matmul", "matmul_matvec")],
+    5:  [("elementwise", "elementwise_scalar_multiplication")],
+    6:  [("matmul", "matmul_gemm")],
+    7:  [("matmul", "matmul_gemm")],
+    8:  [("matmul", "matmul_gemm")],
+    9:  [("matmul", "matmul_gemm")],
+    10: [("matmul", "matmul_bmm")],
+    11: [("matmul", "matmul_bmm")],
+    12: [("matmul", "matmul_gemm")],
+    13: [("matmul", "matmul_gemm")],
+    14: [("matmul", "matmul_gemm")],
+    15: [("matmul", "matmul_gemm")],
+    16: [("matmul", "matmul_gemm")],
+    17: [("matmul", "matmul_gemm")],
+    18: [("matmul", "matmul_gemm")],
+    # 19-32: activation
+    19: [("activation", "activation_relu")],
+    20: [("activation", "activation_leaky_relu")],
+    21: [("activation", "activation_sigmoid")],
+    22: [("activation", "activation_tanh")],
+    23: [("softmax",    "softmax_softmax")],
+    24: [("softmax",    "softmax_log_softmax")],
+    25: [("activation", "activation_swish")],
+    26: [("activation", "activation_gelu")],
+    27: [("activation", "activation_selu")],
+    28: [("activation", "activation_hardsigmoid")],
+    29: [("activation", "activation_softplus")],
+    30: [("activation", "activation_softsign")],
+    31: [("activation", "activation_elu")],
+    32: [("activation", "activation_hardtanh")],
+    # 33-40: normalization
+    33: [("normalization", "normalization_batchnorm")],
+    34: [("normalization", "normalization_instancenorm")],
+    35: [("normalization", "normalization_groupnorm")],
+    36: [("normalization", "normalization_rmsnorm")],
+    37: [("normalization", "normalization_frobeniusnorm")],
+    38: [("normalization", "normalization_l1norm")],
+    39: [("normalization", "normalization_l2norm")],
+    40: [("normalization", "normalization_layernorm")],
+    # 41-46: pooling
+    41: [("pooling", "pooling_max_pool")],
+    42: [("pooling", "pooling_max_pool")],
+    43: [("pooling", "pooling_max_pool")],
+    44: [("pooling", "pooling_avg_pool")],
+    45: [("pooling", "pooling_avg_pool")],
+    46: [("pooling", "pooling_avg_pool")],
+    # 47-49, 51-53: reduction
+    47: [("reduction", "reduction_sum")],
+    48: [("reduction", "reduction_mean")],
+    49: [("reduction", "reduction_max")],
+    51: [("reduction", "reduction_argmax")],
+    52: [("reduction", "reduction_argmin")],
+    53: [("reduction", "reduction_min")],
+    # 50, 54-87: conv (mixed 1D/2D/3D, standard / transposed / depthwise /
+    # pointwise). Sourced by inspecting
+    # ``KernelBench/KernelBench/level1/*.py`` filenames.
+    50: [("conv", "conv_conv2d_standard")],
+    54: [("conv", "conv_conv3d_standard")],
+    55: [("conv", "conv_conv2d_standard")],
+    56: [("conv", "conv_conv2d_standard")],
+    57: [("conv", "conv_convtranspose2d")],
+    58: [("conv", "conv_convtranspose3d")],
+    59: [("conv", "conv_conv3d_standard")],
+    60: [("conv", "conv_conv3d_standard")],
+    61: [("conv", "conv_convtranspose3d")],
+    62: [("conv", "conv_conv2d_standard")],
+    63: [("conv", "conv_conv2d_standard")],
+    64: [("conv", "conv_convtranspose1d")],
+    65: [("conv", "conv_convtranspose2d")],
+    66: [("conv", "conv_conv3d_standard")],
+    67: [("conv", "conv_conv1d_standard")],
+    68: [("conv", "conv_convtranspose3d")],
+    69: [("conv", "conv_convtranspose2d")],
+    70: [("conv", "conv_convtranspose3d")],
+    71: [("conv", "conv_convtranspose2d")],
+    72: [("conv", "conv_convtranspose3d")],
+    73: [("conv", "conv_convtranspose3d")],
+    74: [("conv", "conv_convtranspose1d")],
+    75: [("conv", "conv_convtranspose2d")],
+    76: [("conv", "conv_conv1d_standard")],
+    77: [("conv", "conv_convtranspose3d")],
+    78: [("conv", "conv_convtranspose2d")],
+    79: [("conv", "conv_convtranspose1d")],
+    80: [("conv", "conv_conv2d_standard")],
+    81: [("conv", "conv_convtranspose2d")],
+    82: [("conv", "conv_conv2d_depthwise")],
+    83: [("conv", "conv_conv2d_depthwise")],
+    84: [("conv", "conv_conv2d_depthwise")],
+    85: [("conv", "conv_conv2d_depthwise")],
+    # 86 is depthwise-separable (depthwise + pointwise stages); treated as
+    # depthwise for L2 labeling purposes since the depthwise stage carries
+    # the dominant compute pattern.
+    86: [("conv", "conv_conv2d_depthwise")],
+    87: [("conv", "conv_conv2d_pointwise")],
+    # 88: GELU variant (MinGPT's new_gelu polynomial); collapses to gelu.
+    88: [("activation", "activation_gelu")],
+    # 89-93: cumsum / cumprod variants.
+    89: [("reduction", "reduction_cumsum")],
+    90: [("reduction", "reduction_cumprod")],
+    91: [("reduction", "reduction_cumsum")],
+    92: [("reduction", "reduction_cumsum")],
+    93: [("reduction", "reduction_cumsum")],
+    # 94-100: losses + attention.
+    94:  [("loss", "loss_mse")],
+    95:  [("loss", "loss_cross_entropy")],
+    96:  [("loss", "loss_huber")],
+    97:  [("attention", "attention_scaled_dot_product")],
+    98:  [("loss", "loss_kldiv")],
+    99:  [("loss", "loss_triplet_margin")],
+    100: [("loss", "loss_hinge")],
+}
+assert len(_KB_L1_PROBLEM_TO_OPS) == 100, \
+    f"KB L1 OPS table has {len(_KB_L1_PROBLEM_TO_OPS)} entries, expected 100"
+for _pid, _ops in _KB_L1_PROBLEM_TO_OPS.items():
+    assert len(_ops) == 1, \
+        f"KB L1 problem {_pid} has {len(_ops)} ops, expected 1"
+    _l1, _l2 = _ops[0]
+    assert _l1 in L1_TO_ID, \
+        f"KB L1 problem {_pid} -> L1 {_l1!r} not in VOCAB_L1"
+    assert _l2 in L2_TO_ID, \
+        f"KB L1 problem {_pid} -> L2 {_l2!r} not in VOCAB_L2"
+    assert L2_PARENT_L1[_l2] == _l1, \
+        f"KB L1 problem {_pid}: L2 {_l2!r} parent " \
+        f"{L2_PARENT_L1[_l2]!r} != declared L1 {_l1!r}"
+
+# ``_KB_L1_PROBLEM_TO_L1`` projected from the OPS table so
+# ``infer_from_filename`` (L1-only entry point) continues to work.
+_KB_L1_PROBLEM_TO_L1: dict[int, str] = {
+    pid: ops[0][0] for pid, ops in _KB_L1_PROBLEM_TO_OPS.items()
+}
+
+
+# ---------------------------------------------------------------------------
+# KernelBench L2 problem-id override table
+# ---------------------------------------------------------------------------
+#
+# Token-rule fallback (``_OP_TOKEN_TO_L2``) handles every L2 problem on
+# disk today. This table is reserved for problems where the parser is
+# ambiguous; it is currently empty and the smoke check at the bottom
+# of the file fails loudly if a token can't be resolved.
+_KB_L2_PROBLEM_TO_OPS: dict[int, list[tuple[str, str]]] = {}
+
+
+# ---------------------------------------------------------------------------
+# Token rule fallback for L2 problem op sequences
+# ---------------------------------------------------------------------------
+
+# Tokens are extracted by splitting the basename on ``_`` and dropping the
+# leading numeric id and a trailing ``.py``. Each CamelCase / mixed-case
+# token maps to a single (L1, L2) pair; descriptor words like "for",
+# "with", "over", "a", "dimension" don't appear here and are silently
+# skipped by ``_tokens_to_ops``.
+#
+# Sources:
+#   * KernelBench/KernelBench/level2/*.py — 100 op-sequence filenames.
+#   * KernelBench/KernelBench/level1/*.py — 100 single-op filenames (the
+#     L1 problem-id table above takes precedence, but the rules cover
+#     ``Argmax``/``Argmin``/``Cumsum``/``Cumprod``/``MSELoss``/... for
+#     defensive resolution when the id table misses).
+_OP_TOKEN_TO_L2: dict[str, tuple[str, str]] = {
+    # ---- conv ----
+    "Conv2D":           ("conv", "conv_conv2d_standard"),
+    "Conv2d":           ("conv", "conv_conv2d_standard"),
+    "Conv3d":           ("conv", "conv_conv3d_standard"),
+    "Conv1d":           ("conv", "conv_conv1d_standard"),
+    "ConvTranspose2d":  ("conv", "conv_convtranspose2d"),
+    "ConvTranspose3d":  ("conv", "conv_convtranspose3d"),
+    "ConvTranspose1d":  ("conv", "conv_convtranspose1d"),
+    # ---- matmul ----
+    "Matmul":           ("matmul", "matmul_gemm"),
+    "MatMul":           ("matmul", "matmul_gemm"),
+    "Gemm":             ("matmul", "matmul_gemm"),
+    "GEMM":             ("matmul", "matmul_gemm"),
+    "BMM":              ("matmul", "matmul_bmm"),
+    "Bmm":              ("matmul", "matmul_bmm"),
+    # ---- activation ----
+    "ReLU":             ("activation", "activation_relu"),
+    "LeakyReLU":        ("activation", "activation_leaky_relu"),
+    "Sigmoid":          ("activation", "activation_sigmoid"),
+    "Tanh":             ("activation", "activation_tanh"),
+    "Swish":            ("activation", "activation_swish"),
+    "GELU":             ("activation", "activation_gelu"),
+    "SELU":             ("activation", "activation_selu"),
+    "HardSigmoid":      ("activation", "activation_hardsigmoid"),
+    "HardSwish":        ("activation", "activation_hardswish"),
+    "HardTanh":         ("activation", "activation_hardtanh"),
+    "Hardtanh":         ("activation", "activation_hardtanh"),
+    "Softplus":         ("activation", "activation_softplus"),
+    "Softsign":         ("activation", "activation_softsign"),
+    "ELU":              ("activation", "activation_elu"),
+    "Mish":             ("activation", "activation_mish"),
+    "NewGelu":          ("activation", "activation_gelu"),
+    "MinGPTNewGelu":    ("activation", "activation_gelu"),
+    # Generic "Activation" token (KB L2 problem 52). Mapped to
+    # activation_other so the L1 family is still recoverable without
+    # claiming a specific activation function.
+    "Activation":       ("activation", "activation_other"),
+    # ---- softmax-family ----
+    "Softmax":          ("softmax", "softmax_softmax"),
+    "LogSoftmax":       ("softmax", "softmax_log_softmax"),
+    "LogSumExp":        ("softmax", "softmax_logsumexp"),
+    # ---- pooling ----
+    "MaxPool":          ("pooling", "pooling_max_pool"),
+    "AvgPool":          ("pooling", "pooling_avg_pool"),
+    "GlobalAvgPool":    ("pooling", "pooling_global_avg_pool"),
+    # ---- normalization ----
+    "BatchNorm":        ("normalization", "normalization_batchnorm"),
+    "LayerNorm":        ("normalization", "normalization_layernorm"),
+    "GroupNorm":        ("normalization", "normalization_groupnorm"),
+    "InstanceNorm":     ("normalization", "normalization_instancenorm"),
+    "RMSNorm":          ("normalization", "normalization_rmsnorm"),
+    "FrobeniusNorm":    ("normalization", "normalization_frobeniusnorm"),
+    "L1Norm":           ("normalization", "normalization_l1norm"),
+    "L2Norm":           ("normalization", "normalization_l2norm"),
+    # ---- reduction ----
+    # ``Sum``/``Mean``/``Max``/``Min`` in L2 filenames are reduction
+    # operations (e.g. ``x = torch.sum(x, dim=1, keepdim=True)``).
+    # Elementwise *addition* uses the ``Add`` token instead, so the
+    # ambiguity is resolved by token choice.
+    "Sum":              ("reduction", "reduction_sum"),
+    "Mean":             ("reduction", "reduction_mean"),
+    "Max":              ("reduction", "reduction_max"),
+    "Min":              ("reduction", "reduction_min"),
+    "Prod":             ("reduction", "reduction_prod"),
+    "Argmax":           ("reduction", "reduction_argmax"),
+    "Argmin":           ("reduction", "reduction_argmin"),
+    "Cumsum":           ("reduction", "reduction_cumsum"),
+    "cumsum":           ("reduction", "reduction_cumsum"),
+    "Cumprod":          ("reduction", "reduction_cumprod"),
+    "cumprod":          ("reduction", "reduction_cumprod"),
+    # ---- attention ----
+    "ScaledDotProductAttention": ("attention", "attention_scaled_dot_product"),
+    # ---- loss ----
+    "MSELoss":          ("loss", "loss_mse"),
+    "CrossEntropyLoss": ("loss", "loss_cross_entropy"),
+    "HuberLoss":        ("loss", "loss_huber"),
+    "KLDivLoss":        ("loss", "loss_kldiv"),
+    "TripletMarginLoss": ("loss", "loss_triplet_margin"),
+    "HingeLoss":        ("loss", "loss_hinge"),
+    # ---- elementwise ----
+    "Add":              ("elementwise", "elementwise_add"),
+    "Multiply":         ("elementwise", "elementwise_mul"),
+    "Mul":              ("elementwise", "elementwise_mul"),
+    "Divide":           ("elementwise", "elementwise_div"),
+    "Div":              ("elementwise", "elementwise_div"),
+    "Subtract":         ("elementwise", "elementwise_sub"),
+    "Sub":              ("elementwise", "elementwise_sub"),
+    "Clamp":            ("elementwise", "elementwise_clamp"),
+    "Scale":            ("elementwise", "elementwise_scaling"),
+    "Scaling":          ("elementwise", "elementwise_scaling"),
+    "BiasAdd":          ("elementwise", "elementwise_bias_add"),
+    "ResidualAdd":      ("elementwise", "elementwise_residual_add"),
+    "Cast":             ("elementwise", "elementwise_cast"),
+    # ---- memory_movement (none of the KB L2 problems exercise these, but
+    # the table covers ANCHOR_OVERRIDES_L2 names + future motifs)
+    "Gather":           ("memory_movement", "memory_movement_gather"),
+    "Scatter":          ("memory_movement", "memory_movement_scatter"),
+    "Embedding":        ("memory_movement", "memory_movement_embedding"),
+    "Copy":             ("memory_movement", "memory_movement_copy"),
+    "Transpose":        ("memory_movement", "memory_movement_transpose"),
+    # ---- other ----
+    "Dropout":          ("other", "other_dropout"),
+}
+for _tok, (_l1, _l2) in _OP_TOKEN_TO_L2.items():
+    assert _l1 in L1_TO_ID, \
+        f"_OP_TOKEN_TO_L2[{_tok!r}] L1 {_l1!r} not in VOCAB_L1"
+    assert _l2 in L2_TO_ID, \
+        f"_OP_TOKEN_TO_L2[{_tok!r}] L2 {_l2!r} not in VOCAB_L2"
+    assert L2_PARENT_L1[_l2] == _l1, \
+        f"_OP_TOKEN_TO_L2[{_tok!r}]: L2 {_l2!r} parent " \
+        f"{L2_PARENT_L1[_l2]!r} != declared L1 {_l1!r}"
+
+
+# ---------------------------------------------------------------------------
+# Regex fallback (L1 inference for newly-added basenames)
+# ---------------------------------------------------------------------------
+
+FILENAME_RULES: list[tuple[re.Pattern, str]] = [
+    # matmul family
+    (re.compile(r"(?i)matmul|gemm|matrix_multiplication|matrix_vector"), "matmul"),
+    # conv family (depthwise/pointwise/transposed/etc.)
+    (re.compile(r"(?i)conv(?:\d|_|trans|depth|point|standard)"),         "conv"),
+    # normalization family (specifically-named norms BEFORE plain "norm")
+    (re.compile(r"(?i)batch_?norm|layer_?norm|instance_?norm|group_?norm|"
+                r"rms_?norm|frobenius_?norm|l1_?norm|l2_?norm"),         "normalization"),
+    # softmax (must precede activation; some activations have 'soft' too)
+    (re.compile(r"(?i)log_?softmax|softmax"),                            "softmax"),
+    # attention
+    (re.compile(r"(?i)attention"),                                       "attention"),
+    # pooling
+    (re.compile(r"(?i)pooling|max_pool|avg_pool|average_pool|"
+                r"adaptive_pool|lp_pool"),                               "pooling"),
+    # reduction / scan (cumsum, cumprod, argmax, argmin, sum/mean/max-reduce)
+    (re.compile(r"(?i)(sum|mean|max|min|prod)_reduction|"
+                r"argmax|argmin|cumsum|cumprod|reduce_sum|scan_"),       "reduction"),
+    # loss
+    (re.compile(r"(?i)(mse|huber|kldiv|cross_?entropy|triplet|hinge|"
+                r"focal)_?loss"),                                        "loss"),
+    # activation (after softmax, which would otherwise match "soft*")
+    (re.compile(r"(?i)\b(relu|leaky_?relu|sigmoid|tanh|swish|gelu|selu|"
+                r"hard_?sigmoid|soft_?plus|soft_?sign|elu|hard_?tanh|"
+                r"hard_?swish|mish|new_?gelu)\b"),                       "activation"),
+    # memory movement
+    (re.compile(r"(?i)\b(gather|scatter|embedding|copy|transpose)\b"),   "memory_movement"),
+    # elementwise (catch trailing — scalar mul, add, clamp, cast, ...)
+    (re.compile(r"(?i)scalar_multiplication|elementwise|clamp|cast|"
+                r"\b(add|mul|sub|div|scale)\b"),                         "elementwise"),
+]
+for _pat, _l1 in FILENAME_RULES:
+    assert _l1 in L1_TO_ID, \
+        f"FILENAME_RULES references unknown L1 {_l1!r} (pattern {_pat.pattern!r})"
+
+
+_KB_L1_BASENAME_RE = re.compile(r"^(\d+)_")
+
+
+# ---------------------------------------------------------------------------
+# KB filename enumeration (used to disambiguate L1 vs L2 problems sharing
+# the same leading id, e.g. ``1_Square_matrix_multiplication_.py`` (L1)
+# vs ``1_Conv2D_ReLU_BiasAdd.py`` (L2)).
+# ---------------------------------------------------------------------------
+
+def _enumerate_kb_stems(level_dir_name: str) -> set[str]:
+    """Return the set of basename stems under ``KernelBench/.../<level>/``.
+
+    Falls back to an empty set when the directory isn't on disk (CPU-only
+    hosts without the KB submodule). Empty sets cause the parser to skip
+    the per-level disambiguation step and route directly to the token rule
+    fallback, which still produces valid output for the L2 cases that
+    matter; the smoke check at the bottom of this file is the canary that
+    actually requires the KB tree to be present.
+    """
+    repo = Path(__file__).resolve().parents[1]
+    d = repo / "KernelBench" / "KernelBench" / level_dir_name
+    if not d.is_dir():
+        return set()
+    return {p.stem for p in d.glob("*.py")}
+
+
+_KB_L1_STEMS: set[str] = _enumerate_kb_stems("level1")
+_KB_L2_STEMS: set[str] = _enumerate_kb_stems("level2")
+
+
+# ---------------------------------------------------------------------------
+# Public resolution functions
+# ---------------------------------------------------------------------------
+
+def _to_stem(basename: str) -> str:
+    """Normalize an input to a bare stem (no path, no ``.py`` suffix)."""
+    stem = basename
+    if "/" in stem or "\\" in stem:
+        stem = Path(stem).name
+    if stem.endswith(".py"):
+        stem = stem[:-3]
+    return stem
+
+
+def infer_from_filename(basename: str) -> str:
+    """Return the L1 label for a kernel basename.
+
+    Resolution order:
+
+      1. ``ANCHOR_OVERRIDES`` — exact basename match.
+      2. KB L1 problem-id rule table (basename prefix ``<id>_`` with
+         ``id`` in [1, 100]).
+      3. ``FILENAME_RULES`` regex fallback.
+      4. ``"other"``.
+    """
+    if basename in ANCHOR_OVERRIDES:
+        return ANCHOR_OVERRIDES[basename]
+
+    stem = _to_stem(basename)
+    if stem in ANCHOR_OVERRIDES:
+        return ANCHOR_OVERRIDES[stem]
+
+    m = _KB_L1_BASENAME_RE.match(stem)
+    if m:
+        pid = int(m.group(1))
+        # Only treat the id as a KB-L1 hit when the basename actually
+        # matches a known KB L1 problem — otherwise an L2 problem with
+        # the same id prefix would inherit the L1 problem's label.
+        if pid in _KB_L1_PROBLEM_TO_L1 and (not _KB_L1_STEMS or stem in _KB_L1_STEMS):
+            return _KB_L1_PROBLEM_TO_L1[pid]
+
+    for pat, l1 in FILENAME_RULES:
+        if pat.search(stem):
+            return l1
+
+    return "other"
+
+
+def _tokens_to_ops(stem: str) -> list[tuple[str, str]]:
+    """Parse a CamelCase ``_``-separated stem into a sequence of (L1, L2).
+
+    Descriptor words ("for", "with", "over", "a", "dimension", "padded",
+    "strided", ...) that aren't keys in ``_OP_TOKEN_TO_L2`` are silently
+    dropped. The empty list signals "no recognised op tokens" so the
+    caller can fall back to ``("other", "other_misc")``.
+    """
+    parts = stem.split("_")
+    if parts and parts[0].isdigit():
+        parts = parts[1:]
+    ops: list[tuple[str, str]] = []
+    for tok in parts:
+        if not tok:
+            continue
+        if tok in _OP_TOKEN_TO_L2:
+            ops.append(_OP_TOKEN_TO_L2[tok])
+    return ops
+
+
+def parse_l2_sequence(basename: str) -> list[tuple[str, str]]:
+    """Return the (L1, L2) op-sequence implied by an op-sequence basename.
+
+    Examples:
+
+      >>> parse_l2_sequence("1_Conv2D_ReLU_BiasAdd.py")
+      [('conv', 'conv_conv2d_standard'),
+       ('activation', 'activation_relu'),
+       ('elementwise', 'elementwise_bias_add')]
+      >>> parse_l2_sequence("99_Matmul_GELU_Softmax.py")
+      [('matmul', 'matmul_gemm'),
+       ('activation', 'activation_gelu'),
+       ('softmax', 'softmax_softmax')]
+      >>> parse_l2_sequence("47_Sum_reduction_over_a_dimension.py")
+      [('reduction', 'reduction_sum')]
+      >>> parse_l2_sequence("vector_add")
+      [('elementwise', 'elementwise_add')]
+
+    Resolution order:
+
+      1. ``ANCHOR_OVERRIDES_L2`` — exact basename match (microbench /
+         megakernel ``phase_*`` / megakernel ``op_*``).
+      2. KB L1 problem-id table (``_KB_L1_PROBLEM_TO_OPS``) — when the
+         basename is a known L1 problem (so the L2 problem with the same
+         id prefix doesn't shadow it).
+      3. KB L2 problem-id table (``_KB_L2_PROBLEM_TO_OPS``) — override for
+         L2 problems where the token parser is ambiguous (currently empty).
+      4. Token rule fallback (``_OP_TOKEN_TO_L2``).
+      5. ``[("other", "other_misc")]``.
+    """
+    if basename in ANCHOR_OVERRIDES_L2:
+        return [ANCHOR_OVERRIDES_L2[basename]]
+    stem = _to_stem(basename)
+    if stem in ANCHOR_OVERRIDES_L2:
+        return [ANCHOR_OVERRIDES_L2[stem]]
+
+    m = _KB_L1_BASENAME_RE.match(stem)
+    pid = int(m.group(1)) if m else None
+    if pid is not None:
+        # Treat as KB L1 only if the basename matches a known L1 stem;
+        # this disambiguates L1 problem 1 (``1_Square_matrix_...``) from
+        # L2 problem 1 (``1_Conv2D_ReLU_BiasAdd``).
+        if pid in _KB_L1_PROBLEM_TO_OPS and (
+            not _KB_L1_STEMS or stem in _KB_L1_STEMS
+        ):
+            return list(_KB_L1_PROBLEM_TO_OPS[pid])
+        if pid in _KB_L2_PROBLEM_TO_OPS and (
+            not _KB_L2_STEMS or stem in _KB_L2_STEMS
+        ):
+            return list(_KB_L2_PROBLEM_TO_OPS[pid])
+
+    ops = _tokens_to_ops(stem)
+    if ops:
+        return ops
+
+    return [("other", "other_misc")]
+
+
+def infer_from_filename_l2(basename: str) -> tuple[str, str]:
+    """Return a single (L1, L2) pair for a kernel basename.
+
+    L1 problems return their (L1, L2) directly. L2 problems return the
+    *first* op of the parsed sequence — useful for the legacy "one label
+    per trace" code paths in ``build_splits.py`` and the dominant-class
+    heuristic. For per-launch labeling on L2 problems use
+    ``parse_l2_sequence`` and align to the kernel-launch order.
+    """
+    ops = parse_l2_sequence(basename)
+    if not ops:
+        return ("other", "other_misc")
+    return ops[0]
+
+
+def infer_from_aten(aten_op: str) -> str:
+    """Stub for an aten-op label path.
+
+    Returns ``"other"`` rather than raising so callers wired in early can
+    keep producing labels without a hard dependency.
+    """
+    del aten_op
+    return "other"
+
+
+# ---------------------------------------------------------------------------
+# Smoke checks
+# ---------------------------------------------------------------------------
+
+def _smoke_check_kb_l1() -> tuple[int, int]:
+    """Walk ``KernelBench/KernelBench/level1/`` and report any L1 miss.
+
+    Returns ``(scanned, fail_count)``. Used by the combined entry point at
+    the bottom of this file to compute a single exit code across L1+L2.
+    """
+    repo = Path(__file__).resolve().parents[1]
+    l1_dir = repo / "KernelBench" / "KernelBench" / "level1"
+    if not l1_dir.is_dir():
+        print(f"[smoke L1] KB L1 dir not found at {l1_dir}; "
+              f"skipping coverage check", file=sys.stderr)
+        return 0, 0
+
+    files = sorted(p.name for p in l1_dir.glob("*.py"))
+    by_l1: dict[str, list[str]] = {l1: [] for l1 in VOCAB_L1}
+    for name in files:
+        by_l1[infer_from_filename(name)].append(name)
+
+    n = sum(len(v) for v in by_l1.values())
+    print(f"[smoke L1] scanned {n} L1 files in {l1_dir}")
+    for l1 in VOCAB_L1:
+        print(f"  {l1:<16s} {len(by_l1[l1]):>3d}")
+
+    other_files = by_l1["other"]
+    if other_files:
+        print("[smoke L1] FAIL — basenames that fell through to 'other':",
+              file=sys.stderr)
+        for fn in other_files:
+            print(f"  {fn}", file=sys.stderr)
+        return n, 1
+    print("[smoke L1] OK — every KB L1 filename resolves to a non-'other' L1")
+    return n, 0
+
+
+def _smoke_check_kb_l2() -> tuple[int, int]:
+    """Walk ``KernelBench/KernelBench/level2/`` and report any L2 miss.
+
+    Coverage criterion: every L2 filename resolves to a sequence of
+    one-or-more (L1, L2) pairs with no ``other_misc`` fallthrough. Each
+    op token must produce a recognised pair -- a single ``other_misc``
+    in any sequence fails the smoke check.
+
+    Returns ``(scanned, fail_count)``.
+    """
+    repo = Path(__file__).resolve().parents[1]
+    l2_dir = repo / "KernelBench" / "KernelBench" / "level2"
+    if not l2_dir.is_dir():
+        print(f"[smoke L2] KB L2 dir not found at {l2_dir}; "
+              f"skipping coverage check", file=sys.stderr)
+        return 0, 0
+
+    files = sorted(p.name for p in l2_dir.glob("*.py"))
+    by_l2: dict[str, int] = {l2: 0 for l2 in VOCAB_L2}
+    bad: list[tuple[str, list[tuple[str, str]]]] = []
+    for name in files:
+        ops = parse_l2_sequence(name)
+        if any(l1 == "other" and l2 == "other_misc" for l1, l2 in ops):
+            bad.append((name, ops))
+        for _l1, l2 in ops:
+            if l2 in by_l2:
+                by_l2[l2] += 1
+
+    n = len(files)
+    print(f"[smoke L2] scanned {n} L2 files in {l2_dir}")
+    # Group counts by L1 family for readability.
+    for l1 in VOCAB_L1:
+        total = sum(by_l2[l2] for l2 in _L2_BY_L1[l1])
+        print(f"  {l1:<16s} {total:>5d}  (across "
+              f"{len(_L2_BY_L1[l1])} L2 classes)")
+
+    if bad:
+        print("[smoke L2] FAIL — L2 problems with at least one unresolved "
+              "token (other_misc):", file=sys.stderr)
+        for fn, ops in bad:
+            print(f"  {fn} -> {ops}", file=sys.stderr)
+        return n, 1
+    print("[smoke L2] OK — every KB L2 filename resolves to a complete "
+          "(L1, L2) sequence with no other_misc fallthrough")
+    return n, 0
+
+
+def _smoke_check() -> int:
+    """Run both L1 and L2 coverage checks; return 0 iff both pass."""
+    _, fail_l1 = _smoke_check_kb_l1()
+    _, fail_l2 = _smoke_check_kb_l2()
+    return 1 if (fail_l1 or fail_l2) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_smoke_check())