acceptodds
Under review as a conference paper at ICLR 2027

ProcessKernel: Calibrated Process Supervision for GPU Kernel Generation

Abstract

Generating efficient GPU kernels requires searching a vast space of functionally equivalent programs whose performance depends on low-level hardware behavior. Effective search therefore relies on execution feedback to identify promising implementations. In practice, however, obtaining such feedback is cumbersome and expensive: candidate kernels must be compiled, validated, and evaluated under a reliable testing setup, making repeated execution a major bottleneck to scalable kernel search and generation. We thus introduce an execution-free process supervision framework that turns one-time outcome measurements into reusable guidance for unfinished kernels during autoregressive generation, enabling on-the-fly search without executing intermediate candidates. Extensive experiments show that our approach reduces process-supervision labeling cost by (9.3 vs. an estimated 707 H100 GPU-hours), while improving generated-kernel correctness by up to 38% and achieving up to 21.64 speedup. These results highlight the promising potential of reusable process-level supervision to amortize costly execution feedback and enable more scalable search for correct and efficient GPU kernels.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Kernel Generation, Efficiency, Code Model, Reinforcement Learning, Agents

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_TiWpOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
3(+1)
Presentation
2
Soundness
3(+1)
Read review
Paper summary

ProcessKernel learns an outcome reward model (ORM) from executed complete Triton candidates and calibrates its scores with measured anchors. The calibrated ORM supplies approximate continuation labels for training a process reward model (PRM). At inference, the PRM guides segment-level beam search and the ORM chooses a finished program without executing each search candidate. Across eight generation backbones on KernelBench Levels 1 and 2, the method improves correctness and Fast1 over first-sample generation and includes matched search controls. Its reported 76× saving compares approximately 707 GPU-hours of estimated execution-based continuation labeling with 9.3 GPU-hours of ORM scoring for the same continuations.

Critical strengths
  1. The calibrated ORM and PRM have clear complementary roles: measured outcomes inform partial-code search, and finished candidates receive a final learned selection score.
  2. Results span eight generators and include Random Beam, DeepConf, candidate-pool analysis, ranking-fidelity measurements, and bootstrap intervals for some analyses. Table 1 also reports speed coverage against torch.compile, and Figure 9 gives a concrete non-delegating Triton max-pooling improvement. These controls and examples provide stronger evidence than a comparison with single-sample generation alone.
  3. Training, search, grading, and H100 settings are documented, including five correctness trials and 100 timing trials. The manuscript provides an anonymous replication-package link.
Critical weaknesses
  1. Many selected correct programs delegate heavy operations to PyTorch: 40.0% on Level 1 and 99.0% on Level 2, versus 24.2% and 98.0% among correct first completions (Table 13, p. 26). In the harder Level-1 cases solved only by search, 64 of 75 use such delegation (p. 27). This is allowed by the task prompt, and the paper shows a non-delegating max-pooling gain; Level-2 delegation was already common before search. The missing result is an aggregate performance breakdown for genuinely low-level Triton work versus the permitted library-delegation strategy.
  2. The 13,309 training tasks are derived from KernelBook/PyTorch modules, yet the manuscript does not report a semantic-neighbor, graph-template, or near-code overlap audit against KernelBench. The absence of that audit limits the unseen-task interpretation; it does not establish leakage.
  3. The 76× ratio compares estimated execution time for labeling sampled continuations with ORM scoring time. It omits initial measured-data acquisition, reward-model training, continuation generation, and inference scoring, so it should not be read as an end-to-end cost reduction. The paper otherwise gives useful details of five FP32 correctness trials and 100 timing trials.
  4. ORM ranking is strong for correct-versus-incorrect finished kernels (92.3% pair accuracy) but near chance across all speed pairs (51.2%), improving to 76.6% when speeds differ by at least 2×. The evidence for fine-grained speed selection among correct candidates is therefore weaker than the evidence for finding correct ones.
  5. Performance relative to torch.compile remains more limited than relative to eager PyTorch, despite being reported in Table 1. Across the eight generators, ProcessKernel's Level-2 Fast1 coverage is 23–57% against eager but only 6–14% against torch.compile; AutoTriton Level 2 falls from 9% to 7% against torch.compile even while correctness and eager-relative Fast1 improve. This bounds the speed claim while leaving the same-budget correctness gains intact.
Questions for authors
  1. Can you stratify existing Correct, Fast1, and Random Beam comparisons by heavy PyTorch delegation or by how much computation the Triton kernel performs? A result on the non-delegating subset would clarify the low-level generation claim without changing the current benchmark rules.
  2. What semantic, graph-template, and near-code overlap checks were performed between the training tasks and KernelBench, and what happens if the closest neighbors are excluded?
  3. What is the amortized end-to-end cost after measured-data collection, two reward-model training runs, continuation generation, anchor labeling, and inference scoring are included?
  4. On existing candidate pools containing only correct implementations, how close is ORM-selected latency to a hardware-measured oracle and to random selection?
7 comments

We sincerely thank all reviewers for their constructive feedback and overall positive rating of our work! We are pleased that all reviewers appreciate the ideas behind our approach. Reviewer iH7x praised the “Learning to Rank + process reward modeling idea” and described our segment-level beam search as “an interesting idea on where to start using the PRM”. The reviewers further recognize turning sparse execution feedback into reusable process guidance as “a sensible and meaningful direction” (Reviewer vsyQ) and highlight the “clear complementary roles” of the calibrated ORM and PRM (Reviewer TiWp), while also praising our “very comprehensive and well-designed” evaluation (Reviewer vsyQ) and “Strong results” (Reviewer iH7x).

Q1: Many selected correct programs delegate heavy operations to PyTorch: 40.0% on Level 1 and 99.0% on Level 2, versus 24.2% and 98.0% among correct first completions (Table 13, p. 26). In the harder Level-1 cases solved only by search, 64 of 75 use such delegation (p. 27). This is allowed by the task prompt, and the paper shows a non-delegating max-pooling gain; Level-2 delegation was already common before search. The missing result is an aggregate performance breakdown for genuinely low-level Triton work versus the permitted library-delegation strategy. Can you stratify existing Correct, Fast1, and Random Beam comparisons by heavy PyTorch delegation or by how much computation the Triton kernel performs? A result on the non-delegating subset would clarify the low-level generation claim without changing the current benchmark rules.

The table below reports performance gains separately for kernels that delegate operations to PyTorch and those that do not. These results suggest that our method can effectively leverage PyTorch delegation while also generating efficient Triton kernels without delegation.

MethodDelegating kernelsNon-delegating kernels
CorrectFast₁CorrectFast₁
Nucleus sampling19.613.012.28.3
USC22.715.914.39.2
Likelihood16.911.011.97.6
Random Beam19.011.412.37.6
DeepConf19.011.513.17.8
ProcessKernel41.228.616.311.0
  • Correct: share of problems whose selected kernel matches the PyTorch reference in all five correctness trials (tolerance 10⁻⁴), as in Table 1.
  • Fast₁: share of problems whose selected kernel is correct and faster than PyTorch eager.
  • Delegating: the kernel leaves a heavy operation (e.g. a convolution or matrix product) to PyTorch, or does no work in Triton. Non-delegating: all other correct kernels.

Q2: The 13,309 training tasks are derived from KernelBook/PyTorch modules, yet the manuscript does not report a semantic-neighbor, graph-template, or near-code overlap audit against KernelBench. The absence of that audit limits the unseen-task interpretation; it does not establish leakage. What semantic, graph-template, and near-code overlap checks were performed between the training tasks and KernelBench, and what happens if the closest neighbors are excluded?

While meaningful exact or semantic overlap between kernel-generation problems is not straightforward to define precisely, we adopted the filtering approach proposed in [1] as a practical way to assess potential overlap. We examined both semantic, graph-template and near-code overlap between the KernelBook problems used to train our ORM and PRM and the KernelBench L1/L2 evaluation problems:

  • For semantic overlap, we use similarity of jina-embeddings-v3 embeddings (the model of the filter in [1]), reported as the L2 distance τ used there.
  • For the near-code overlapping: we use exact match and token Jaccard similarity of the problem files [1].
  • For Graph-template overlapping: two problems can differ in text but perform the same computation. In the spirit of structure-based clone detection, which compares programs by their structure rather than their text [2], we trace each module's forward pass on PyTorch's meta device and record its sequence of ATen operators, without running any kernel. One check requires an identical sequence of at least three operators (identical template). The other compares the operators of two problems by their Jaccard similarity [1] (op-set match).
  • Exact and syntactic matching. We found no overlap under exact matching or token-level Jaccard similarity, across thresholds ranging from 0.70 to 0.95 (compared with the threshold of >0.8 suggested in [1]).
  • Semantic matching. We used jina-embeddings-v3 to identify potentially overlapping problems based on their embedding-space L2 distance, with threshold τ\tau (i.e., cosine similarity > 1−τ2/21-\tau^2 /2). After excluding potentially overlapping evaluation problems under each semantic threshold, we recomputed the aggregated results in Table 1. As shown below, ProcessKernel remains the best method in varying generators and task levels. For example, at τ\tau = 0.40 its Correctness is 49.4 vs. 35.4 for the strongest baseline on L1 (+14.0%), and 59.5 vs. 35.6 on L2 (+23.9%), and at τ\tau = 0.45 its Correctness is 56.2 vs. 39.1 for the strongest baseline on L1 (+17.1%), and 58.0 vs. 38.6 on L2 (+19.4%) ([1] suggested threshold < 0.45).
  • Graph-template: after removing the graph-template overlapping problems, ProcessKernel remains the best method in Correct and Fast₁ under every filter (Table B). With an identical template, its Correct is 54.1 vs. 35.0 for the strongest baseline on L1; at op-set Jaccard ≥ 0.6, it is 53.7 vs. 29.6 on L2.

Table A1. τ = 0.35.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling29.718.60.3531.021.20.40
USC34.320.20.4137.427.40.45
Likelihood26.514.70.3028.920.50.38
Random Beam31.016.80.3529.919.20.40
DeepConf29.815.60.3331.820.50.41
ProcessKernel (Ours)52.632.10.5960.644.50.73

Table A2. τ = 0.40.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling31.717.40.3828.419.20.30
USC35.419.20.4535.625.10.39
Likelihood29.615.20.3426.618.50.30
Random Beam32.616.10.3927.716.60.36
DeepConf34.115.50.3929.718.00.35
ProcessKernel (Ours)49.427.40.5659.542.70.65

Table A3. τ = 0.45.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling37.517.20.2928.020.50.28
USC40.620.30.3638.629.50.38
Likelihood35.918.80.3325.017.80.26
Random Beam37.916.00.2627.717.10.28
DeepConf39.115.60.2530.720.10.31
ProcessKernel (Ours)56.235.90.4558.043.90.62

Table B1. Identical template (≥ 3 operators).

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling30.920.10.3830.821.30.40
USC35.021.20.3937.127.00.44
Likelihood27.215.30.2828.720.30.38
Random Beam32.217.80.3529.718.90.40
DeepConf31.116.80.3231.420.10.41
ProcessKernel54.133.80.5860.544.20.73

Table B2. Identical op set (Jaccard = 1.0).

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling28.819.20.4230.721.20.40
USC39.426.00.6537.227.20.45
Likelihood26.914.40.3529.020.50.38
Random Beam35.020.40.5129.618.70.40
DeepConf37.521.20.5331.520.00.41
ProcessKernel50.035.60.6560.544.10.73

Table B3. Op-set Jaccard ≥ 0.6.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling23.69.70.1822.512.30.30
USC34.719.40.3529.619.70.33
Likelihood26.412.50.2321.311.80.28
Random Beam27.612.70.2023.211.60.33
DeepConf29.29.70.1725.913.70.34
ProcessKernel47.230.60.4053.736.80.65

[1] Tehrani, Ali, et al. "Fine-Tuning GPT-5 for GPU Kernel Generation." arXiv preprint arXiv:2602.11000 (2026). [2] Komondoor, Raghavan, and Susan Horwitz. "Using Slicing to Identify Duplication in Source Code." SAS 2001.

Q3: The 76× ratio compares estimated execution time for labeling sampled continuations with ORM scoring time. It omits initial measured-data acquisition, reward-model training, continuation generation, and inference scoring, so it should not be read as an end-to-end cost reduction. The paper otherwise gives useful details of five FP32 correctness trials and 100 timing trials. What is the amortized end-to-end cost after measured-data collection, two reward-model training runs, continuation generation, anchor labeling, and inference scoring are included?

We have revised the text and updated our cost accounting to include the previously omitted costs. Specifically, profiling the ORM training data requires approximately 7 H100 GPU-hours, anchor profiling 2 GPU-hours, ORM training 4 GPU-hours, and ORM-based labeling (including scoring and calibration) 9 GPU-hours, totaling approximately 22 H100 GPU-hours. After including these costs, the estimated GPU-time savings relative to profiling-based labeling (around 707 H100 GPU-hours) are approximately 32X speedup (corresponding to around 96.89% time cost reduction), while providing high-quality supervision for PRM training. We have also clarified that this comparison accounts for the listed training and labeling costs, rather than representing an end-to-end cost reduction.

Q4: ORM ranking is strong for correct-versus-incorrect finished kernels (92.3% pair accuracy) but near chance across all speed pairs (51.2%), improving to 76.6% when speeds differ by at least 2×. The evidence for fine-grained speed selection among correct candidates is therefore weaker than the evidence for finding correct ones.

Although our ORM’s overall speed-pair ranking accuracy is 51.2%, this aggregate result is dominated by near-tied comparisons: more than 91% of code pairs in the test set differ in performance by at most 0.5%. For pairs with larger performance gaps, the ORM identifies the faster implementation much more reliably.

Table A. Accuracy on speed pairs, by speed gap (the 73,075 speed pairs of Table 12, from 46 problems; 95% bootstrap CI over problems). A random order gives 50.0% in every row, as in Table 12.

Speed gap between the two kernelsRandom order (%)ORM (%)
All50.051.2
≥ 1.05×49.760.8
≥ 1.2×50.362.9
≥ 1.5×49.871.2
≥ 2.1×50.476.6
≥ 3.0×50.179.4
Reviewer_vsyQOpenReview ↗
Rating
4(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes ProcessKernel, which is an execution-free process supervision framework for Triton kernel generation. The paper use LambdaRank to train an ORM to rank complete Triton kernels within each kernel generation problem. Its scores are calibrated to the terminal-grade scale using a small set of executed anchor kernels. The ORM then scoring estimiated values for sampled continuations, and further these values supervise a PRM.

At inference time, the PRM guides segment-level beam search for kernel generation and the ORM selects the final kernel, with no compilation or execution. On KernelBench L1/L2 tasks across eight generators, the method reports large gains in correctness and Fast₁ over sampling and search baselines, and a 76× reduction in labeling cost.

Critical strengths
  1. The motivation of this paper is clear and practical. Turning sparse execution feedback into reusable process guidance is a sensible and meaningful direction.
  2. I think the calibration design is well reasoned: The ORM learns only order of kernels within problems, and the scale of value is recovered from anchor kernels; And in Appendix C.3, the design is validated carefully, showing the imputed labels preserve ordering while honestly reporting scale bias, which I believe is very interesting.
  3. The evaluation is very comprehensive and well-designed, including eight generators, specialized and general-purpose kernels...
  4. The paper explicitly deals with known reward hacks such as constant outputs and precomputed weights.
Critical weaknesses
  1. Many “correct” kernels are not genuine Triton kernels, which is a classic "fallback" in kernel generation field[1]. Among ProcessKernel’s correct L1 kernels, 14–19% contain no Triton kernel at all for several generators (F1.1), and 18.2% never launch one for DR.Kernel-8B (F1.2). Results should be re-reported with F1.1–F1.3 counted as failures.

[1] StitchCUDA: An Automated Multi-Agents End-to-End GPU Programing Framework with Rubric-based Agentic Reinforcement Learning

  1. The reward models barely distinguish speed. ORM speed-pair accuracy is 0.512, near chance (Table 12). Efficiency gains therefore appear to come mostly from correctness filtering rather than speed modeling, which contradicts the “efficiency-aware” framing.

  2. Some key ablations are missing. There is no test without calibration (raw ORM scores or ranks), without per-problem offsets, and no sensitivity analysis for K.

Questions for authors

Please see the weaknesses, thank you.

4 comments

We sincerely thank all reviewers for their constructive feedback and overall positive rating of our work! We are pleased that all reviewers appreciate the ideas behind our approach. Reviewer iH7x praised the “Learning to Rank + process reward modeling idea” and described our segment-level beam search as “an interesting idea on where to start using the PRM”. The reviewers further recognize turning sparse execution feedback into reusable process guidance as “a sensible and meaningful direction” (Reviewer vsyQ) and highlight the “clear complementary roles” of the calibrated ORM and PRM (Reviewer TiWp), while also praising our “very comprehensive and well-designed” evaluation (Reviewer vsyQ) and “Strong results” (Reviewer iH7x).

Q1: Many “correct” kernels are not genuine Triton kernels, which is a classic "fallback" in kernel generation field[1]. Among ProcessKernel’s correct L1 kernels, 14–19% contain no Triton kernel at all for several generators (F1.1), and 18.2% never launch one for DR.Kernel-8B (F1.2). Results should be re-reported with F1.1–F1.3 counted as failures. [1] StitchCUDA: An Automated Multi-Agents End-to-End GPU Programing Framework with Rubric-based Agentic Reinforcement Learning.

We acknowledge that our original results used a different definition of correctness. We report the results with F1.1–F1.3 counted as failures. Specifically, we apply our static linter described in Table 7 (Appendix B.3) to the kernel selected by each method, count any kernel flagged with F1.1, F1.2, or F1.3 as incorrect, and recompute Correct, Fast₁, and Mean speedup for all six methods on both task levels.

  • Overall: ProcessKernel remains the best across every metric and task level. Over the strongest baseline on each metric, ProcessKernel still leads by 27–84% on L1 and 59–98% on L2.
  • L1: After removing them, ProcessKernel still leads clearly: Correct is 47.0%, against 35.6% for the strongest baseline (+11.4%).
  • L2: After removing the fallback kernels, ProcessKernel still shows a clear advantage: Correct is 58.9%, against 37.0% for the strongest baseline (+21.9%).
Relative improvement over Nucleus samplingL1L2
Correct54%97%
Fast₁ (eager)+50%110%
Fast₁ (compile)125%98%
Mean39%86%
LevelMethodCorrect (%)Fast₁ eager (%)Fast₁ compile (%)Mean
L1Nucleus sampling30.5020.135.000.40
USC35.6322.256.130.44
Likelihood28.1316.503.250.33
Random Beam30.6117.804.760.38
DeepConf32.1318.004.380.37
ProcessKernel47.0030.1311.250.56
L2Nucleus sampling29.8820.755.250.39
USC37.0027.135.000.44
Likelihood28.6320.384.380.375
Random Beam28.5418.713.900.39
DeepConf31.2520.254.250.40
ProcessKernel58.8843.6310.380.72
Each cell reports: Table 1 with F1.1–F1.3 counted as failures. Aggregated over 8 generators.

Q2: The reward models barely distinguish speed. ORM speed-pair accuracy is 0.512, near chance (Table 12). Efficiency gains therefore appear to come mostly from correctness filtering rather than speed modeling, which contradicts the “efficiency-aware” framing.

Although our ORM’s overall speed-pair ranking accuracy is 0.512, this aggregate result is dominated by near-tied comparisons: more than 91% of code pairs in the test set differ in performance by at most 0.5%. For pairs with larger performance gaps, the ORM identifies the faster implementation much more reliably.

Table A. Accuracy on speed pairs, by speed gap (the 73,075 speed pairs of Table 12, from 46 problems; 95% bootstrap CI over problems). A random order gives 50.0% in every row, as in Table 12.

Speed gap between the two kernelsRandom order (%)ORM (%)
All50.051.2
≥ 1.05×49.760.8
≥ 1.2×50.362.9
≥ 1.5×49.871.2
≥ 2.0×50.476.6
≥ 3.0×50.179.4

Q3: Some key ablations are missing. There is no test without calibration (raw ORM scores or ranks), without per-problem offsets, and no sensitivity analysis for K.

We added the following ablations. For each variant, we rebuilt the labels, retrained the PRM with everything else fixed, and re-evaluated the L1 task search on four generators.

Calibration and offsets (Table A): As the reviewer notes, the ORM provides the order within a problem, and the anchors recover the scale. The ablations confirm both roles:

  • Scale: recovered by g and c_x. With both, the labels are closest to the measured values (MAE 0.208 vs. 0.253 with g only) and agree best with them across problems (Pearson 0.645 vs. 0.56–0.57; cross-problem order 75.8% vs. 72.5%). We compare the MAE with g only because, without g, the labels are rescaled ORM scores and are not on the grade scale; their MAE (0.241) is shown for reference only.
  • Order: comes from the ORM and is unchanged. Since g is monotonic and c_x is shared within each problem, calibration largely preserves the ORM-induced ordering. Minor changes can arise from averaging calibrated scores across continuations, but our results show that only 2.8–5.3% of training pairs change order.

Sensitivity to K (Table B) K is the number of continuations averaged to label a prefix (K=5 by default). We built labels from only 1 or 3 of the same 5 continuations, so the analysis covers K ≤ 5.

  • Larger K improves label quality. order accuracy 65.5 / 69.3 / 71.2% for K = 1 / 3 / 5
  • Larger (K) improves PRM ranking. Top-1 0.697 / 0.709 / 0.769 for K = 1 / 3 / 5
  • The search result is robust to K. Correct is 60.2% / 60.0% / 60.5% for K = 1 / 3 / 5. These differences are not statistically significant, and they are about as large as the difference between two PRMs trained on the same K = 5 labels.
  • Every variant is far better than no PRM. With the same ORM pick, Random Beam solves 42.5% of these problems, against 60.5% for all PRM variants (+18.0%).

Table A. Labels vs. measured values

LabelsMAE ↓PearsonCross-problem pair accuracyWithin-problem pair accuracy
Paper (g + c_x)0.2080.64575.8%71.2%
g only0.2530.56272.5%71.0%
No g, no c_x0.2410.57272.5%71.5%

Table B. Effect of K

KLabel vs. measured order (%)PRM pairwise acc. (%)PRM NDCG / Top-1Accuracy (%)
165.565.60.853 / 0.69760.2
369.364.80.852 / 0.70960.0
571.266.50.874 / 0.76960.5
No PRM–––42.5

Thank you for your infomative rebuttal. I decide to increase my score to 4. Hope this paper could be accepted.

Thank you for your encouraging feedback. We sincerely appreciate your support and are glad that our rebuttal is helpful.

Reviewer_iH7xOpenReview ↗
Rating
3
Confidence
3(+1)
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

(this is an emergency review)

In this paper, the authors propose a process reward model for Kernel Generation. The idea is sound: kernels are very expensive to evaluate, since they require hardware evaluation, which leads to tons of wasted rollouts; can we train a process-level scorer that can guide ingerence time generation? Authors use learning-to-rank to first train an outcome reward model and then they transform this into a process reward model. Results show that the method is efficient and effective.

Critical strengths
  • Very well-written and readable paper. Good organization of content, paper was fully understandable even if I am not an everyday kernel-person.

  • I really like the Learning to Rank + process reward modeling idea. I think it’s very fitting and also well motivated. Segment-level beam search is an interesting idea on where to start using the PRM.

  • Strong results.

Critical weaknesses

Please see the "questions" section as my "weaknesses" might require more explanations that anything else.

Questions for authors

these are all clarification questions, some might affect the validity of the results.

  • Can we discuss why using an ORM to support the training of a PRM is not something that brings any “overfitting” problem on the specific training distribution. I am partially confident this can be seen as a form of distillation but would be good to get some more information (tried to read the Appendix but i think it would benefit from a more detailed data section).

  • Is the evaluation/setup fair?

    • I am not sure what clearly is the training corpus here. Would be good to break this up more concretely. That section is the only section that I found a little bit confusing in the paper.

    • What is the realistic overlap between problems in KernelBook and KernelBench. I am sure there might be 0 test overlap but maybe semantic overlap? I know https://arxiv.org/pdf/2602.11000 does specific filtering on the datasets to ensure little overlap. Can the authors discuss this point in the response? Can they applying filter and try some ablations?

    • Is this evaluation computed or budget matched? Does it make sense for this to be compute/budget matched?

  • In my understanding what the authors are learning here is a form of “hardware-proxy” which would suggest to me that the PRM is going to be very hardware dependent. This is not a negative per se but probably worth discussing.

  • Am I correct in assuming that what the PRM learns is going to be very in-distribution? I would assume GPU kernel finding is an act of discovery, which is often on the tail or very out-of-distribution. And I would assume that this makes it harder to find very good but very rare kernels that have very specific good properties? The PRM will learn what “generally works” but that might not be the best. This reminds to the limit of other proxy evaluations (such as the ones used in biology for drug discovery).

5 comments

We sincerely thank all reviewers for their constructive feedback and overall positive rating of our work! We are pleased that all reviewers appreciate the ideas behind our approach. Reviewer iH7x praised the “Learning to Rank + process reward modeling idea” and described our segment-level beam search as “an interesting idea on where to start using the PRM”. The reviewers further recognize turning sparse execution feedback into reusable process guidance as “a sensible and meaningful direction” (Reviewer vsyQ) and highlight the “clear complementary roles” of the calibrated ORM and PRM (Reviewer TiWp), while also praising our “very comprehensive and well-designed” evaluation (Reviewer vsyQ) and “Strong results” (Reviewer iH7x).

Q1: Can we discuss why using an ORM to support the training of a PRM is not something that brings any “overfitting” problem on the specific training distribution. I am partially confident this can be seen as a form of distillation but would be good to get some more information (tried to read the Appendix but i think it would benefit from a more detailed data section.

We find it indeed an interesting perspective to interpret the ORM-to-PRM training process as a form of knowledge distillation. From our understanding, it shares the underlying spirit of transferring knowledge from a teacher (here, the ORM) to a student (here, the PRM), allowing the student to benefit from richer supervision signals (e.g., relative rankings of expected prefix quality) than hard-label supervision alone. However, it also differs from conventional knowledge distillation in that the ORM and PRM operate on different input spaces rather than evaluating the same inputs. We believe this distinction is particularly meaningful in our setting, as the PRM is not trained to directly reproduce the ORM's scoring function, but rather to learn how outcome-level quality can inform intermediate process-level supervision. Specifically, because the ORM can only score complete kernels, we sample multiple continuations for each prefix, evaluate them using the ORM, and average their scores to obtain a Monte Carlo estimate of the prefix's expected outcome quality. The PRM is then trained to preserve relative rankings among prefixes within each problem, rather than directly regressing the ORM scores. In this sense, we believe our approach can be viewed as distilling outcome-level knowledge into process-level supervision, rather than conventional output imitation.

Additionally, our experimental setup (see also Q2) should help alleviate concerns about overfitting, as all reported evaluations are conducted on held-out kernel-generation problems. We use KernelBook for training both the ORM and PRM, while conducting all evaluations on KernelBench Levels 1 and 2. Specifically, the separation is at the problem level, meaning that the evaluated kernels correspond to different PyTorch reference implementations and associated computational workloads, rather than merely different kernel implementations of previously seen problems. This allows us to assess whether the learned outcome- and process-level supervision generalizes to unseen kernel-generation problems.

Q2: I am not sure what clearly is the training corpus here. Would be good to break this up more concretely. That section is the only section that I found a little bit confusing in the paper.

Our training corpus is constructed exclusively from KernelBook (Section 4.1 and Appendix B.1), while KernelBench Levels 1 and 2 (100 problems each) are reserved only for evaluation.

Problem preparation. We convert the PyTorch modules in KernelBook into KernelBench-style kernel-generation problems and hold out 500 problems for pseudo-label validation (Appendix C.3).

ORM training data. We use DeepSeek-V4-Flash and GPT-OSS-120B to generate complete kernel candidates, which are compiled and executed on NVIDIA H100 GPUs to measure correctness and runtime. Each training ranking list contains 16 candidates (8 positive, 8 negative examples) for the same problem.

PRM training data. We extract prefixes at different generation depths from complete kernels generated by DeepSeek-V4-Flash, Qwen3.5-122B, and MiniMax-M2.7. Each prefix is assigned a pseudo-label by sampling five continuations, scoring them with the calibrated ORM, and averaging the resulting scores. The PRM is then trained on ranking lists of 2–8 prefixes from the same problem at comparable generation depths.

Importantly, the training problems have no exact or syntactic overlap with the evaluation problems in KernelBench (see also Q3). As suggested, we have also expanded the data description in the appendix to clarify the construction process and report the complete split sizes.

Q3: What is the realistic overlap between problems in KernelBook and KernelBench. I am sure there might be 0 test overlap but maybe semantic overlap? I know https://arxiv.org/pdf/2602.11000 does specific filtering on the datasets to ensure little overlap. Can the authors discuss this point in the response? Can they applying filter and try some ablations?

While meaningful exact or semantic overlap between kernel-generation problems is not straightforward to define precisely, we adopted the filtering approach proposed in [1] as a practical way to assess potential overlap. We examined both syntactic and semantic overlap between the KernelBook problems used to train our ORM and PRM and the KernelBench L1/L2 evaluation problems:

Exact and syntactic matching. We found no overlap under exact matching or token-level Jaccard similarity, across thresholds ranging from 0.70 to 0.95 (compared with the threshold of >0.8 suggested in [1]).

Semantic matching. We used jina-embeddings-v3 to identify potentially overlapping problems based on their embedding-space L2 distance, with threshold τ\tau (i.e., cosine similarity > 1−τ2/21-\tau^2 /2). After excluding potentially overlapping evaluation problems under each semantic threshold, we recomputed the aggregated results in Table 1. As shown below, ProcessKernel remains the best method in varying generators and task levels. For example, at τ\tau = 0.40 its Correctness is 49.4 vs. 35.4 for the strongest baseline on L1 (+14.0%), and 59.5 vs. 35.6 on L2 (+23.9%), and at τ\tau = 0.45 its Correctness is 56.2 vs. 39.1 for the strongest baseline on L1 (+17.1%), and 58.0 vs. 38.6 on L2 (+19.4%) ([1] suggested threshold < 0.45).

Table A. τ = 0.35.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling29.718.60.3531.021.20.40
USC34.320.20.4137.427.40.45
Likelihood26.514.70.3028.920.50.38
Random Beam31.016.80.3529.919.20.40
DeepConf29.815.60.3331.820.50.41
ProcessKernel (Ours)52.632.10.5960.644.50.73

Table B. τ = 0.40.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling31.717.40.3828.419.20.30
USC35.419.20.4535.625.10.39
Likelihood29.615.20.3426.618.50.30
Random Beam32.616.10.3927.716.60.36
DeepConf34.115.50.3929.718.00.35
ProcessKernel (Ours)49.427.40.5659.542.70.65

Table C. τ = 0.45.

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling37.517.20.2928.020.50.28
USC40.620.30.3638.629.50.38
Likelihood35.918.80.3325.017.80.26
Random Beam37.916.00.2627.717.10.28
DeepConf39.115.60.2530.720.10.31
ProcessKernel (Ours)56.235.90.4558.043.90.62

[1] Tehrani, Ali, et al. "Fine-Tuning GPT-5 for GPU Kernel Generation." arXiv preprint arXiv:2602.11000 (2026).

Q4: Is this evaluation computed or budget matched? Does it make sense for this to be compute/budget matched?

We report the kernel generation time below. While our method introduces some additional overhead compared with standard decoding, the improved execution efficiency of the resulting kernels can help offset this cost in practice. For example, in computational workloads that run for hundreds of hours, even moderate improvements in execution speed can translate into tens of hours of GPU time saved, whereas kernel generation with our method typically takes only on the order of tens of seconds. This suggests that the additional generation overhead can be a reasonable trade-off, particularly for long-running or repeatedly executed workloads.

MethodTime Cost (seconds)
Nucleus sampling27.7
Likelihood34.6
USC36.2
DeepConf25.3
Random Beam32.1
ProcessKernel41.3

Q5: In my understanding what the authors are learning here is a form of “hardware-proxy” which would suggest to me that the PRM is going to be very hardware dependent. This is not a negative per se but probably worth discussing.

We further evaluate its cross-hardware generalization on two additional GPUs, A100 and GH200, while both the ORM and PRM are trained on H100. As shown below, the hardware does affect the improvement, but our approach still shows consistent improvement on different hardware.

Table A. H100

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling21.8812.830.3231.0021.250.40
USC27.1415.130.3537.3827.380.45
Likelihood18.097.890.2128.8820.500.38
Random Beam24.0311.130.2929.9019.210.40
DeepConf23.8510.690.2731.7520.500.41
ProcessKernel (Ours)47.8626.640.5560.6244.500.73

Table B. A100 (40 GB, Ampere).

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling21.717.400.2831.0015.250.39
USC26.979.870.3337.3820.500.42
Likelihood18.095.590.2028.7514.500.37
Random Beam23.317.480.2829.8115.470.40
DeepConf23.526.740.2531.8817.620.41
ProcessKernel (Ours)47.2014.140.5160.6233.380.71

Table C. GH200 (Grace Hopper).

MethodL1 CorrectL1 Fast₁L1 MeanL2 CorrectL2 Fast₁L2 Mean
Nucleus sampling21.8810.200.3231.0020.000.38
USC27.3012.500.3537.3825.620.42
Likelihood18.097.070.2128.8819.380.36
Random Beam24.0110.650.3029.8117.620.38
DeepConf23.859.700.2731.7520.750.39
ProcessKernel (Ours)48.1920.230.5660.6241.250.72

Q6: Am I correct in assuming that what the PRM learns is going to be very in-distribution? I would assume GPU kernel finding is an act of discovery, which is often on the tail or very out-of-distribution. And I would assume that this makes it harder to find very good but very rare kernels that have very specific good properties? The PRM will learn what “generally works” but that might not be the best. This reminds to the limit of other proxy evaluations (such as the ones used in biology for drug discovery)

From our understanding, our results suggest that the PRM captures certain transferable kernel optimization patterns, potentially corresponding to computational structures at the Triton Intermediate Representation (TTIR) level and GPU execution characteristics at the Triton GPU Intermediate Representation (TTGIR) level (e.g., memory coalescing, data reuse, and parallelism). Such patterns can generalize across different problems and, to some extent, GPU architectures, rather than being limited to memorized kernels that are highly similar to the training samples. Indeed, our formulation may overlook rare, unconventional optimizations (although it remains unclear how prevalent such cases are and to what extent they could offer additional performance gains). In this regard, if the goal is to discover fundamentally new optimization patterns, better balancing the exploration of novel kernel designs with the exploitation of learned efficient patterns would be a promising future direction. We will further refine this discussion in the final revision following the rebuttal exchange.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.