acceptodds
Under review as a conference paper at ICLR 2027

ModelParts: Model-Grounded Tasks and Roofline Rewards for Training Kernel Agents on Emerging Accelerators

Abstract

As custom accelerators proliferate, kernel-optimization agents face a recurring cold start problem: the optimized libraries current methods use for training do not yet exist. Our premise is that the AI models a platform aims to train and serve can supply training data for reinforcement learning, while the accelerator supplies rewards based on its compute and memory throughput limits. We present ModelParts, which captures model computation graphs during compilation and explores alternative partitions to generate tasks whose kernel boundaries are not limited to existing libraries or manually selected motifs. To enable reinforcement learning on these tasks without baseline kernels in the target domain-specific language (DSL), we score measured latency against the hardware's roofline. We instantiate this approach with Neuron Kernel Interface (NKI), a domain-specific language for AWS Trainium and Inferentia accelerators. We construct ModelParts-6K, a corpus of 6,000 tasks generated from five models spanning distinct architectures. To isolate the effect of ModelParts data, we train models with reinforcement learning on ModelParts-6K and a synthetic dataset of PyTorch operator compositions. To evaluate transfer beyond generated tasks, we measure whether trained models can optimize the expert-written kernels in NKILib. With profiler-in-the-loop access, the ModelParts-trained policy yields a aggregate speedup on NKILib, surpassing both frontier baselines without profiler access.

Primary area:
reinforcement learning
Keywords:
accelerator kernel optimization, reinforcement learning, model computation graphs, graph partitioning, roofline models, domain-specific languages, NKI, AWS Trainium

Reviews

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

The paper presents ModelParts, an RL training data generation technique to generate training tasks for coding models to produce efficient kernel code on new hardware, where no existing kernel library is available. The dataset consists of different partitions of sets of ATen IR operations, captured from real model graphs during torch.compile. Starting from the torchinductor's own partitioning, the authors run a Metropolis–Hastings walk with shift, fuse, and split moves to sample alternative partitions, and each resulting part becomes a task. The model must write an NKI kernel covering the operations. The authors propose using a reward based on the roofline.

Using this dataset, the authors train Qwen3.8-27B with GRPO and compare against training on synthetic operator compositions (NKI-Agent-Ops), with and without profiler access during the agent loop. ModelParts training improves Pass@8 and transfers better than synthetically generated tasks (NKO Agent Ops).

Critical strengths
  1. Important problem to work on.
  2. Authors demonstrate decent improvements in coding performance using this approach.
Critical weaknesses
  1. It is not clear that RL enables efficient kernel code generation on new hardware. Knowledge of a new platform is learnt during pretraining.
  2. It is not clear that the coding model trained on ModelParts transfers to other models, since all evaluation tasks are drawn from the same five models used for training.
  3. ModelParts addresses the data generation problem for a "new platform", but NKI/Trainium is not a new platform: it already has an SDK and expert-written kernels, and the base model has likely seen NKI code during pretraining. The cold-start setting is therefore only emulated.
Questions for authors

I think the paper was motivates a real problem of writing efficient kernel code for brand new hardware. I think the paper falls short on a few accounts. Please see my comments below:

  1. Premise of the paper. My main concern is the premise of the paper. The authors argue that current models would struggle with a new hardware release and therefore need RL training on generated tasks before a kernel ecosystem exists. Prior research, however, has shown that acquiring new knowledge happens during pretraining, and RL training only assists in sampling the model, i.e., it sharpens the distribution toward solutions the base model can already produce rather than expanding its capabilities [1]. The authors should thus narrow the motivation of the Model Parts.

  2. More general claim In my experience, modern coding models work really well at producing low-level GPU code, and with a brief description of the new DSL and hardware, this is a transferable skill. So it is not well established whether a new accelerator requires RL training on generated tasks at all, rather than prompting a strong existing model with documentation and profiler feedback. The paper's own results support this (untrained Opus 5 with PITL achieves the best NKILib speedup).

Evaluation/Results

  1. Learning transferable skills across models. Qwen trained with ModelParts using RL is able to achieve a good speedup because the tasks in dataset are generated by MH sampling of different operation sets from the same model graphs used for training. MH naturally explores peration sets with faster times using torchinductor. For a fair apples-to-apples comparison against NKI-Agent-Ops, the authors must evaluate Qwen+MP on a new model not present in the dataset. Another way to establish this is to omit one particular model from the ModelParts dataset, evaluate on tasks generated from the omitted model, and compare that to NAO.

  2. NKI and Trainium are not new hardware The base model has access to NKI code during pretraining. To study this, the authors should report pass@k for larger k for the base and RL-trained models to show whether RL expands what the model can do or only improves sampling.

  3. Comparison to prior work. Could similar gains be achieved simply by using an existing harness without any RL training? AccelOpt [2] targets the same problem on NKI through a test-time search. is it possible to ocmpare the performance of ModelParts tuned model against AccelOpt [2] on the same base model (Qwen3.8-27B)?

  4. Opus performs worse than untrained Qwen on ModelParts tasks in Table 2. Why is that?

Minor: Typo change “amd” to “and" in Section 3.1 (line 179)

References: [1] Yue, Yang, et al. "Does reinforcement learning really incentivize reasoning capacity in llms beyond the base model?." Advances in Neural Information Processing Systems 38 (2026): 57654-57689.

[2] Zhang, Genghan, et al. "Accelopt: A self-improving llm agentic system for ai accelerator kernel optimization." Proceedings of Machine Learning and Systems 8 (2026): 541-568.

1 comment

Thank you for the thoughtful review and the concrete experiment suggestions.

CW1 We agree that RL is unlikely to teach knowledge absent from pretraining, and we do not claim it does. Our claim concerns the training pipeline: ModelParts supplies a realistic, verifiable training distribution without an existing kernel ecosystem, and RL on it makes an open model write correct, faster NKI kernels far more reliably. With PITL, Pass@8 on held-out ModelParts tasks rises from 38.3 to 84.9, and the aggregate speedup on 66 NKILib kernels from 1.37× to 1.65×.

CW2 We have not yet evaluated tasks from a model outside the five and will add this. Two results already test transfer beyond them: without PITL, ModelParts training raises Pass@8 on NKI-Agent-Ops tasks, a different generator, from 23.2 to 32.2, nearly matching training on that distribution (32.9); and on NKILib, whose tasks start from expert kernels, it raises the 66 kernel speedup with PITL from 1.37× to 1.65× (faster on 57 of 66), versus 1.42× for NKI-Agent-Ops training.

CW3 Agreed: the base model has likely seen NKI code, so the cold start is emulated for the training pipeline (no NKI kernels, baselines or curated tasks), not for the model's prior knowledge, as §6 states. That exposure does not yield working kernels: before any feedback, 95.2% of base Qwen's and 94.4% of Opus 5's first submissions fail to compile. A newly released accelerator is the right test of the stronger claim; §6 lists it as future work.

Q1 We agree, and we narrowed the motivation and now cite Yue et al. Our results do not show RL adding knowledge absent from pretraining. They show RL turning partial NKI knowledge into working kernels: only 4.8% of the base policy's first submissions compile and pass, and Pass@8 with PITL rises from 38.3 to 84.9.

Q2 On NKILib, prompting a frontier model works well: Opus 5 with PITL is our strongest optimizer (1.97× on 66 kernels), as the revised abstract states. Writing kernels from scratch is different: on held-out ModelParts tasks, Opus 5 with PITL reaches 32.5 Pass@8, below the untrained 27B policy (38.3) and the trained one (84.9). Our claim concerns training open models. ModelParts tasks and the verifier can also improve prompted frontier agents.

ERQ1 Current transfer evidence favors ModelParts: it nearly matches NKI-Agent-Ops training on NKI-Agent-Ops tasks (32.2 vs 32.9 Pass@8 without PITL), while NKI-Agent-Ops training reaches 52.8 on ModelParts tasks vs 67.2. Note that the walk's energy is a roofline latency estimate (launch overhead plus per-part roofline time, §3.1), not TorchInductor timings; TorchInductor supplies only the initial partition.

ERQ2 Agreed; we will report pass@k up to k = 64 for the base and trained policies. Current numbers do not separate the two views: with PITL, the base policy already solves 38.3% of held-out ModelParts tasks within eight attempts, and training raises this to 84.9%.

ERQ3 Our untrained conditions are exactly this setting: the same harness (Harbor with Mini-SWE-Agent) and profiler access, without RL. Training raises Pass@8 on held-out ModelParts tasks from 38.3 to 84.9 and the 66-kernel NKILib speedup from 1.37× to 1.65×. AccelOpt is test-time search over an existing kernel, so it is complementary: a ModelParts-trained policy can serve as its proposer. We will report AccelOpt with base and trained Qwen3.8-27B on NKIBench at matched compute.

ERQ4 Opus 5 has no head start in writing NKI from scratch. First check-solution outcomes on the held-out generated tasks of Table 2, with PITL:

Compile errorCorrectness errorCorrect
Opus 594.4%2.0%3.6%
Qwen3.8-27B95.2%0.0%4.8%
Qwen3.8-27B MP-RL89.9%1.7%8.4%
Qwen3.8-27B NAO-RL91.9%0.0%8.1%

NKILib tasks instead start from a correct, compiling expert kernel, and frontier models had 128 steps there rather than 64, which is where Opus 5's skill shows. We replaced §5.1's "harder distribution" reading with this explanation and added the table as Appendix A.12.

Minor. Typo fixed.

We hope these analyses and narrower claims address your concerns. If they do, we would be grateful if you would consider raising your score.

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

This paper studies how to train models to write high-performance kernels for emerging accelerators that lack mature kernel libraries. The authors extract a large set of kernel-writing tasks from the computation graphs of real models and use the hardware's theoretical performance bound as the reward, so the method does not depend on existing implementations. Experiments target NKI, the kernel language for Trainium. The authors train Qwen3.8-27B with reinforcement learning, compare their task set against a dataset of synthetic operators, and examine whether giving the model access to on-device testing tools during training makes a difference. After training, the model is substantially more accurate on the generated tasks and reaches an average speedup of about 1.11× over the expert-written kernels in NKILib.

Critical strengths
  1. The problem matters in practice, and the approach is sound. Neither training nor evaluation depends on existing code in the target language, so the method suits the early stage of a new hardware platform. The overall pipeline is complete, and the experiments are clearly designed.
Critical weaknesses
  1. The novelty is limited, and the main results are not compelling. Training uses standard GRPO and an off-the-shelf agent framework. Prior work has already extracted tasks from models and evaluated kernels against hardware peak performance. The paper mainly combines existing techniques and applies them to a new hardware target. On the most important metric, speedup, the trained model reaches 1.11× on NKILib. The untrained model given only the testing tools reaches 1.06×, so the gap is small.

  2. The size of the gains from training is not explained. Training uses pure RL with a very small learning rate and a single pass over the data. Even so, Pass@8 on ModelParts rises from 34.2 to 67.2, and to 84.9 when testing tools are available. These gains are well beyond what one would usually expect from such a setup. In addition, the evaluation and training tasks come from the same sampling pipeline and may be very similar. From the current results, it is hard to tell whether the improvement reflects better kernel-writing ability or adaptation to the evaluation environment and to similar tasks.

Questions for authors
  1. The generated task set is not too hard. Yet even with on-device debugging, Opus 5 fails all eight attempts on more than 60% of the tasks, while the same model performs best on NKILib. Could the authors break down each model's failures into formatting errors, compilation or API errors, numerical mismatches, timeouts, and budget exhaustion? If numerical mismatches dominate, how many are minor discrepancies, such as differences of one or two ULPs caused by rounding intermediate results at different points than the reference implementation? Since the model cannot see how the reference implementation computes its results at a low level, are such discrepancies inherently hard to match? Finally, can the authors show that every generated task is solvable under the current tolerance?

  2. What explains the near-doubling of Pass@8? Which kinds of errors in the base model does training mainly fix? Could the authors report Pass@1 before and after training, along with Pass@k curves for larger values of k? These would show whether the base model can also solve the newly solved tasks when given more samples.

1 comment

Thank you for the detailed questions. We have clarified the contribution, expanded the NKILib evaluation, and added first-solution outcomes in Appendix A.12.

CW1 We use standard GRPO and an off-the-shelf harness to isolate the effect of the training distribution rather than introduce a new RL algorithm. ModelParts generates executable tasks by sampling partitions of compiled model graphs beyond the compiler-selected boundaries, and supports RL without target language baseline kernels. We agree that hardware-limit scoring is established: §2 now cites SOL-ExecBench and discusses AccelOpt/NKIBench. Our distinction is using a correctness-gated roofline ratio as the RL reward without requiring a target-language performance baseline.

The matched-profiler gain on the ten core NKILib kernels is modest: 1.06× to 1.11×. We therefore expanded the evaluation to 66 NKILib kernels. With profiler access held fixed, ModelParts training raises aggregate best-of-eight speedup from 1.37× to 1.65×, and produces faster kernels than the base policy on 57 of 66 tasks. The same RL setup with NKI-Agent-Ops training reaches 1.42×, supporting the importance of the task distribution. Opus 5 with profiler access remains stronger at 1.97×; we do not claim to outperform frontier models. Table 3 retains the ten core per-kernel results, while new Table 4 reports geometric-mean aggregates for both sets across all evaluated settings. Expanded per-kernel results are in Appendix A.5. (§5.2)

CW2 Training makes one pass over each corpus, with eight rollouts per task and a learning rate of 2.5 × 10⁻⁷ (§4.1). The new analysis identifies a shared early barrier: base Qwen fails compilation on 95.2% of first check-solution calls. ModelParts training reduces this to 89.9% and raises first-call correctness from 4.8% to 8.4%. Merkle hash deduplication precedes the training/evaluation split, preventing exact duplicates under that representation. Transfer is also observed outside ModelParts: without PITL, ModelParts training raises NKI-Agent-Ops Pass@8 from 23.2 to 32.2, nearly matching training on NKI-Agent-Ops itself (32.9). The expanded NKILib results provide further evidence beyond the generator's own tasks. (§4.1, §5.1, §5.2.)

Q1 Appendix A.12 reports first-call outcomes on the held-out generated tasks, pooling ModelParts and NKI-Agent-Ops, with PITL:

ModelCompilation errorCorrectness errorCorrect
Opus 594.4%2.0%3.6%
Qwen3.8-27B95.2%0.0%4.8%
Qwen3.8-27B, RL on ModelParts89.9%1.7%8.4%
Qwen3.8-27B, RL on NKI-Agent-Ops91.9%0.0%8.1%

Percentages are over rollouts with a first call. Compilation dominates these initial outcomes. We revised §5.1 to avoid treating Opus's performance gap as evidence that model-grounded tasks are intrinsically harder.

For BF16 outputs, the verifier accepts |ŷ − y| ≤ max(β·RMS(y), ε) + ρ·|y|, with ρ = 10⁻², β = 10⁻³, and ε = 10⁻⁶. A one-ULP difference for a finite normal BF16 reference value is at most about 0.78% relative and falls within the 1% relative term. The best condition solves 84.9% of held-out ModelParts tasks within eight attempts. (Table 2, Appendix A.9.)

Q2 Table 2 already reports pass rates before and after RL training, with and without profiler access. With profiler access held fixed, ModelParts training raises held-out ModelParts Pass@8 from 38.3% to 84.9%. The first-call analysis complements these rollout-level results: correct first submissions increase from 4.8% to 8.4%, before any profiler feedback. Together, these analyses demonstrate improved single-submission reliability and task coverage at a matched eight-attempt budget. We have added Pass@8 curves to the Appendix. (Table 2, §5.1, Appendix A.12.)

We hope the clarified claims and additional analyses address your concerns. We would be grateful if you would reconsider your assessment in light of these revisions.

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

This paper creates 6,000 kernel-writing tasks. It uses hardware roofline estimates to reward fast, correct kernels without optimized baseline implementations. The result is improved kernel generation and modest speedups over expert Trainium kernels.

Critical strengths

The paper is easy to understand and the experiment is clean. The authors faithfully reported results and the paper looks complete.

Critical weaknesses
  1. The performance gain is over-exaggerated: ModelParts-trained Qwen with profiler feedback achieves 1.11× aggregate NKILib speedup. However, Opus 5 with feedback achieves 1.27×. So technically the paper's trained model does not surpass Opus 5.
  2. Only ten kernels are evaluated.
  3. Perhaps the biggest problem -- the lack of a concrete problem to solve. Most papers try to solve a specific problem, which requires innovation. This paper doesn't seem to have identified a problem that previous works could not solve. Other papers have used roofline performance as the reward without generating reference solutions. I want the authors to articulate very clearly what is the problem they are trying to solve and how does this paper differ from prior work.
Questions for authors

Q1: Appendix A.5 uses the chip’s 181 FP32 TFLOP/s rate universally, while tasks include BF16. Why is there a discrepancy? Is the numerator for the reward always a valid latency lower bound??

1 comment

Thank you for a clear and constructive review. We made the corrections below (see also the general response).

CW1: Agreed. The abstract compared our policy with profiler access against frontier models without it. The revised abstract reads: "With profiler-in-the-loop access, ModelParts training raises the 27B policy’s aggregate speedup on an expanded set of 66 NKILib kernels from 1.37× to 1.65×. Frontier models with the same access remain stronger (Opus 5: 1.97×)." Our claim is about improving an open model, not about outperforming frontier models. (Abstract, §5.2, Table 4)

CW2: The ten kernels are NKILib core kernels used frequently by vLLM model deployments on Trainium. We evaluated against an expanded set of 66 NKILib kernels. With profiler access, ModelParts training raises the aggregate best-of-eight speedup from 1.37× to 1.65× and produces faster kernels than the base 27B policy on 57 of the 66 tasks. Opus 5 with profiler access reaches 1.97×. Per-kernel results are in the new Appendix A.5. We retain the ten core per-kernel results in Table 3, removing its aggregate column. New Table 4 reports aggregate best-of-eight speedups for both the original ten-core-kernel set and the expanded 66-kernel set, across all model, training, and profiler-access settings. Both aggregates are geometric means of per-kernel speedups over expert implementations, using the same best-of-eight selection and verification protocol.

CW3: The problem we are trying to solve is training kernel agents with RL at scale when existing training tasks are scarce and reward signals are difficult to calibrate: ModelParts provides a large, realistic task distribution, and roofline scoring provides a hardware-normalized reward signal, without requiring existing kernels in the target language.

Curated benchmarks are small and fixed, mined corpora presuppose existing kernels, synthetic compositions are not derived from actual model graphs, and most reward pipelines need a baseline kernel. ModelParts turns the models a platform must serve into a scalable distribution of verifiable tasks by sampling fusion boundaries of their compiled graphs, and RL on it improves correctness and transfers to expert-written kernels. How it differs from prior work:

WorkTask sourceKernel BoundariesUsed for
SOL-ExecBench235 tasks from 124 modelsFixedEvaluation
FastKernels384 tasks from 47 architecturesFixedEvaluation
NKIBench (AccelOpt)14 kernels from LLM workloadsFixedTest-time search
CUDA-Agent-Ops, NKI-AgentSynthetic operator compositionsDefined by sampled synthetic compositionsRL, SFT
ModelPartsSampled partitions of compiled model graphsSampled beyond compiler choicesRL

We agree that scoring against hardware limits is not new. We now cite SOL-ExecBench’s speed-of-light score and discuss AccelOpt/NKIBench’s scoring against peak hardware throughput (§2). We are unaware of prior work using a roofline-based performance measure directly as the RL reward for training kernel-generation policies. If the reviewer has such work in mind, we would welcome the reference and revise our discussion accordingly.

Q1: Thank you for catching this. It is an error in the paper's text, not in the experiments: the verifier and the partition walk count matmul FLOPs at the peak for their dtype (Trainium2 dense: 667 TFLOP/s for BF16, 181 for FP32; the verifier allocates one quarter to its LNC = 2 context), so all reported rewards already use valid lower bounds and no result changes. Appendix A.6 listed only the FP32 figure. We corrected it and the compute-peak definition in §3.1. (§3.1, Appendix A.5)

We hope these changes address your concerns. If they do, we would be grateful if you would consider raising your score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary for Program, Senior Area and Area Chairs

We thank the reviewers and chairs for their feedback. We summarize the initial assessments and rebuttal evidence below.

1. Initial Review Assessment

The reviews recognized an important problem and a clear experimental pipeline. wrAF described the approach as sound and suitable for the early stage of a hardware platform; svnM recognized improvements in coding performance; REaj highlighted clear presentation and clean experiments.

The concerns centered on the contribution relative to prior work, the magnitude and breadth of transfer, the distinction between training and profiler feedback, and the interpretation of the cold-start setting. The revised paper and our responses address these points through an expanded evaluation, matched comparisons, and first-submission analysis.

2. Key Rebuttal Updates

Expanded expert-kernel evaluation (REaj, wrAF, svnM). We expanded evaluation from ten vLLM-serving NKILib core kernels to 66 NKILib kernels. With profiler access held fixed, ModelParts training raises Qwen3.8-27B’s aggregate best-of-eight speedup over expert implementations from 1.37× to 1.65× and produces faster kernels on 57 of 66 tasks. The paired improvement is 1.20×, with a 95% bootstrap confidence interval over kernels of 1.15–1.27×.

Setting, all with profiler accessCore kernels (10)Expanded kernels (66)
Base Qwen3.8-27B1.06×1.37×
Qwen3.8-27B trained on NKI-Agent-Ops1.06×1.42×
Qwen3.8-27B trained on ModelParts1.11×1.65×
Opus 51.27×1.97×

Table 3 retains the ten core per-kernel results. New Table 4 reports geometric-mean aggregates for both sets under the same verification protocol; Appendix A.5 provides expanded per-kernel results. The abstract now names Qwen3.8-27B and compares models with the same profiler access.

Separating training from feedback and task-distribution effects (wrAF, svnM). Table 2 compares base and trained policies with and without profiler access. Holding profiler access fixed, ModelParts training raises held-out ModelParts Pass@8 from 38.3% to 84.9% and Reward@8 from 0.063 to 0.293. The expert-kernel comparison likewise holds profiler access fixed: 1.37× for base Qwen, 1.42× after NKI-Agent-Ops training, and 1.65× after ModelParts training. Standard GRPO, the same off-the-shelf harness, and matched training settings make this a controlled comparison of training distributions.

Transfer beyond the generator’s own tasks (wrAF, svnM). Without profiler access, ModelParts training raises Pass@8 on independently generated NKI-Agent-Ops tasks from 23.2% to 32.2%, nearly matching training on that distribution itself (32.9%). In the reverse direction, NKI-Agent-Ops training reaches 52.8% on ModelParts tasks, compared with 67.2% after ModelParts training. Together with the expanded expert-written NKILib evaluation, these results establish transfer across task sources. Canonical Merkle-hash deduplication precedes the training/evaluation split.

First-submission analysis (wrAF, svnM). Appendix A.12 reports each rollout’s first check-solution outcome on held-out generated tasks with profiler access, pooling ModelParts and NKI-Agent-Ops. ModelParts training raises correct first submissions from 4.8% to 8.4% and reduces compilation errors from 95.2% to 89.9%. These submissions precede verifier feedback, providing evidence of improved initial kernel generation alongside the complete-rollout results in Table 2. The revised §5.1 also distinguishes generation from scratch from NKILib optimization, which begins with a correct expert kernel.

Clarified contribution and scope (all reviewers). ModelParts addresses the availability of realistic training tasks and performance supervision before a mature target-language kernel ecosystem exists. It samples executable tasks from alternative partitions of compiled model graphs and uses a correctness-gated roofline ratio as the RL reward. The revised related-work discussion distinguishes this training use from hardware-limit evaluation in SOL-ExecBench and test-time optimization in AccelOpt/NKIBench. The cold-start claim concerns the training pipeline’s independence from target-language baseline kernels. Our claim is that this pipeline improves open-model kernel generation and optimization; frontier agents remain complementary.

3. Significance of the New Evidence

The expanded evaluation changes the empirical picture from a small gain on ten highly optimized serving kernels to a broader, statistically supported improvement over 66 expert implementations. Matched-profiler comparisons separate training gains from access to testing tools, while cross-generator transfer and first-submission outcomes provide complementary evidence of improved kernel-writing reliability.

We respectfully ask the Area Chairs and Senior Area Chairs to consider this expanded evidence and the clarified contribution when assessing the paper.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.