# KernelSight Dataset This document describes the on-disk dataset produced by the data pipeline: file layout, the 24-channel input tensor, the per-bin and per-segment labels, the vocabularies, and the splits. The model side (ViT, baselines) consumes this dataset; the pipeline itself runs on profile artifacts collected via `crun` on H100 / H200 nodes. For the data pipeline state and outstanding TODOs, see `README.md`. For operational notes (CUPTI Range Profiler quirks, nsys clock alignment), see `CLAUDE.md` §"CUPTI operational notes". ## 1. Snapshot count and motifs The dataset is the set of `(tensor_input.npz, labels.npz)` pairs living under `kernels//_out/**/` on shared NFS — one per profiled kernel snapshot. The motif families: | Motif family | Notes | |---|---| | Microbenchmarks | `vector_add`, `gather`, `reduction`, `scatter`, `wgmma` (one class each) | | Megakernel | 4-phase sequential workload (`elementwise → memory_movement → reduction → matmul`) | | KernelBench L1 | Single-op problems (`level1/*`), one labeled segment each | | KernelBench L2 | Op-sequence problems (`level2/*`), one segment per op in the chain | | CUTLASS Tier-1 | `cutlass_gemm` (TF32 WS-GEMM, 278 snaps), `cutlass_fmha` (FA3, 85 snaps), `cutlass_fp8_gemm` (FP8 WS-GEMM, 14 snaps), `cutlass_sparse_gemm` (2:4 sparse, 18 snaps), `cutlass_grouped_gemm` (grouped → `matmul_bmm`, 12 snaps). Each a prebuilt CUTLASS example as one labeled black-box anchor, **parameter-swept** over M/N/K and motif-specific axes. | | CUTLASS WS-overlap PoC | `cutlass_ws_overlap` — real CUTLASS ex.48 WS-GEMM; device `%globaltimer` markers → multi-hot overlap baked into its corpus `labels.npz`. **Parameter-swept**: 472 snapshots, all `multihot_has_overlap = 1`. | The 6 CUTLASS motifs are **parameter-swept** (`dev/launch_cutlass_sweep.sh` → `dev/postprocess_sweep.sh`). The KB corpus is also swept (selective dtype/seed). Exact snapshot and split counts are **regenerated by `tools/build_splits.py` after each collection** — see the `n` field in each `splits/*.json` (currently **1444 traces**: train 1124 / val 160 / test 160; param_ood 956, iid 433, composed 1124). See `scale.md` (repo root, local-only) for how to grow further. ## 2. File layout Per snapshot: ``` kernels//_out/ ├── crun_submit.log # SLURM submission log ├── kernel_meta.json # Per-launch identity metadata (KB only) ├── cupti/ # CUPTI Range Profiler output │ └── range_raw.json # Per-launch warp-stall taxonomy + pipe-util │ # metrics (kernel-replay) ├── nvbit/ # NVBit region profiler output │ ├── region_stats__.json # Per-region inst_class + counters │ ├── pcmap__.json # PC → region attribution │ ├── hotspots__.json # Per-BB exec counts │ ├── sass_all__.sass # Raw SASS dump │ └── summary__.txt ├── nsys/ │ └── .{nsys-rep,sqlite} # Nsight Systems trace ├── input/ │ ├── tensor_input.npz # [24, 512] model input — see §3 │ ├── tensor_ncu.npz # Per-source side artifact (Range: stall + pipe-util) │ ├── tensor_nsys.npz # Per-source side artifact (nsys system/BW) │ ├── heatmap_*.png # Per-source heatmaps │ ├── heatmap_combined.png # All sources stacked │ └── timeseries_*.png └── labels/ └── labels.npz # Per-bin + per-segment labels — see §4 ``` Optional side artifacts (NOT built automatically by `run.sh`; need separate invocations of the respective `tools/` scripts): ``` kernels//_out/ ├── fingerprint/fingerprint.npz # 32-D instruction-mix vector — §6 └── sass/sass_modality.npz # [N_pc, 9] per-kernel SASS matrix — §7 (RETIRED: builder removed) ``` ## 3. Input tensor: `tensor_input.npz` ### 3.1 Shape and time binning ``` data [24, 512] float32 — 24 counter channels × 512 timesteps counter_names [24] object — string name per row time_edges_ns [513] int64 — bin boundary timestamps (ns) kernels [K, 2] int64 — per-kernel-launch [start_ns, end_ns] kernel_names [K] object — demangled name per launch kernel_function_index [K] int64 — index into sass_modality kernel table ``` The time axis is **512 equal-width bins covering each trace's kernel-active window**: - The renderer clips to `[first_kernel_start - 50 ms, last_kernel_end + 50 ms]`. - The clipped window is divided into 512 equal bins. - So **bin width is per-trace, not global**. Observed widths: | Snapshot | Window | Bin width | |---|---|---| | `KB L1_P1` (matmul) | 253 ms | 0.50 ms/bin | | `KB L2_P5` | 520 ms | 1.01 ms/bin | | `gather` | 5.8 s | 11.28 ms/bin | | `wgmma` | 5.9 s | 11.48 ms/bin | | `vector_add` | 6.9 s | 13.45 ms/bin | | `reduction` | 11.6 s | 22.74 ms/bin | | `cutlass_fp8_gemm` (varies) | ~0.1–35 s | ~0.2–68 ms/bin | | `scatter` | 15.3 s | 29.82 ms/bin | The 512-token sequence length stays constant; the ViT never sees absolute time. If you need wall-clock per bin, use `time_edges_ns[i:i+2]`. ### 3.2 Channel layout All 24 channels carry live signal across the corpus — there are no zero-by-construction placeholder rows. The layout is the source of truth in `tools/render_model_input.py:CANONICAL_INPUT_CHANNELS`. (The pre-trim 64-channel layout had 39 dead channels from Hopper uncollectable counters + deferred tiers + corpus-absent pipe types, plus a `stall_total` pad row. Those 40 rows were removed after an empirical audit of the pre-trim corpus.) #### Pipe signature (rows 0–6, PRIMARY operator-identity) Source: `ncu` (Range Profiler `.avg.pct_of_peak_sustained_active` form). | Row | Name | Semantics | |---|---|---| | 0 | `pipe: tensor_op_hmma` | HMMA tensor-core pipe utilization (FP16/BF16/TF32 matmul) | | 1 | `pipe: xu` | XU pipe (transcendentals / type conversion) | | 2 | `pipe: fma` | FMA pipe (FFMA / HFMA) | | 3 | `pipe: alu` | ALU pipe (integer add/sub/mul) | | 4 | `pipe: lsu` | LSU pipe (global / shared load-store) | | 5 | `pipe: cbu` | CBU pipe (control / branch) | | 6 | `pipe: tma` | TMA pipe (Hopper async bulk copy) | Three pipes from the old Tier A are absent from the corpus and removed: `tensor_op_imma` (no INT8 tensor ops), `tensor_op_dmma` (no FP64 tensor ops), `fp64` (no FP64 pipe activity). #### Memory access shape (rows 7–8) | Row | Name | Source | Semantics | |---|---|---|---| | 7 | `hit: l2` | `ncu` | L2 cache hit rate (`lts__t_sector_hit_rate.pct`) | | 8 | `atom: lts_atomic_input_pct` | `ncu` | L2 atomic-input cycles, fraction of peak [0,1] (normalized via the `atom:` divisor) | #### Secondary discriminators (rows 9–12) | Row | Name | Source | Semantics | |---|---|---|---| | 9 | `stall: short_scoreboard` | `ncu` | Short-scoreboard stall ratio | | 10 | `stall: barrier` | `ncu` | Barrier-wait stall ratio | | 11 | `pred_on_per_inst_ratio` | `ncu` | Predicate-on fraction (catches masked attention) | | 12 | `gmem_coalesce_ratio` | `nvbit` | Sectors-per-warp-load ratio from NVBit region_stats | #### System / BW from nsys (rows 13–16) Source: `nsys`. Pulled from the nsys `TARGET_INFO_GPU_METRICS` periodic samples (~10 kHz, gh100 set). | Row | Name | Semantics | |---|---|---| | 13 | `SMs Active [Throughput %]` | Fraction of SMs active per sample | | 14 | `DRAM Read Bandwidth [Throughput %]` | DRAM read BW % of peak | | 15 | `DRAM Write Bandwidth [Throughput %]` | DRAM write BW % of peak | | 16 | `Tensor Active [Throughput %]` | Tensor-core active fraction | #### Per-bin SASS modality (rows 17–23) Source: NVBit `inst_class` counts via `_compute_tier_i` (renderer), coalesced to 7 live categories, normalized to fractions, tiled by kernel-launch intervals. Two categories from the old 9-channel set (`sass_compute_transcendental`, `sass_atomic`) are absent from the corpus and removed. | Row | Name | NVBit `inst_class` source | |---|---|---| | 17 | `sass_compute_fma` | `alu_fp32` | | 18 | `sass_compute_tensor` | `tensor_wgmma` | | 19 | `sass_memory_global` | `ld_global + st_global` | | 20 | `sass_memory_shared` | `ld_shared + st_shared` | | 21 | `sass_memory_tma` | `special` (cp.async / TMA / ldgsts) | | 22 | `sass_control` | `branch + call + ret` | | 23 | `sass_misc` | `alu_int + barrier + membar + ld_local + st_local + other` | ### 3.3 Standardization Each row is divided by a physical-scale divisor (see `PHYSICAL_MAX` and `PHYSICAL_DIVISOR_PATTERNS` in the renderer) so values typically land in `[0, 1]` while preserving cross-channel magnitude differences. Examples: | Pattern | Divisor | Effect | |---|---|---| | `pipe:` | 100.0 | percent → fraction | | `[Throughput %]` (nsys) | 100.0 | percent → fraction | | `stall: …` | 64.0 | per-issue-active ratio → fraction of warps | | `gmem_coalesce_ratio` | 8.0 | sectors/warp → normalized | Per-channel min/max normalization is intentionally avoided (would collapse all rows to `[0, 1]` even when they share the same shape and lose cross-channel magnitude information). ### 3.4 Active row count After the channel trim, all 24 rows carry signal on every motif that exercises the underlying hardware feature. Per-motif active counts: | Motif | Active rows | |---|---| | `gather` | 15 / 24 | | `vector_add` | 16 / 24 | | `wgmma` | 19 / 24 | | `scatter` | 20 / 24 | | `reduction` | 22 / 24 | | `cutlass_grouped_gemm` | varies per group | The remaining zeros on simpler motifs (e.g. `gather` doesn't use tensor cores, so `pipe: tensor_op_hmma` = 0) reflect real hardware inactivity, not uncollectable counters. ## 4. Labels: `labels.npz` 24 keys, all aligned to the same `[T=512]` time axis or per-segment `[S]` arrays. Built by `tools/build_labels.py` from the nsys kernel timeline + the motif-specific segmentation logic. The 4 multi-hot keys (§4.3) are **additive**: they were introduced alongside the original 20 single-label keys without changing any of them, so existing single-label consumers keep working unchanged. ### 4.1 Per-bin arrays (length T = 512) | Key | dtype | Semantics | |---|---|---| | `workload_l1` | int32 | L1 class id per bin (–1 if unlabeled) | | `workload_l2` | int32 | L2 class id per bin (–1 if unlabeled) | | `workload_l1_multihot` | uint8 `[T, 12]` | per-bin multi-hot over L1 (overlapping labels — see §4.3) | | `workload_l2_multihot` | uint8 `[T, 73]` | per-bin multi-hot over L2 | | `multihot_n_active` | uint8 | # active L1 classes per bin (= L1 multi-hot row sum) | | `segment_id` | int32 | 0-based segment ordinal per bin (–1 if no segment overlaps) | | `mask_any_kernel` | uint8 | 1 if any kernel interval overlaps this bin | | `mask_labeled` | uint8 | 1 if `workload_l1 >= 0` for this bin | | `time_edges_ns` | int64 | `[T+1] = [513]` bin boundary timestamps | (`workload_l*_multihot` and `multihot_n_active` are `[T, *]` / `[T]` arrays; the table groups them with the per-bin keys. There is also a scalar `multihot_has_overlap` (uint8 `[]`) — see §4.3.) ### 4.2 Per-segment arrays (length S, motif-dependent) | Key | shape | dtype | Semantics | |---|---|---|---| | `segment_starts` | `[S]` | int64 | First bin index (inclusive) | | `segment_ends` | `[S]` | int64 | Last bin index (exclusive) | | `segment_label_l1` | `[S]` | int32 | L1 class id | | `segment_label_l2` | `[S]` | int32 | L2 class id | | `segment_kernel_names` | `[S]` | object | Demangled kernel name (or NVTX op label) | | `segment_predecessor_l1` | `[S]` | int32 | L1 class of the preceding segment in start order (–1 for first) | | `segment_predecessor_l2` | `[S]` | int32 | L2 class of the preceding segment | | `segment_position` | `[S]` | int32 | 0-based ordinal of this segment within its L2 group (per-phase position) | | `attribute_flags` | `[S, 8]` | uint8 | 0/1 per attribute (see §5) | `S` varies per snapshot: - Microbenchmarks: `S = 1` (single-class, single-kernel-family runs). - KernelBench L1: `S = 1` per problem (single op). - KernelBench L2: `S = 2..6` (op-sequence problems, one segment per op in the chain). - Megakernel: `S ≈ 500` (one segment per inner `op_*` NVTX range, bin-resolvable subset). ### 4.3 Multi-label (overlapping) per-bin tracks — ADDITIVE The single-label fields (`workload_l1` / `workload_l2`) carry exactly **one** class id per bin. Real fused, warp-specialized kernels run >1 workload phase *concurrently* — e.g. a Hopper WS-GEMM's producer TMA-load phase (`memory_movement`) overlaps its consumer WGMMA phase (`matmul`) in wall-clock time. The multi-hot tracks let a bin carry 2+ classes at once. | Key | shape | dtype | Semantics | |---|---|---|---| | `workload_l1_multihot` | `[T, 12]` | uint8 | `[t, c] = 1` iff L1 class `c` is active in bin `t` | | `workload_l2_multihot` | `[T, 73]` | uint8 | `[t, j] = 1` iff L2 class `j` is active in bin `t` | | `multihot_n_active` | `[T]` | uint8 | # active L1 classes in bin `t` (= row sum of `workload_l1_multihot`) | | `multihot_has_overlap` | `[]` | uint8 | 0 if every bin has ≤1 active class (sequential one-hot); 1 if any bin carries ≥2 | **Relationship to the single-label fields (a strict superset):** - **Subsumption.** The bin's single label is always set in its multi-hot row (`workload_l1_multihot[t, workload_l1[t]] == 1` wherever `workload_l1[t] ≥ 0`). So `workload_l1` is the *dominant / argmax* class and is guaranteed to be a member of the multi-hot set. A single-label consumer is never contradicted. - **Degenerate on the sequential corpus.** Every sequential snapshot (microbenchmarks, KernelBench L1/L2, the CUTLASS Tier-1 ops) is one op at a time — so the multi-hot is exactly the **one-hot** of the single label, every row sums to ≤ 1, and `multihot_has_overlap == 0`. The schema subsumes the single-label case; it does not change it. (The two device-marker GEMM PoCs are the exception — see below.) - **`mask_labeled` interaction.** `multihot_n_active > 0` is the multi-label analog of `mask_labeled`; on the sequential corpus the two are identical. - **Hierarchy.** Wherever an L2 bit is set, its parent L1 bit (`l2_parent_l1[j]`) is set too — the same L1/L2 hierarchy the single-label fields obey, enforced by CI on the multi-hot rows. **Where genuine overlap comes from.** Only device-instrumented fused kernels produce ≥2 concurrent labels. Two device-`%globaltimer`-marker GEMM PoCs bin their region markers (`produce_*` → `memory_movement`, `consume_*` → `matmul`, `epilogue` → `memory_movement`) into the multi-hot tracks of their corpus `labels.npz` (`build_corpus_labels.py`). After the parameter sweep, **29 snapshots carry `multihot_has_overlap = 1`** (`cutlass_ws_overlap`: 1 baseline + 15 variants; `cutlass_ws_overlap`: 1 baseline + 471 variants — each variant re-runs its marker stage at the variant shape, so overlap depth tracks K / tile / problem size). The two baselines, for reference: - `cutlass_ws_overlap` (real CUTLASS ex.48 WS-GEMM) — overlap on all **28 bins** of its labeled launch window (producer TMA-load ‖ consumer WGMMA). - `cutlass_ws_overlap` (WS-GEMM with device markers) — **majority of bins carry ≥2 labels (98.9 % of active bins)**. The standalone `build_multihot_demo.py` → `labels_multihot.npz` path is a demo, not part of the corpus output. The general ingestion hook is `build_labels_for(out_dir, extra_spans=[(start_bin, end_bin, l1, l2), …])`. **This multi-label (multi-hot) overlap track is the adopted labeling scheme for overlapping phases.** See `mega-kernel-profiling.md` for the per-warp marker analysis and the per-region channel decomposition. **Labels are ground truth, not counter-derived (no leakage).** The multi-hot labels are derived **only** from the `%globaltimer` device markers (warp role → phase boundaries); they are **independent of the 24 counter input channels** in §3. The model's task is to *predict* these labels **from** the counters, and because the labels never read the counters there is no input↔label leakage. **Model side (described, not implemented here).** The multi-hot tracks are the adopted target for a **sigmoid / multi-label head** (per-class binary cross-entropy over the 12 L1 / 73 L2 channels, masked by `multihot_n_active > 0`); segmental F1 is then computed **per class** (each class is its own on/off track / temporal IoU). The existing single-label softmax head keeps training off `workload_l1` / `workload_l2` unchanged. ### 4.4 Vocabularies (carried in every `labels.npz`) | Key | shape | Notes | |---|---|---| | `vocab_l1` | `[12]` object | See §5.1 | | `vocab_l2` | `[73]` object | See §5.2 | | `attribute_flag_names` | `[8]` object | See §5.3 | | `spatial_state_vocab` | `[5]` object | See §5.4 (vocab carried for model side; per-bin assignment is out of scope — no fused kernels) | | `l2_parent_l1` | `[73]` int32 | `l2_parent_l1[j]` = L1 id of the parent class of L2 id `j` | The vocabs are the **single source of truth** in `tools/workload_taxonomy.py`. CI invariants in `tests/test_tensor_invariants.py` enforce the cardinalities + hierarchy. ## 5. Vocabularies ### 5.1 L1 classes (12) ``` 0 matmul — GEMM / matvec / batched matmul kernels 1 conv — 1D / 2D / 3D convolutions (depthwise, transposed, etc.) 2 activation — ReLU, GELU, sigmoid, etc. 3 normalization — BatchNorm, LayerNorm, RMSNorm, GroupNorm 4 softmax — softmax / log_softmax / cross-entropy softmax stage 5 pooling — max / avg / adaptive pooling 6 reduction — sum / mean / max / argmax reductions 7 attention — self / cross attention (Q·K^T, softmax(QK)V) 8 loss — MSE / CE / NLL loss kernels 9 elementwise — add / mul / fused elementwise epilogues 10 memory_movement — copy / transpose / gather / scatter / permute / reshape 11 other — dropout, indexing, misc ``` ### 5.2 L2 classes (73) `VOCAB_L2` in `tools/workload_taxonomy.py`. Sample subclasses: - `matmul/{bmm, gemm, matvec}` (3) - `conv/{conv1d_standard, conv2d_depthwise, conv2d_standard, …, convtranspose3d}` (~13) - `activation/{relu, gelu, sigmoid, …}` (~8) - `normalization/{batchnorm, layernorm, rmsnorm, groupnorm, …}` (~6) - `softmax/{softmax, logsoftmax, cross_entropy}` (~3) - `pooling/{maxpool, avgpool, adaptive_avgpool, …}` (~6) - `reduction/{sum, mean, max, argmax}` (~4) - `attention/{qkv_matmul, attn_softmax, attn_v_matmul, mha_fused}` (~4) - `loss/{mse, ce, nll, bce, smooth_l1}` (~5) - `elementwise/{add, mul, fused_relu, fused_gelu, …}` (~8) - `memory_movement/{copy, gather, scatter, transpose, permute}` (~5) - `other/{dropout, misc}` (~2) The full list with the L1 parent of each is in `VOCAB_L2` / `L2_PARENT_L1`. The hierarchy invariant `vocab_l1[l2_parent_l1[j]]` == L1-parent-of-`vocab_l2[j]` is checked by CI. ### 5.3 Attribute flags (8, multi-label per segment) ``` sparse — Sparse layout / sparsity-aware kernel tma — Uses Hopper TMA bulk-copy cluster — Uses CGA (cluster) launch masked — Has predicate-mask logic (e.g. causal attention) persistent — Persistent-style loop body vectorized_store — STG.128 / vectorized writes detected atomic_accum — atomicAdd / red.add accumulation epilogue ldgsts — Uses cp.async / LDGSTS (Ampere-style async copy) ``` `attribute_flags[s, k]` is 1 if segment `s` exhibits flag `k`. Derived by `_attribute_flags_from_meta` from kernel-name pattern matching + NVBit SASS dump scan. ### 5.4 Spatial state (5, vocab only — per-bin derivation out of scope) ``` uniform — All SMs doing similar work wavefront_transition — Producer / consumer wave transition tail_effect — Last-wave imbalance load_imbalanced — Persistent uneven distribution hotspot — Single SM / SMSP doing most of the work ``` The vocab is exposed so the model side can define a 5-class head, but **per-bin `spatial_state[T]` is NOT in `labels.npz`** — deriving it reliably requires per-SM markers or per-SMSP instance data, which is deferred along with Tier G (no fused kernels in the corpus to motivate the C++ work). ## 6. Optional: 32-D fingerprint (`fingerprint.npz`) Built by `tools/build_fingerprint.py` from NVBit `region_stats_*.json`. **Not produced by `run.sh` automatically** — invoke separately if needed (the CUTLASS/PoC sweep's `dev/postprocess_sweep.sh` runs it for every variant): ```bash python tools/build_fingerprint.py kernels//_out ``` Schema: ``` vec [32] float32 — concatenation of: 16-D normalized inst_class fractions 16-D normalized inst_pipe fractions class_names [16] object — inst_class names (parallel to vec[0:16]) pipe_names [16] object — inst_pipe names (parallel to vec[16:32]) ``` Used as a static per-trace embedding for retrieval / nearest-neighbor sanity checks on the model side. ## 7. Optional: per-PC SASS modality (`sass_modality.npz`) **Historical / retired — not part of the current pipeline.** This artifact was built by the since-removed `tools/build_sass_modality.py` from CUPTI `sassmetrics_*.json`, but the per-PC SASS-metric injector (`ikp_cupti_sassmetrics`) was retired along with the PM/PC-sampling injectors, so `sassmetrics_*.json` is no longer collected and `sass_modality.npz` cannot be regenerated from the current tree. The in-tensor SASS modality (§3.2 rows 17–23) comes from NVBit and is unaffected. The schema below documents previously-collected files; `tensor_input.npz`'s `kernel_function_index[K]` still indexes a `sass_modality.npz` kernel table when one is present. Schema: ``` column_names [F=9] object — see below kernel_names [K] object — demangled kernel name per matrix kernel_cubin_crcs [K] int64 — cubin CRC for rebuild disambiguation pc_offsets [K] object — per-kernel int64[N_pc_k] of PC offsets matrices [K] object — per-kernel float64[N_pc_k, F=9] matrix source_files [K] object — per-kernel list[str] (source attribution per PC) source_lines [K] object — per-kernel int64[N_pc_k] (source line per PC) ``` The 9 columns are: ``` raw (from CUPTI smsp__sass_*): inst_executed thread_inst_executed thread_inst_executed_pred_on inst_executed_op_global_ld inst_executed_op_global_st sectors_mem_global sectors_mem_global_ideal derived: pred_on_ratio = pred_on / max(thread_inst_executed, 1) in [0, 1] coalesce_per_pc = sectors_mem_global / max(sectors_ideal, 1) in [1, ~8] ``` The model side cross-attends from a bin embedding to a gathered `[K, N_pc, 9]` tensor when the bin's kernel mapping is known (see `tools/sass_dataloader_stub.py` for the wiring sketch). The `tensor_input.npz` `kernel_function_index[K]` field gives the index into `sass_modality.npz`'s `kernel_names` for each kernel launch. ## 8. Splits Built by `tools/build_splits.py`. Seven JSON files under `splits/`: ``` splits/ ├── train.json — ~70% of labeled traces (L1-stratified) ├── val.json — ~17% ├── test.json — ~13% ├── iid.json — random-stratified subset ├── composed.json — multi-segment traces (KB L2 + CUTLASS) ├── length_ood.json — long-tail segment-count traces └── param_ood.json — CUTLASS/PoC parameter-sweep variants (fixed op binary, unseen launch geometry / tile); 52 traces ``` (Per-split trace counts are regenerated by `build_splits.py` — read each file's `n` field for the current numbers.) Each split JSON has the shape: ```json { "split": "iid", "seed": 0, "n": 62, "traces": [ { "path": "kernels/gather/_out/input/tensor_input.npz", "motif": "gather", "n_kernels": 10001, "n_unique_kernels": 1, "T": 512, "l1_labels": ["memory_movement"], "l2_labels": ["memory_movement_gather"], "dominant_l1": "memory_movement", "dominant_l2": "memory_movement_gather" }, ... ], "notes": "..." } ``` `path` is relative to the repo root. The matching `labels.npz` lives at `/../labels/labels.npz`. Splits are **L1-stratified** so each split sees every L1 class with at least 3 examples (per `test_l1_strata_coverage`). KernelBench L2 problems are routed to `composed` to exercise multi-segment / predecessor-context inference. Megakernel goes to `length_ood` as the single longest-segment- count trace in the corpus. `param_ood` holds the 52 CUTLASS/PoC parameter-sweep variants (`_is_param_sweep_variant` in `build_splits.py`: non-baseline `_out//` snapshots of a binary-fixed motif, excluding KernelBench's dtype sweep) — a held-out fixed-op / unseen-geometry generalization bin. The legacy four (`iid` / `param_ood` / `composed` / `length_ood`) are overlapping *views* over the same corpus, orthogonal to the disjoint `train` / `val` / `test` partition. ## 9. Known limitations The 24-channel tensor has no zero-by-construction placeholder rows — every channel carries real signal somewhere in the corpus. The 40 dead channels from the pre-trim 64-channel layout (Hopper-uncollectable counters, deferred per-instance tiers, corpus-absent pipe types, and the `stall_total` pad row) were removed after an empirical audit across the full pre-trim corpus (4322 tensor files). Remaining zeros reflect genuine hardware inactivity (e.g. `pipe: tma` is zero on simple microbenchmarks that don't use TMA bulk copy). The 5 microbench motifs + KB problems + CUTLASS ops together cover **all 12 L1 classes and ~all 73 L2 classes**, so the label-side coverage is strong. ## 10. Loading examples ### NumPy ```python import numpy as np t = np.load("kernels/wgmma/_out/input/tensor_input.npz", allow_pickle=True) X = t["data"] # shape (24, 512), float32 names = list(t["counter_names"]) edges = t["time_edges_ns"] # shape (513,), bin boundaries kernels = t["kernels"] # shape (K, 2), per-launch [start, end] ns l = np.load("kernels/wgmma/_out/labels/labels.npz", allow_pickle=True) y_l1 = l["workload_l1"] # (512,) int32 y_l2 = l["workload_l2"] # (512,) int32 mask = l["mask_labeled"] # (512,) uint8 — 1 where y_l1 >= 0 attrs = l["attribute_flags"] # (S, 8) uint8 vocab_l1 = list(l["vocab_l1"]) print(f"bin 256 → L1 = {vocab_l1[y_l1[256]]}") # Multi-label (overlapping) head target — sigmoid / BCEWithLogits over classes. y_l1_mh = l["workload_l1_multihot"] # (512, 12) uint8, 0/1 active = [vocab_l1[c] for c in np.nonzero(y_l1_mh[256])[0]] print(f"bin 256 → active L1 set = {active} (n_active = {l['multihot_n_active'][256]})") ``` ### PyTorch Dataset sketch ```python import json, numpy as np, torch from torch.utils.data import Dataset class KernelSightDataset(Dataset): def __init__(self, split_path): with open(split_path) as f: split = json.load(f) self.traces = split["traces"] def __len__(self): return len(self.traces) def __getitem__(self, i): rec = self.traces[i] tpath = rec["path"] lpath = tpath.replace("/input/", "/labels/").replace( "tensor_input.npz", "labels.npz" ) t = np.load(tpath, allow_pickle=True) l = np.load(lpath, allow_pickle=True) X = torch.from_numpy(t["data"]).float() # (24, 512) y_l1 = torch.from_numpy(l["workload_l1"]).long() # (512,) y_l2 = torch.from_numpy(l["workload_l2"]).long() # (512,) mask = torch.from_numpy(l["mask_labeled"]).bool() # (512,) # Treat unlabeled bins as ignore_index by setting them to -100 y_l1 = torch.where(mask, y_l1, torch.full_like(y_l1, -100)) y_l2 = torch.where(mask, y_l2, torch.full_like(y_l2, -100)) return X, y_l1, y_l2 train_ds = KernelSightDataset("splits/train.json") val_ds = KernelSightDataset("splits/val.json") test_ds = KernelSightDataset("splits/test.json") ``` ### ViT-on-heatmap framing (suggestion, not required) ```python # Treat X as a 24×512 single-channel "image". # The dataloader stub's default patch_shape=(4, 16) tiles it into # 6 channel groups × 32 time chunks = 192 patches of 4×16=64 values each. patches = X.unfold(0, 4, 4).unfold(1, 16, 16) # (6, 32, 4, 16) patches = patches.contiguous().view(6 * 32, 4 * 16) # (192, 64) # Per-bin head (output 512 logits per class): un-patch the time dim back to 512. ``` With 24 channels, 4-row patches give 6 channel groups (24 = 6×4 exactly, no padding): pipes (rows 0–6 + L2 hit rate), discriminators + nsys (rows 8–16), SASS modality (rows 17–23). The smaller patch count (192 vs 512 in the old 64-channel layout) makes inference cheaper. ## 11. Pipeline references - **Single source of truth for the tensor schema**: `tools/render_model_input.py:CANONICAL_INPUT_CHANNELS` (24 entries). - **Single source of truth for the label vocab**: `tools/workload_taxonomy.py` (`VOCAB_L1`, `VOCAB_L2`, `ATTRIBUTE_FLAGS`, `SPATIAL_STATE_VOCAB`, `L2_PARENT_L1`). - **CI invariants**: `tests/test_tensor_invariants.py` (thousands of assertions across every collected snapshot), `tests/test_label_smoke.py` (synthetic end-to-end smoke), `tests/test_splits.py` (split coverage / disjointness). - **Reproduction commands**: `kernels//run.sh` per motif; `dev/launch_parallel.sh` + `dev/launch_kernelbench.sh` for batched GPU dispatch via `crun`.