Add README.md

README.md

@@ -0,0 +1,332 @@
+---
+license: apache-2.0
+pretty_name: KernelSight v4 — Per-Timestep GPU Workload Traces
+size_categories:
+  - 1K<n<10K
+task_categories:
+  - other
+tags:
+  - gpu
+  - cuda
+  - profiling
+  - performance
+  - kernel
+  - hopper
+  - h100
+  - cutlass
+  - kernelbench
+  - time-series
+  - sequence-labeling
+  - systems
+viewer: false
+---
+
+# KernelSight v4
+
+**Per-timestep workload labels for GPU execution traces.**
+
+KernelSight pairs every GPU workload trace with a dense, per-timestep workload
+labeling. Each snapshot is a `[24, 512]` counter image — 24 hardware-counter
+channels sampled across 512 equal-width time bins — paired with per-bin labels
+drawn from a two-level hierarchy of **12 coarse (L1)** and **73 fine (L2)**
+workload classes. The goal is to label *what a kernel is doing at each instant*
+(matmul, attention, reduction, memory movement, …) rather than the single
+coarse bottleneck label a profiler assigns per launch.
+
+All counters are collected on a single **NVIDIA H100 80GB HBM3** (Hopper,
+`sm_90a`). No data augmentation is applied: each snapshot is the trace as
+measured, and class imbalance is handled at training time rather than by
+resampling.
+
+| | |
+|---|---|
+| **Snapshots** | 1,444 |
+| **Tensor shape** | `[24, 512]` (24 channels × 512 time bins) |
+| **Label vocab** | 12 L1 classes · 73 L2 classes |
+| **Labeled segments** | 45,860 |
+| **Overlap ground truth** | 472 snapshots (`has_overlap=1`) |
+| **Standard split** | train 1,124 / val 160 / test 160 |
+| **Hardware** | NVIDIA H100 80GB HBM3 (`sm_90a`) |
+| **On-disk size** | ~68 MB (4,332 `.npz` files) |
+| **License** | Apache-2.0 |
+
+---
+
+## Quick start
+
+The dataset ships as raw NumPy `.npz` files in a fixed directory layout, indexed
+by JSON split files. It is **not** loadable through `datasets.load_dataset()`;
+download the folder and read the `.npz` files directly with NumPy.
+
+```python
+from huggingface_hub import snapshot_download
+import numpy as np, json, os
+
+root = snapshot_download(repo_id="williamhtan/kernelsight", repo_type="dataset")
+
+# Load a split (paths inside are relative to `root`)
+split = json.load(open(os.path.join(root, "splits/train.json")))
+rec = split["traces"][0]
+
+# Input tensor
+t = np.load(os.path.join(root, rec["path"]), allow_pickle=True)
+X = t["data"]                      # (24, 512) float32
+
+# Labels live alongside the input
+lpath = rec["path"].replace("/input/", "/labels/").replace("tensor_input.npz", "labels.npz")
+l = np.load(os.path.join(root, lpath), allow_pickle=True)
+y_l1  = l["workload_l1"]           # (512,) int32, -1 where unlabeled
+y_l2  = l["workload_l2"]           # (512,) int32
+mask  = l["mask_labeled"]          # (512,) uint8
+y_mh  = l["workload_l1_multihot"]  # (512, 12) uint8, multi-label overlap track
+```
+
+A reference PyTorch `Dataset` is bundled at `tools/sass_dataloader_stub.py`, and
+the label vocabularies live in `tools/workload_taxonomy.py` (single source of
+truth). Full schema documentation is in [`data_info.md`](data_info.md).
+
+---
+
+## Directory layout
+
+```
+kernelsight_dataset_v4/
+├── README.md                 # this card
+├── MANIFEST_v4.md            # release notes / per-class counts
+├── data_info.md              # full on-disk schema reference
+├── splits/                   # 7 split JSONs (see Splits)
+├── tools/
+│   ├── workload_taxonomy.py  # 12 L1 + 73 L2 + 8 flags + 5 spatial (source of truth)
+│   └── sass_dataloader_stub.py
+└── kernels/<motif>/_out/<variant>/
+    ├── input/tensor_input.npz       # [24, 512] profiler heatmap + metadata
+    ├── labels/labels.npz            # per-bin + per-segment L1/L2 labels, vocabs
+    └── fingerprint/fingerprint.npz  # 32-D instruction-mix fingerprint
+```
+
+Each `<variant>` is one snapshot (e.g. parameter-swept geometry like
+`cutlass_gemm/_out/m8192_n1024_k4096_.../`). Split JSON `path` fields are
+relative to the dataset root and point at `.../input/tensor_input.npz`.
+
+---
+
+## Input tensor — `tensor_input.npz`
+
+- `data` — `[24, 512]` float32: 24 counter channels × 512 time bins.
+- `time_edges_ns` — `[513]` int64: bin-boundary timestamps (bins are equal-width
+  *per trace*, ~0.5 ms for fast matmul up to ~30 ms for long scatter; the window
+  is clipped to the kernel-active span).
+- `counter_names` — `[24]`: channel names. `kernels`, `kernel_names`,
+  `kernel_function_index` — per-launch identity metadata.
+
+Channels divide into five semantic groups. Each channel is divided by a fixed
+physical-scale divisor (pipe/throughput ÷100, warp-stall ÷64, coalescing ÷8) so
+values land in ~`[0, 1]` while *preserving* magnitude differences (no per-channel
+min/max rescale).
+
+| Rows | Group | Source | Channels |
+|---|---|---|---|
+| 0–6 | Pipe signature | CUPTI | `tensor_op_hmma`, `xu`, `fma`, `alu`, `lsu`, `cbu`, `tma` |
+| 7–8 | Memory access | CUPTI/ncu | `hit: l2`, `atom: lts_atomic_input_pct` |
+| 9–12 | Discriminators | ncu/NVBit | `short_scoreboard`, `barrier`, `pred_on_per_inst_ratio`, `gmem_coalesce_ratio` |
+| 13–16 | System bandwidth | Nsight Systems | `SMs Active %`, `DRAM Read %`, `DRAM Write %`, `Tensor Active %` |
+| 17–23 | SASS modality | NVBit | `compute_fma`, `compute_tensor`, `memory_global`, `memory_shared`, `memory_tma`, `control`, `misc` |
+
+---
+
+## Labels — `labels.npz`
+
+**Per-bin arrays** (length `T = 512`):
+
+| Key | dtype | Meaning |
+|---|---|---|
+| `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]` | Multi-hot per-bin L1 (overlap track) |
+| `workload_l2_multihot` | uint8 `[T,73]` | Multi-hot per-bin L2 |
+| `multihot_n_active` | uint8 `[T]` | # active L1 classes per bin |
+| `multihot_has_overlap` | uint8 `[]` | 1 if any bin asserts ≥2 classes |
+| `segment_id` | int32 `[T]` | 0-based segment ordinal per bin (`-1` if none) |
+| `mask_any_kernel` | uint8 `[T]` | 1 if a kernel interval overlaps this bin |
+| `mask_labeled` | uint8 `[T]` | 1 if `workload_l1 >= 0` |
+| `time_edges_ns` | int64 `[T+1]` | Bin boundaries |
+
+**Per-segment arrays** (length `S`, varies by motif): `segment_starts`,
+`segment_ends`, `segment_label_l1`, `segment_label_l2`, `segment_kernel_names`,
+`segment_predecessor_l1/l2`, `segment_position`, `attribute_flags` `[S,8]`.
+
+**Vocabularies** (carried in *every* `labels.npz`): `vocab_l1[12]`,
+`vocab_l2[73]`, `attribute_flag_names[8]`, `spatial_state_vocab[5]`,
+`l2_parent_l1[73]`.
+
+The single-label fields are always a subset of the multi-hot tracks. On the
+sequential corpus the multi-hot is effectively one-hot; genuine overlap comes
+from 472 `cutlass_ws_overlap` snapshots whose producer (TMA load →
+`memory_movement`) and consumer (WGMMA → `matmul`) phases co-occur, derived from
+device `%globaltimer` markers (independent of the 24 counter channels — no label
+leakage).
+
+---
+
+## Label taxonomy
+
+**L1 (12):** `matmul`, `conv`, `activation`, `normalization`, `softmax`,
+`pooling`, `reduction`, `attention`, `loss`, `elementwise`, `memory_movement`,
+`other`.
+
+**L2 (73), nested under L1 parents:**
+
+| L1 | L2 classes |
+|---|---|
+| matmul | `bmm`, `gemm`, `matvec` |
+| conv | `conv1d_standard`, `conv2d_depthwise`, `conv2d_pointwise`, `conv2d_standard`, `conv3d_standard`, `convtranspose1d`, `convtranspose2d`, `convtranspose3d` |
+| activation | `elu`, `gelu`, `hardsigmoid`, `hardswish`, `hardtanh`, `leaky_relu`, `mish`, `other`, `relu`, `selu`, `sigmoid`, `softplus`, `softsign`, `swish`, `tanh` |
+| normalization | `batchnorm`, `frobeniusnorm`, `groupnorm`, `instancenorm`, `l1norm`, `l2norm`, `layernorm`, `rmsnorm` |
+| softmax | `log_softmax`, `logsumexp`, `softmax` |
+| pooling | `avg_pool`, `global_avg_pool`, `max_pool` |
+| reduction | `argmax`, `argmin`, `cumprod`, `cumsum`, `max`, `mean`, `min`, `prod`, `sum` |
+| attention | `scaled_dot_product` |
+| loss | `cross_entropy`, `hinge`, `huber`, `kldiv`, `mse`, `triplet_margin` |
+| elementwise | `add`, `bias_add`, `cast`, `clamp`, `div`, `mul`, `residual_add`, `scalar_multiplication`, `scaling`, `sub` |
+| memory_movement | `copy`, `embedding`, `gather`, `scatter`, `transpose` |
+| other | `dropout`, `misc` |
+
+**Attribute flags (8, multi-label per segment):** `sparse`, `tma`, `cluster`,
+`masked`, `persistent`, `vectorized_store`, `atomic_accum`, `ldgsts`.
+
+**Spatial-state vocab (5, exposed for the model side):** `uniform`,
+`wavefront_transition`, `tail_effect`, `load_imbalanced`, `hotspot`.
+
+---
+
+## Corpus composition
+
+| Source | Motif | Snapshots | Notes |
+|---|---|---|---|
+| Microbench | `vector_add` | 20 | coalesced BW-bound elementwise |
+| Microbench | `gather` | 17 | random-indexed memory movement |
+| Microbench | `reduction` | 16 | tree + atomic reductions |
+| Microbench | `scatter` | 31 | atomic histogram scatter |
+| Microbench | `wgmma` | 1 | tensor-core GEMM baseline |
+| KernelBench | `kernelbench` | 480 | PyTorch L1 + L2 ops (11 populated L1 classes) |
+| CUTLASS | `cutlass_gemm` | 278 | ex48 TF32 warp-specialized GEMM |
+| CUTLASS | `cutlass_fmha` | 85 | ex88 FlashAttention-3 |
+| CUTLASS | `cutlass_ws_overlap` | 472 | ex48 + device `%globaltimer` markers |
+| CUTLASS | `cutlass_fp8_gemm` | 14 | ex54 FP8 WS-GEMM |
+| CUTLASS | `cutlass_sparse_gemm` | 18 | ex62 2:4 structured sparsity |
+| CUTLASS | `cutlass_grouped_gemm` | 12 | ex57 grouped GEMM |
+
+**Per-L1 distribution** (snapshots containing each class / labeled segments):
+matmul 849 / 3,257 · activation 147 / 11,654 · reduction 125 / 7,155 · conv 98 /
+6,418 · attention 92 / 295 · elementwise 86 / 2,887 · normalization 79 / 6,546 ·
+pooling 62 / 2,019 · memory_movement 48 / 48 · loss 42 / 4,860 · softmax 28 /
+721. The corpus is heavily imbalanced (matmul dominates bin count via long
+CUTLASS traces), which motivates a class-balanced objective and macro-F1.
+
+---
+
+## Splits
+
+Each split JSON is `{split, seed, n, traces, notes}`; every `traces[i]` records
+`path`, `motif`, `n_kernels`, `n_unique_kernels`, `T`, `l1_labels`, `l2_labels`,
+`dominant_l1`, `dominant_l2`.
+
+**Standard disjoint partition** (L2-stratified, trace-level leak-free):
+
+| Split | n |
+|---|---|
+| `train.json` | 1,124 |
+| `val.json` | 160 |
+| `test.json` | 160 |
+
+This measures *within-kernel generalization*: most test traces share kernel
+identity with training and differ in geometry/precision/sweep parameters.
+
+**Overlapping analysis tags** (views over the same corpus, not a partition):
+
+| Tag | n | Selects |
+|---|---|---|
+| `iid.json` | 433 | random IID sample |
+| `param_ood.json` | 956 | parameter-sweep variants (fixed op, unseen geometry) |
+| `composed.json` | 1,124 | multi-kernel / multi-segment traces |
+| `length_ood.json` | 0 | reserved (empty in v4) |
+
+---
+
+## Collection methodology
+
+Workloads come from three sources — hand-written CUDA microbenchmarks isolating
+canonical GPU behaviors, the [KernelBench](https://github.com/ScalingIntelligence/KernelBench)
+Level-1 / Level-2 problem suite, and [CUTLASS](https://github.com/NVIDIA/cutlass)
+Hopper examples (the single largest contributor, ~61% of the corpus) spanning six
+warp-specialized datapaths (TF32, FP8, 2:4-sparse, grouped GEMM,
+FlashAttention-3, and WS-GEMM with device markers).
+
+Each workload is profiled by three complementary collectors and fused onto one
+time grid:
+
+1. **NVBit** — SASS-level dynamic binary instrumentation: per-PC instruction mix
+   and coalescing statistics.
+2. **CUPTI Range Profiler** — replays each kernel for a 19-metric warp-stall
+   taxonomy (stall reasons, pipe utilizations, occupancy).
+3. **Nsight Systems** — samples system throughput at ~10 kHz alongside the
+   CUDA/NVTX timeline; the only natively time-resolved source, so it defines the
+   time grid.
+
+Labels come from NVTX markers + kernel boundaries, with kernel-name + SASS
+pattern matching resolving the L2 class. The full collector fork and per-motif
+`run.sh` reproduction harness are part of the KernelSight project (not bundled in
+this dataset distribution, which ships the rendered tensors, labels, and splits).
+
+---
+
+## Changes from v3.1
+
+- Dropped `megakernel` (1 PoC snapshot) and `tiled_gemm_poc` (590 hand-written
+  PoC snapshots).
+- Added three CUTLASS Hopper datapaths: FP8 (ex54), 2:4 sparse (ex62), grouped
+  (ex57).
+- Selective KernelBench expansion (activation, normalization, pooling, reduction,
+  elementwise) and geometry sweeps over microbenchmarks and CUTLASS GEMM/FMHA.
+- Corpus 262 → 1,444 snapshots; overlap ground truth 29 → 472 snapshots.
+- CI: 26,996 assertions passed, 0 failed.
+
+See [`MANIFEST_v4.md`](MANIFEST_v4.md) for full release notes.
+
+---
+
+## Limitations
+
+- Counters are from a **single H100** (`sm_90a`); cross-architecture transfer is
+  out of scope.
+- Overlap timing is coarse: device-marker spans resolve producer/consumer
+  *envelopes* (≈ whole launch), so overlap is annotated at launch granularity.
+- All 24 channels carry real signal, but many rows are legitimately zero where
+  the hardware is inactive for a given motif.
+- The `spatial_state` vocab is exposed for the model side; per-bin spatial-state
+  derivation is not provided.
+
+---
+
+## License & provenance
+
+Released under **Apache-2.0**. Derived workloads retain their upstream licenses:
+
+- **KernelBench** problems — MIT (Scaling Intelligence Lab, Stanford University).
+- **CUTLASS** examples — BSD-3-Clause (NVIDIA Corporation).
+
+The profiler tooling builds on the Intra-Kernel Profiler (NVBit / CUPTI / Nsight
+Systems). This release contains only derived, aggregated counter tensors and
+labels — no third-party source code.
+
+## Citation
+
+```bibtex
+@misc{tan2026kernelsight,
+  title  = {KernelSight: Per-Timestep Workload Labeling of GPU Execution Traces},
+  author = {Tan, William},
+  year   = {2026},
+  note   = {CS231N project, Stanford University},
+  howpublished = {\url{https://huggingface.co/datasets/williamhtan/kernelsight}}
+}
+```