acceptodds
Under review as a conference paper at ICLR 2027

How to Train Your Little Dragon: Teaching a Small Language Model to Construct and Refine GPU Optimization Scripts

Abstract

Compiler transformations interact, making GPU kernel optimization a search for combinations that preserve the computation while improving performance. We investigate how to train a small language model to generate the optimization: a correct, performance-improving script that coordinates interacting transformations in one complete proposal. We introduce HOW TO TRAIN YOUR LITTLE DRAGON, a training method that teaches a small language model both to construct complete optimization scripts and to improve existing ones. Rather than learn only to rank search candidates or generate replacement kernel code, our LITTLE DRAGON learns to generate correct scripts that transform the under-optimized kernel and improve its performance. We devise a compact, lossless representation whose deterministic decoding reconstructs the exact compiler trace, preserving its transformation parameters and dependencies. We use a compiler framework TVM MetaSchedule to build training data on 54,116 distinct workloads, and construct 108,594 examples in two training sets: 60,236 teach the model to generate an optimized script from an unoptimized kernel, while 48,358 teach it to produce a better script given the kernel and a somewhat optimized script. Supervised fine-tuning teaches the model to construct and improve optimization scripts from these search-derived examples. We then add reinforcement learning with a shaped reward that combines correctness with measured performance, awarding a latency-based bonus only to numerically correct kernels. This enables the model learn not only from existing optimizations, but from the correctness and performance of its generated scripts. We apply this training method to a model with 8 billion parameters. After supervised fine-tuning and reinforcement learning, the model achieves per-attempt correctness of 91.27% for construction and 92.01% for refinement, while reinforcement learning produces faster kernels than supervised training on 88 of 102 construction tasks and 145 of 170 refinement prompts. With only 8 billion parameters, our LITTLE DRAGON achieves higher per-attempt correctness and better kernel performance than six frontier LLMs—GPT-6 Astra, Opus 5, Kimi-K3, and GLM-5.3 among them, each with hundreds of billions to trillions of parameters—for which task-specific training is unavailable or expensive. These results suggest that HOW TO TRAIN YOUR LITTLE DRAGON enables a small language model to learn from compiler search and direct correctness and performance feedback, internalizing an optimization policy that constructs and improves complete scripts in one shot.

Primary area:
foundation or frontier models, including LLMs
Keywords:
large language models, code generation, GPU kernel optimization, reinforcement learning with verifiable rewards

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_BEPVOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper trains a small LLM (8B) to write optimization schedules for TVM. In TVM, one usually take a plain loop program and apply a schedule (tiling, thread binding, shared memory, tensor cores etc.) to get a fast GPU kernel, and normally you find a good schedule by running MetaSchedule, which is an evolutionary search that tries lots of candidates on the GPU. The authors run this search on a big pile of workloads, keep the best schedules, and turn them into training data for two tasks: write a schedule from scratch, or take a non-competitive schedule and rewrite it into a better one. They also design a compact format for schedules that converts back to the exact compiler trace, and attach an explanation to each example (written by Kimi-K3 and checked against the actual edits). Then it's the usual recipe, SFT first and then GRPO, where the reward gives some partial credit for parsing and compiling and only gives a speed bonus if the kernel is actually correct. On held-out tasks on an H100, the model gets correct schedules on the first try most of the time, and RL mostly makes the kernels faster. The authors report that it beats six frontier LLMs and also beats TVM's own search while being much faster to run.

Critical strengths
  • The method is concrete and carefully engineered. The schedule format is done with care, and the reward only pays for speed when the kernel is correct, which is a sensible guard against reward hacking.

  • They put real effort into the train/test split, separating tasks by workload and by a hash of the program, and they compare against the search that generated their own training data, including how long each one takes.

Critical weaknesses

Weakness #1 Practical Value and Comparisons with Kernel Optimization Agents

My biggest issue is that I'm not convinced this setup is useful in practice, and the paper fails to make a convincing case. To get this model you have to run TVM's search on tens of thousands of workloads, then train a model, and what you get is tied to one compiler, one GPU and even one TVM version (the paper says the format is only checked under the recorded version). Change any of those and you're collecting data and training again.

Meanwhile, the obvious alternative is just to take a strong LLM and put it in an agent loop that compiles, tests, profiles and fixes things. That needs no training and no data collection, and we already know agent harnesses boost LLMs a lot on kernel optimization. So it seems not an economic choice to distill TVM into a one-shot model.

Of course, this would be sensible if the proposed approach leads to much stronger kernels. Yet, while the paper cites LLM-guided search methods that work inside TVM on the same schedules (Reasoning Compiler, LiteCoOp) plus agent systems like AccelOpt and AlphaEvolve, it did not compare against any of them. Their own model has a refinement mode, so it could run in a loop too. A fair comparison would look at kernel quality vs attempts or wall-clock time, for their model refining its own outputs and for a frontier model inside an agent harness. Without that I honestly can't tell if all the training effort buys anything.

And the frontier LLM comparison they do have isn't fair. The frontier models get one shot, no compiler feedback, no retries, no examples. On top of that, for construction they're asked to write a whole TVM kernel from PyTorch code, which is a different and much harder task than what the trained model does (it only outputs schedule edits in its own format). A fine-tuned model beating zero-shot models in this setup is pretty much guaranteed, and I think the really low correctness of some frontier models is mostly about the interface, not about how good they are at optimization (under proper interface and harness).

Weakness #2. Lack of Strong Baselines

The rest of the evidence doesn't tell me how good the kernels really are or what part of the method matters. All the speedups are vs TVM's default schedule, which is super slow, so the huge speedup numbers don't mean much. *There's no comparison to popular and strong baselines, like cuBLAS, FlashAttention, Triton or torch.compile. They also say the model beats the same TVM search it learned from, but they don't say what search budget TVM got, so maybe the search just wasn't run long enough. Correctness is checked on one random input, which is pretty weak. And held-out tasks might just be the same operators with different shapes; there's no analysis of how close they are to the training tasks.

Also the method itself is a pretty standard recipe. SFT on compiler search data plus RL with an execution reward has been done before (TLM, LLM Compiler, Compiler-R1, CUDA Agent and so on). The new pieces are the compact format, the explanation graphs, the token weighting and the refinement data, but none of them is ablated, so we don't know if any of them matters. With one GPU, one base model and one training run, it's hard to see what this adds beyond applying a known approach to TVM schedules.

Questions for authors
  • How does your model compare with a frontier model in an agent loop with compiler feedback, at matched time or compute? For example, KernelAgent and AccelOpt.
  • What happens if you run your refinement mode in a loop on your own outputs?
  • How would the frontier models do if they got the same schedule-edit interface as your model, plus a few examples and the compiler errors?
  • What search budget did TVM's MetaSchedule get in your comparison, and how does your model do against a full-budget search?
  • How do your kernels compare with cuBLAS, FlashAttention, Triton or torch.compile?
16 comments

We thank the reviewer for the reviews. We address the reviewer’s two weaknesses and five questions below:

AuthorsOpenReview ↗

Response to W1

W1

Our practical contribution is that our targeted training enables an 8B model to perform the complex task of compiler optimization, outperform frontier models on the evaluated workloads, and produce strong schedules without repeating an expensive search for each task. The scale difference is concrete: Kimi K3, one of our baselines, contains 2.8 trillion total parameters and activates 104 billion per token, which is 350 and 13 times our model’s parameter count, respectively. Achieving stronger task-specific performance with an 8B model is a significant result: our training approach makes a small model an effective alternative to invoking frontier models for these optimization tasks.

To illustrate the resource stakes, an adaptation run using 256–1,024 GPUs for two weeks would consume approximately 86,000–344,000 GPU-hours. At an assumed 3–5 per GPU-hour, that amounts to roughly 258,000–1.72 million for one run, before additional experiments and engineering. This budget shows why small model specialization matters. Our approach makes an accessible 8B model outperform available frontier models on TVM kernel optimization tasks.

That trained model then reuses compiler search experience across new workloads. Although its training labels come from approximately 9-minute searches, we evaluate it against TVM MetaSchedule searches with a 1,000-trial target and three seeded runs per workload, taking a median of 53.6 minutes per task. The model produces the reported high performance kernels with approximately 39× less optimization time compared with MetaSchedule. Thus, the benefit is both a small model capable of this demanding task and a reusable policy that reduces the search required at deployment; the upfront data generation and training costs are amortized across subsequent uses.

We would like to clarify the distinction between training the model to refine an existing schedule and running it in an agentic loop. The refinement task gives the model a starting schedule and asks the model to propose an improvement in one invocation; it does not repeatedly invoke the model with compiler feedback. Our contribution is a training method that teaches a small model compiler knowledge and improves its optimization ability, not an agentic workflow. The reported results demonstrate what the trained model achieves in a single shot.

Our trained model can also serve as the optimizer within an agentic loop, where repeated calls to frontier models can incur substantial inference costs. For example, Kimi K3 activates 104 billion parameters per token, compared with our model’s 8 billion. At equal generated token counts, this represents approximately 13× more parameter-dependent inference arithmetic per proposal. Using our smaller model therefore offers a substantially lower model compute requirement for repeated proposals, allowing an agentic workflow to spend that budget on more optimization attempts or reduce its inference time and cost.

At the reviewer’s request, we conducted additional experiments during the discussion period in which the model refines its first construction output once. This additional refinement step yields further speedups of 1.14× on attention kernels, 1.32× on quantization kernels, and 1.15× on convolution kernels. These results show that the same model can further improve its initial output, beyond the gains already achieved without an agentic loop.

Our comparison with frontier models has even made the task easier and more accessible to frontier models. We have two kinds of tasks, construction and refinement. In construction, the objective is to produce an optimized TVM implementation of the reference PyTorch kernel. Our trained model receives the set of information including initial TensorIR and compiler features and outputs the schedule edits which are lowered to TVM trace and applied to the initial TensorIR. Given the same input information and also the PyTorch reference code, asking the frontier baselines to generate TVM traces directly resulted in a lack of sufficient correct outputs. We therefore relaxed the output format requirement: the baselines still receive the same information and the PyTorch reference code but may generate complete TVMScript kernels rather than use our custom representation. Thus, this construction task does not require them to use our custom representation. For refinement, both the frontier baselines and Little Dragon receive the same prompt. Our SFT+RL model achieves 92.01% Correct@1, compared with 45.81% for the strongest frontier baseline, and a 59.28% correct-and-≥2× improvement rate, compared with 17.33% for the strongest frontier baseline on that metric. Little Dragon therefore achieves approximately twice the correctness rate and 3.4 times the rate of correct refinements that at least double performance. These results demonstrate that our targeted training enables an 8B model to outperform available frontier models on this demanding optimization task.

AuthorsOpenReview ↗

Response to W2 - Part 1

W2

We report additional baselines in our answer to Q5 and we achieve speedups over cuBLAS, FlashAttention, Triton and torch.compile. Every TVM datapoint in Section 3.5 and every search-best reference is a completed MetaSchedule evolutionary search with a 1,000-trial target per run, a median of 53.6 min per task on one H100, three seeded runs per workload. The training labels came from a much lighter 9-minute search, so the model learned from around 9-minute searches and is evaluated against search results after an average of 54 minutes. Some longest search runs include MoE grouped gate-up GEMM, which takes 1,138 minutes, LM-head GEMM with 655 minutes, and Sparse-MLA decode with 323 minutes.

Figure 4 of the paper compares optimization time and kernel quality across six workload families between first SFT+RL output and TVM MetaSchedule search run. Under the plotted timing convention, SFT+RL produces these faster kernels with approximately 39× less optimization time. These results show how compiler search experience can be reused through training: the 8B policy produces a complete schedule in a single proposal, reducing the per-task cost of obtaining an optimized kernel.

Our model generates compiler transformations, not kernels. It therefore operates within the bounds of TVM’s scheduling primitives rather than generating arbitrary code that replaces the original kernel. These primitives—including tiling, reordering, thread binding, caching, and tensorization—are applied to the original TensorIR kernel M0M_0. TVM checks their applicability during trace replay, rejects transformations that violate the checked preconditions, and generates the resulting kernel.

We agree that a single random test is insufficient to establish correctness, and we do not use it as that basis. Our approach instead relies on TVM’s semantics-preserving scheduling primitives and their applicability checks. Because TVM relies on downstream code generation, including LLVM, we retain an additional numerical sanity check to catch potential compilation faults, not to establish the correctness of the schedule transformations themselves.

This sanity check compares the generated GPU kernel against the LLVM-compiled original kernel M0M_0, element by element across the entire output tensor. “One randomly generated test case” refers to complete input tensors: the 112×3456112 \times 3456 and 4304×34564304 \times 3456 matrices in Appendix A.1 contain 15,261,696 input values, and the check compares all 112×4304=482,048112 \times 4304 = 482{,}048 output values. Passing this check is required before a candidate receives a latency bonus.

Our training set contains diverse workloads spanning six kernel families: GEMM, normalization and reduction, attention, quantization and irregular kernels, vision, and mixture-of-experts. These workloads come from models including DeepSeek-V3.2-Exp, Qwen3-Next-80B-A3B, Llama-3.1-8B, Mixtral-8x7B, Kimi-K3, Qwen3.5-9B, etc. Our split excludes exact workload identities and initial-IR hashes across training and evaluation. Sharing an operator family does not make workloads equivalent optimization problems: different shapes change the tiling, parallelization, and memory management decisions needed to produce an efficient schedule.

We also ran additional experiments to directly test shape extrapolation, creating 20 new construction cells across eight templates, with one axis extended to 2× and 4× beyond each template’s training range. The extrapolated configurations include GEMM rows up to 16,384, FP8-GEMM rows up to 8,192, MLA contexts up to 65,536, GQA KV lengths up to 131,072, softmax row widths of 16,384, RMSNorm sequences of 4,096 tokens, patch grids corresponding to 1,512-pixel images, and 256 experts.

Factor beyond training rangeCellsSFT Correct@1SFT+RL Correct@1SFT+RL median over L0L_0
2×1097.50%100.00%57.6×
4×1081.25%90.00%70.5×

SFT+RL produces a correct candidate for every 2× cell and for seven of eight templates through 4×. Its median speedup is 57.6× at 2× and 70.5× at 4×. These new results establish substantial shape extrapolation within learned operator structures: extrapolation preserves correctness while continuing to produce high-performance schedules beyond the training range.

Our SFT/RL ablations are already reported in Table 1, which separately evaluates Seed-Coder-8B-Instruct (the base model), SFT, and SFT+RL. Adding RL increases construction fast10\mathrm{fast}_{10} from 64.98% to 77.69% and refinement correct and ≥ 2× over graph A improvement from 37.24% to 59.28%. These gains of 12.71 and 22.04 percentage points respectively directly establish the benefit of RL beyond supervised training.

Reviewer_ffdeOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

This paper presents How to Train Your Little Dragon, a method for training an 8B language model to construct and refine complete GPU compiler-optimization scripts. It introduces a compact Typed Schedule Edit Language that deterministically reconstructs exact TVM MetaSchedule traces while separately representing evidence, analysis, edits, and expected effects. Compiler search over 54,116 workloads produces 60,236 construction examples and 48,358 refinement examples. Seed-Coder-8B-Instruct is first trained with supervised fine-tuning and then optimized with GRPO using staged rewards for parsing, replay, compilation, numerical correctness, and measured latency. On held-out H100 tasks, the final model reports Correct@1 above 91% and substantially higher performance-success rates than six general-purpose frontier models.

Critical strengths
  1. The paper tackles an interesting systems-learning problem. Generating a complete transformation script requires coordinating dependent tiling, memory, thread-mapping, and tensorization decisions. The lossless representation is well motivated because it preserves executable compiler parameters and dependencies while avoiding fragile global temporary identifiers. Round-trip checks provide a concrete contract between the model output and the compiler trace.

  2. The training pipeline connects large-scale compiler search with both construction and refinement supervision, followed by direct execution feedback. The reward gives partial credit for progress through the compiler pipeline and allows latency bonuses only after the candidate compiles and passes the numerical check. The paper also separates failures in the denominator and compares fixed first outputs, which is more informative than reporting only the best of eight samples.

Critical weaknesses
  1. Numerical correctness is tested with only one randomly generated input per workload. This is too weak for validating aggressive compiler transformations. A kernel can accidentally match on one input while mishandling other values, race conditions, boundary cases, NaNs, accumulation order, aliasing, or unsupported layouts. Such a kernel can receive the full correctness and latency reward during RL and can also be counted as correct in evaluation. This issue is especially serious given reported speedups as large as hundreds of times over the default schedule. The paper's claim that the reward is protected from reward hacking is not supported without a substantially stronger and independent test suite.

  2. The comparison with frontier models is not matched. The trained model sees more than 100,000 task-specific examples and uses a custom representation designed to reconstruct TVM traces. For construction, the external models instead receive PyTorch reference code and must generate complete self-contained TVMScript TensorIR kernels. They do not receive the same initial TensorIR, AST features, output language, or task-specific training. Therefore, Table 1 demonstrates the value of specialization, but it does not isolate the proposed representation, refinement data, or RL method, and it cannot support a general claim that the 8B model is a better kernel optimizer than the larger models. More relevant learned compiler baselines, representation-matched prompting, and SFT/RL ablations are missing.

  3. The held-out split rules out exact workload identities and initial-IR hashes, but does not establish structural generalization. The 54,116 workloads are produced from compiler search and shape grids over recurring operator families. Closely related shapes and almost identical TensorIR structures may therefore occur across training and evaluation. No near-duplicate analysis, family-held-out split, shape extrapolation study, or performance as a function of training similarity is reported. The refinement evaluation is particularly concentrated: 194 prompts come from only 39 tasks.

  4. The reported RL and efficiency results lack important controls. Only one SFT and one selected RL checkpoint are reported, with the RL checkpoint chosen using a post-hoc validation-latency criterion. There are no independent training seeds or uncertainty estimates. The claimed 39x lower optimization time compares per-task inference with a new TVM search, but excludes the cost of generating 108,594 labels, teacher explanations, SFT, and hardware-based RL. This is a useful amortized deployment comparison, but not a complete cost comparison.

  5. The supplementary archive is much more limited than the main claims require. It contains a TVM provenance patch, a trace-collection script, and recorded files for only two example workloads. Its provenance record explicitly excludes model weights, datasets, recorded experiment traces, and experiment results. It also does not provide the SFT or RL implementation needed to reproduce the learned policy. The artifact helps inspect the trace format, but it cannot reproduce the training process, correctness rates, frontier-model comparison, or reported speedups.

Questions for authors

See Weaknesses.

6 comments
AuthorsOpenReview ↗

Responses to Q1 and Q2

We thank the reviewer for the reviews and we address Questions 1 to 5 below:

Q1

Our model generates compiler transformations, not kernels. It therefore operates within the bounds of TVM’s scheduling primitives rather than generating arbitrary code that replaces the original kernel. These primitives—including tiling, reordering, thread binding, caching, and tensorization—are applied to the original TensorIR kernel (M_0). TVM checks their applicability during trace replay, rejects transformations that violate the checked preconditions, and generates the resulting kernel.

We agree that a single random test is insufficient to establish correctness, and we do not use it as that basis. Our approach instead relies on TVM’s semantics-preserving scheduling primitives and their applicability checks. Because TVM relies on downstream code generation, including LLVM, we retain an additional numerical sanity check to catch potential compilation faults, not to establish the correctness of the schedule transformations themselves.

This sanity check compares the generated GPU kernel against the LLVM-compiled original kernel M0M_0, element by element across the entire output tensor. “One randomly generated test case” refers to complete input tensors: the 112×3456112 \times 3456 and 4304×34564304 \times 3456 matrices in Appendix A.1 contain 15,261,696 input values, and the check compares all 112×4304=482,048112 \times 4304 = 482{,}048 output values. Passing this check is required before a candidate receives a latency bonus.

Q2

We show that targeted training enables an 8B model to perform the complex task of compiler optimization and outperform available frontier models on the evaluated workloads. The scale difference is concrete: Kimi K3, one of our baselines, contains 2.8 trillion total parameters and activates 104 billion per token, which is 350 and 13 times our model’s parameter count, respectively. Achieving stronger task-specific performance with an 8B model is a significant result. Our contribution is the training approach that enables this outcome without requiring frontier-scale adaptation.

To illustrate the resource stakes, an adaptation run using 256–1,024 GPUs for two weeks would consume approximately 86,000–344,000 GPU-hours. At an assumed 3–5 per GPU-hour, this amounts to roughly 258,000–1.72 million for one run, before additional experiments and engineering. This budget shows why small model specialization matters. Our approach makes a small model outperform available frontier models on TVM kernel optimization tasks.

We have two kinds of tasks, construction and refinement. In construction, the objective is to produce an optimized TVM implementation of the reference PyTorch kernel. Our trained model receives the set of information including initial TensorIR and compiler features and outputs the schedule edits which are lowered to TVM trace and applied to the initial TensorIR. Given the same input information and also the PyTorch reference code, asking the frontier baselines to generate TVM traces directly resulted in a lack of sufficient correct outputs. We therefore relaxed the output format requirement: the baselines still receive the same information but may generate complete TVMScript kernels rather than use our custom representation. Thus, this construction task was made easier and more accessible to the baselines, not to require them to use our custom representation. For refinement, both the frontier baselines and Little Dragon receive the same prompt. Our SFT+RL model achieves 92.01% Correct@1, compared with 45.81% for the strongest frontier baseline, and a 59.28% correct-and-≥2× improvement rate, compared with 17.33% for the strongest frontier baseline on that metric. Little Dragon therefore achieves approximately twice the correctness rate and 3.4 times the rate of correct refinements that at least double performance. These results demonstrate that targeted training enables an 8B model to outperform available frontier models on this demanding optimization task.

Our SFT/RL ablations are already reported in Table 1, which separately evaluates Seed-Coder-8B-Instruct (the base model), SFT, and SFT+RL. Adding RL increases construction fast10\mathrm{fast}_{10} from 64.98% to 77.69% and refinement correct and ≥ 2× over graph A improvement from 37.24% to 59.28%. These gains of 12.71 and 22.04 percentage points respectively directly establish the benefit of RL beyond supervised training.

AuthorsOpenReview ↗

Response to Q3

Q3

Our training set contains diverse workloads spanning six kernel families: GEMM, normalization and reduction, attention, quantization and irregular kernels, vision, and mixture-of-experts. These workloads come from models including DeepSeek-V3.2-Exp, Qwen3-Next-80B-A3B, Llama-3.1-8B, Mixtral-8x7B, Kimi-K3, Qwen3.5-9B, etc. Our split excludes exact workload identities and initial-IR hashes across training and evaluation. Sharing an operator family does not make workloads equivalent optimization problems: different shapes change the tiling, parallelization, and memory management decisions needed to produce an efficient schedule.

We also ran additional experiments to directly test shape extrapolation, creating 20 new construction cells across eight templates, with one axis extended to 2× and 4× beyond each template’s training range. The extrapolated configurations include GEMM rows up to 16,384, FP8-GEMM rows up to 8,192, MLA contexts up to 65,536, GQA KV lengths up to 131,072, softmax row widths of 16,384, RMSNorm sequences of 4,096 tokens, patch grids corresponding to 1,512-pixel images, and 256 experts.

Factor beyond training rangeCellsSFT Correct@1SFT+RL Correct@1SFT+RL median over L0L_0
2×1097.50%100.00%57.6×
4×1081.25%90.00%70.5×

SFT+RL produces a correct candidate for every 2× cell and for seven of eight templates through 4×. Its median speedup is 57.6× at 2× and 70.5× at 4×. These new results establish substantial shape extrapolation within learned operator structures: extrapolation preserves correctness while continuing to produce high-performance schedules beyond the training range.

Our refinement evaluation is also diverse, and its 194 prompts are not 194 copies of the same optimization problem. Each refinement prompt is a (task, parent schedule, requested improvement band) triple. The evaluation contains 187 distinct parent graphs across 39 tasks and 35 workloads, distributed across all six families:

Kernel familyTasksRefinement prompts
Attention1469
Normalization and reduction840
Vision630
GEMM525
Quantization and irregular kernels420
Mixture-of-experts210

The parent graphs are verified MetaSchedule candidates that already achieve a median speedup of 9.6× over L0L_0. The model must therefore improve distinct and already fast schedules. Counting only the underlying tasks overlooks the different optimization problems presented by these starting schedules.

The same kernel can have several different optimized schedules. Improving one schedule may require different changes from improving another. The model therefore faces 187 distinct starting schedules, even though they belong to 39 tasks. The model must identify how to improve each schedule, so it is not solving the same optimization problem repeatedly.

AuthorsOpenReview ↗

Responses to Q4 and Q5

Q4

Checkpoint selection used validation data, not the sealed evaluation set. Neither training nor checkpoint ranking used the sealed prompts. For SFT, we scored five checkpoints based on execution results using four validation sets containing 2529 validation prompts. The checkpoint for the second epoch was best on each validation set. For RL, sixteen checkpoints were evaluated on 204 construction and 300 refinement validation prompts. Thus, the reported checkpoint was selected independently of the results on the sealed evaluation set.

We ran two additional SFT training seeds with the same data and hyperparameters and evaluated all three under the sealed protocol:

MetricSeed 42Seed 1337Seed 2027
Construction Correct@189.33%89.33%89.55%
Construction fast284.16%84.38%85.24%
Construction fast1064.98%65.41%65.84%
Refinement Correct@191.95%90.72%92.40%
Refinement improves-A68.56%66.69%68.43%
Refinement ≥2× A37.24%35.50%36.66%

The ranges across seeds are 0.22–1.08 percentage points for construction and 1.68–1.87 points for refinement. These variations are small relative to SFT’s approximately 20–46-point advantages over the strongest external baseline on the corresponding metrics, demonstrating that the results are reproducible across independent training runs.

For uncertainty analysis, we added 95% task-clustered bootstrap confidence intervals using 10,000 resamples for every number in Table 1.

Construction (%)Refinement (%)
ModelCorrect@1fast2fast10Correct@1Correct and improves ACorrect and ≥2× A
GPT-6 Astra9.38 [6.79, 12.28]7.65 [5.60, 9.81]6.03 [4.09, 8.08]45.55 [31.92, 59.70]36.47 [24.94, 48.65]17.33 [10.96, 24.17]
Opus 564.01 [59.59, 68.64]58.30 [53.02, 63.47]36.96 [30.60, 43.32]45.81 [38.59, 52.95]31.70 [26.09, 37.50]14.24 [9.81, 18.94]
Kimi-K334.91 [31.25, 38.69]25.43 [21.88, 28.99]14.55 [11.42, 17.78]37.82 [26.87, 48.85]19.59 [13.14, 26.22]4.70 [2.56, 7.19]
GLM-5.315.73 [13.25, 18.32]11.75 [9.38, 14.33]7.00 [4.96, 9.16]18.56 [13.66, 23.59]8.25 [5.73, 11.00]1.80 [0.90, 2.96]
Qwen3.8-27B0.11 [0.00, 0.32]0.000.0019.59 [14.71, 24.87]4.57 [3.16, 6.15]1.48 [0.71, 2.37]
Seed-Coder-8B-Instruct0.000.000.008.12 [4.04, 12.95]4.51 [1.61, 8.01]1.22 [0.06, 2.98]
SFT89.33 [84.27, 93.75]84.16 [78.02, 89.76]64.98 [56.90, 72.74]91.95 [85.51, 96.71]68.56 [60.82, 75.96]37.24 [28.82, 46.01]
SFT+RL91.27 [86.21, 95.69]89.33 [83.62, 94.40]77.69 [70.15, 84.70]92.01 [82.63, 99.55]87.05 [77.56, 94.91]59.28 [48.07, 70.43]

These intervals preserve the substantial separation between SFT+RL and the external baselines. This analysis supports that RL significantly improves schedule performance while maintaining high correctness. Construction fast10\mathrm{fast}_{10} rises from 64.98% to 77.69%, and refinement correct-and-≥2× improvement rises from 37.24% to 59.28%.

Finally, the 39× reduction in optimization time is the deployment benefit of learning a reusable optimization policy: the model applies what it has learned to new tasks instead of running a fresh TVM search for each one. All the results show that our trained model finds higher performance kernels than frontier models and also finds faster kernels than the TVM compiler with a much lower cost.

Q5

The ICLR 2027 Author Guidelines (https://iclr.cc/Conferences/2027/AuthorGuidelines) encourage code sharing but do not require an open-source release as a condition of publication. Our experimental results are reported in the main body of the paper to substantiate its claims. There is no requirement to include experimental results in the supplementary archive. Corporate release restrictions currently prevent us from distributing the complete model weights and datasets. Within these constraints, we provided the trace collection script, example records, etc. to make the data collection and label generation process inspectable. We intend to release additional resources following publication of the paper.

We again thank the reviewer. We hope that our clarifications and the new supporting evidence have fully addressed your concerns, and we would be grateful if you would consider raising your score given these improvements.

Reviewer_G5z3OpenReview ↗
Rating
4
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper shows that fine-tuning a small model as a specialized GPU-kernel optimizer outperforms six flagship generic LLMs. The paper separates the responsibilities into transformation (definition and execution), policy selection, and evaluation (correctness and performance). Correctness is consistently verified w.r.t recent prior work. The method achieves this through compact and lossless schedule edits. The small model takes compiler search records and AST features as input and generates optimization scripts rather than ranking optimization candidates. The paper uses a teacher model (Kimi-K3) to generate explanations of compiler traces. The small model is first trained in a supervised fashion on outputs from deterministic tooling and the teacher model. It is then fine-tuned with a hand-engineered RL reward that rewards/penalizes successful parsing, validity, replay, compilation, numerical correctness, and latency.

Critical strengths

The paper demonstrates that training on compiler search experience and execution feedback enables a specialized small model (8 billion parameters) to outperform generic flagship models.

Critical weaknesses

None

Questions for authors

Clarification: How were the flagship models prompted? Was a multi-agent setup used?

Future work: If the flagship agents were given the compiler traces and execution feedback, along with a sufficient budget for multiple attempts, could they outperform the small model?

1 comment

Thank you very much for your time and thoughtful comments. We really appreciate them.

Clarification: We gave the flagship models the same prompt as our model (our trained model receives the set of information including initial TensorIR and compiler features) together with the PyTorch reference code. In this setting, asking the baseline frontier models to generate TVM traces directly resulted in a lack of sufficient correct outputs. We therefore relaxed their requirement: they receive the same set of information and the PyTorch reference code but may generate a complete TVM kernel, a conventional code format, that general-purpose models are more familiar with. There was not a multi-agent setup that was used.

Future work: Given sufficient budget for multiple attempts it may be possible to outperform the small model. However, the same agentic loop could be also employed for our trained small model to further optimize the traces and therefore outperform this setup too. We agree that this is an exciting future direction to investigate both the Little Dragon and the frontier models in genetic loops.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.