| --- |
| license: [apache-2.0, bsd-3-clause, mit] |
| language: [en, code] |
| pretty_name: Kernel-Opt RL (vLLM / SGLang / FlashInfer) |
| size_categories: [10K<n<100K] |
| task_categories: [text-generation] |
| tags: [cuda, triton, gpu-kernels, kernel-optimization, reinforcement-learning, autotuning, vllm, sglang, flashinfer] |
| configs: |
| - config_name: tuned_configs |
| data_files: |
| - {split: train, path: tuned_configs/train-*} |
| - {split: test, path: tuned_configs/test-*} |
| - config_name: kernel_commits |
| data_files: |
| - {split: train, path: kernel_commits/train-*} |
| - {split: test, path: kernel_commits/test-*} |
| --- |
| |
| # Kernel-Opt RL |
|
|
| Real-world GPU kernel optimization data mined from production LLM inference engines |
| ([vLLM](https://github.com/vllm-project/vllm), [SGLang](https://github.com/sgl-project/sglang), |
| [FlashInfer](https://github.com/flashinfer-ai/flashinfer)). It's built for RL: given a base kernel and a |
| concrete deployment (model shape, GPU, dtype, batch size), choose the optimization. |
|
|
| Inference engines ship one generic kernel and specialize it per model and per GPU. Most of that |
| specialization is not new code. It is **autotuned launch parameters** checked in as JSON |
| (`E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3.json`), plus a stream of **perf commits** that rewrite |
| kernels for specific models and hardware. This dataset turns both into RL tasks, with the **benchmark |
| gains reported in each PR description** extracted as structured measurements. |
|
|
| ## Subsets |
|
|
| ### `tuned_configs`: kernel + deployment → best launch config |
| |
| | | | |
| |---|---| |
| | rows | 19,287 (17,561 train / 1,726 test) | |
| | tuned config files | 1,138 | |
| | GPUs | 48 (NVIDIA A100 → B300/GB300, AMD MI300X/MI325X/MI355X, Intel Arc, …) | |
| | kernels | `fused_moe_kernel` (vLLM + SGLang), `fused_moe_kernel_gptq_awq`, `_w8a8_triton_block_scaled_mm`, `_w8a8_block_fp8_matmul`, `_w8a8_block_int8_matmul`, `_selective_scan_update_kernel` | |
| | dtypes | bf16/fp16, fp8_w8a8 (per-tensor + 128×128 block), int8_w8a8, int8_w8a16, int4_w4a16 | |
| | M (tokens) | 1 … 262,144 | |
| | documented gains | 148 tuning PRs traced, 66 with benchmark tables; `speedup_vs_default` on 399 rows from 46 config files (median 1.30×, p10 1.03×, p90 1.98×) | |
|
|
| One row is one (config file, batch size M) entry. `prompt` contains the Triton kernel source, the |
| hardware, the problem shape and the MoE models whose shape matches under TP/EP (`candidate_models`, |
| resolved against 32 MoE model configs on the Hub). It asks for a JSON config. `best_config` is the |
| autotuned answer. |
|
|
| Gain fields: `config_pr_url` is the newest PR that added or changed the config file. `config_pr_gains` |
| holds all measurements extracted from that PR. `speedup_vs_default` is the documented speedup of the |
| tuned config over vLLM/SGLang's default heuristic at this exact M. It is set only when the attribution |
| is unambiguous: the GPU and shape match, and multiple matching rows agree within 5%. |
|
|
| **Split:** grouped by config filename (hash), so a given (shape, GPU, dtype) never appears in both |
| train and test, whatever the repo, Triton version or M. |
|
|
| ### `kernel_commits`: optimize a kernel file the way the real perf PR did |
| |
| | | | |
| |---|---| |
| | rows | 1,517 file-level tasks (1,365 train / 152 test) from 850 PRs | |
| | languages | CUDA (`.cu/.cuh`), C++, Triton, CuTe DSL | |
| | date range | 2023-04 → 2026-10 | |
| | documented gains | 529 PRs with benchmark numbers → 913 rows; `kernel_speedup` on 596 rows (median 1.33×, p10 1.02×, p90 4.25×), `e2e_speedup` on 556 rows | |
| |
| Selected from non-merge commits that touch kernel directories and carry a performance signal in the |
| title (`[Perf]`, optimize, speedup, faster, tune, throughput, latency, …), excluding build, CI, docs, |
| tests and reverts. Only modified kernel files are kept: ≤10 per commit, ≤120 KB per file, ≤800 changed |
| lines. |
| |
| `prompt` gives the goal (the PR title, which plays the role of the issue in SWE-RL), the target hardware |
| and models, and the full `before_code`. It asks for **SEARCH/REPLACE edits**. The PR body is withheld |
| from the prompt because it usually describes the fix. The reference answer is `after_code` / `diff`. |
| Prompt lengths: median ~21K chars (~6K tokens), p90 ~74K chars. Filter on `len(prompt)` for short-context |
| RL. |
|
|
| Other fields: `models_mentioned`, `hardware_mentioned`, `speedup_claims` (regex over the commit |
| message), `pr_body`, `gains` (structured measurements from the PR), `kernel_speedup` / `e2e_speedup` |
| (median documented speedup at kernel and end-to-end scope), `license`. |
|
|
| **Split:** temporal. The newest ~10% of rows are test (2026-10-18 onward), the code least likely to be in |
| a model's pretraining data. |
|
|
| ### `gains` / `config_pr_gains` format |
|
|
| A JSON list of measurements extracted from the PR description: |
| `{scope: "kernel"|"e2e", hardware, model, shape, batch_size, metric, unit, higher_is_better, baseline, |
| optimized, stated_speedup, speedup}`. `speedup` is computed in code from baseline/optimized and |
| normalized so that > 1 means the PR is better. When a PR states only a ratio, `stated_speedup` is used. |
| Extraction was done by `Qwen3-235B-A22B-Instruct-2507`, with `gpt-oss-120b` as a fallback for very long |
| tables, using an extract-only prompt (no computed numbers). Audit: in 98.8% of extracted |
| baseline/optimized pairs, both values appear verbatim in the PR text. The remainder were mostly averages |
| of repeated runs. Extraction failed for 5 PRs (malformed model output), which have empty `gains`. |
|
|
| ## Using it for RL |
|
|
| Rewards live in [`code/reward.py`](code/reward.py): |
|
|
| - **`tuned_configs`**: `config_reward` is deliberately a stub, because the partial-credit scheme is a design choice. Compare the parsed JSON config to `best_config` as an offline proxy (exact match is |
| sparse, so use partial credit or log-distance on the power-of-two tile sizes). `speedup_vs_default` |
| tells you how much a config actually matters for that row and can weight the reward. On hardware, |
| launch `kernel_source` with the predicted config and reward `t_best / t_pred`. The tuned config is |
| only the best within the tuner's search space, so it can be beaten. |
| - **`kernel_commits`**: `patch_reward(completion, before_code, after_code)` follows SWE-RL. It returns −1 if |
| the edits are malformed or don't apply, and otherwise the `difflib` similarity between the changed lines |
| and the real commit's. Validated on this data: the oracle edit scores 1.0 on 98.7% of rows and ≥ 0.95 on |
| all but one. For an execution reward, run through an environment such as |
| [KernelGYM](https://github.com/hkust-nlp/KernelGYM). Watch for reward hacking (timer exploits, cached |
| outputs; see the [CUDA-L1](https://github.com/ornith-ai/CUDA-L1) notes). |
| |
| ```python |
| from datasets import load_dataset |
| ds = load_dataset("guychuk/kernel-opt-rl", "kernel_commits", split="train") |
| ds = ds.filter(lambda r: len(r["prompt"]) < 32_000 and r["kernel_speedup"]) # short, with documented gains |
| ``` |
| |
| Both subsets have a plain-string `prompt` column. TRL's `GRPOTrainer` forwards the other columns |
| (`best_config`, `before_code`, `after_code`, …) to reward functions as keyword arguments. |
| |
| ## Limitations |
| |
| - Tuned configs record only the *winner*, not the full latency table, so offline config rewards are a |
| proxy. `speedup_vs_default` covers only rows whose PR documented that exact M. |
| - `candidate_models` comes from shape matching (`E == experts`, `N == intermediate / TP`, or |
| `E == experts / EP`). Shapes are shared across models, e.g. DeepSeek-V3, Kimi-K2 and MiMo-V2-Flash. |
| - PR gains are self-reported by the authors, on their hardware and benchmark setup, and are not reproduced. |
| - Snapshots are from each repo's HEAD at build time (see `commit`). Rebuild for fresher data. |
| |
| ## Licensing |
| |
| All code comes from vLLM, SGLang and FlashInfer (all Apache-2.0). Some vendored files carry their own |
| licenses. Each row has a `license` field taken from the file header (Apache-2.0: 1,481 commit rows and all |
| config rows; BSD-3-Clause / BSD: 35; MIT: 1). Files under non-open-source licenses (the NVIDIA TensorRT |
| Source Code License Agreement and NVIDIA proprietary headers) are **excluded**. License and copyright |
| headers in the code are kept verbatim. The upstream `LICENSE` and `NOTICE` files are in |
| [`licenses/`](licenses/), as Apache-2.0 §4 requires. The compilation itself is released under |
| Apache-2.0. PR descriptions are quoted from public GitHub PRs and linked via `pr_url`. |
| |
| ## Related datasets |
| |
| [KernelBench](https://huggingface.co/datasets/ScalingIntelligence/KernelBench) (eval; keep held out), |
| [KernelBook](https://huggingface.co/datasets/GPUMODE/KernelBook) (PyTorch→Triton pairs), |
| [Nemotron-SFT-CUDA-v1](https://huggingface.co/datasets/nvidia/Nemotron-SFT-CUDA-v1) (CUDA SFT with tests), |
| [CUDA-L1](https://github.com/ornith-ai/CUDA-L1) (RL-optimized KernelBench solutions per GPU). |
| |
| ## Reproduce |
| |
| The build code is in [`code/`](code/). `uv run build.py --push <repo_id>` clones the three repos as blobless clones, mines configs and commits, |
| fetches PR descriptions with `gh`, extracts gains via HF Inference Providers (cached), and pushes. |
| |
