acceptodds
Under review as a conference paper at ICLR 2027

Self-Play Pretraining with Zero-Data

Abstract

Advances in language modeling have been driven by scaling pretraining on ever more data. Yet, training data is still largely curated on the model's behalf. A more general approach to pretraining would let the model learn to generate the data that is most useful for its own improvement. This would provide an effectively unbounded source of training data, relying on compute rather than the total sum of human ingenuity. We introduce **Self-Play Pretraining with Zero Data**, an initial proof-of-concept towards this vision. Starting from random initialization, two autoregressive transformers learn in tandem: a generator proposes programs interpreted by a universal Turing machine, generating byte sequences, while a learner autoregressively predicts these byte sequences. The learner is trained with standard cross-entropy, while the generator is trained with reinforcement learning to produce sequences at the frontier of the learner's capabilities, yielding an adaptive curriculum. We use a universal Turing machine because any computable data-generating process can be represented as a program, providing a broad search space with minimal domain-specific assumptions. Self-play then learns which parts of this space produce useful training data, rather than requiring us to specify such structure in advance. We test whether zero-shot performance on natural data improves predictably with self-play compute; this is a clean test of transfer since neither generator nor learner is trained on natural data. Across several natural datasets, zero-shot loss exhibits predictable power-law scaling in compute, with scaling exponents comparable to those obtained by training directly on natural data. This suggests that learning universal predictive structure may play an unappreciated role in driving pretraining gains; we formalize this via a new scaling law ansatz. The resulting models also exhibit in-context learning.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
self-play, pretraining, solomonoff induction

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_YrJZOpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper introduces a novel (to the best of my knowledge) pretraining strategy that uses no natural data. The training sequences are synthetic byte sequences created by programs sampled from a generator. An RL-based scheme pushes the generator to create programs that are structured and aligned with the learner's trajectory. The main result is that the resulting model achieves nontrivial performance across a wide range of datasets, including images, text, and code. Furthermore, performance scales with compute as in Neural Scaling Laws, suggesting the possibility of scaling up this procedure to larger data and model scales.

Critical strengths
  1. This work contributes significantly to the line showing that nontrivial predictive performance can emerge without natural-data pretraining. The introducion of an adaptive self-play strategy improves on fixed program sampling and seem to transfer across several modalities. I find this a compelling contribution to understanding how synthetic training data can support broadly useful learning.

  2. I found the paper particularly enjoyable to read. The central research question is clear and well motivated. The text provides useful intuition for the proposed approach. This clarity makes both the method and the significance of the empirical findings accessible, strengthening the paper’s value to a broad ICLR audience.

Critical weaknesses

I did not find any critical weakness, although the authors should have tried to connect their results to ideas from the theoretical In-Context learning literature (see question below). I also added some minor concerns about the presentation in the questions section below.

Questions for authors

I believe that the submission as it stands is worthy of acceptance, but the extreme coarseness of the review form does not allow me to give a clearly positive assessment that could still be improved through feedback. In particular, the instruction to ask only assessment-changing questions is too restrictive to allow for general feedback that could improve the paper and contribute to a useful scientific discussion, without changing my assessment. This is a shame as it obstructs thoughtful reviewing and meaningful author-reviewer discussions aimed at improving the paper. I hope it will not become standard practice in future ML conferences.

Nevertheless, since I spent some time going through the paper, I will post my feedback here. If the authors reply, we will hopefully make something productive of this nonsensical review process.

Main questions

Comparison with ICL

According to some, the in-context learning phenomenon where a model infers a task from examples in the prompt is only an instance of a more generic form of out-of-distribution generalisation (see here for the main idea, here for a broad overview). In simple terms, when a learner is trained on examples drawn from a distribution over tasks, the learner might learn a generic predictive strategy instead of specialising to the individual tasks presented during training. This scenario is similar to the setting of this paper, as (modulo replay) every sentence is drawn from a new program. I wonder if it's possible to interpret the main observation of this paper as the model having learned some inference strategy over programs taken from a certain distribution. For example, even a model that infers the best Markov-process approximation of language would have nontrivial performance on real text. I understand that, in this case, the distribution over programs is evolving with training, but I would be curious to hear the author's idea on this connection.

Self-play with PCFG

The authors use a Brainf*ck-like language to generate programs, so as to guarantee, via Turing completeness, the representability of any data-generating process. However, the data on PCFG pretraining suggests that there might be a preference towards PCFG-like data-generating processes for text and code. Have the authors thought of changing the architecture of the program generator to incorporate a preference towards particular classes of data-generating processes?

Clarification requests and other minor concerns

  1. The sketch explaining the generator reward in Figure 1 is far less clear than anything else in the first 5 pages or so. The in-text explanation before equation (2) is much simpler, so I hope the authors can find a better illustration.

  2. I am not an expert in policy-gradient RL. I would have liked to have some intuitive description of the choices listed on page 5, between line 226 and equation (5). There was a similar explanation about the particular choice of reward on the previous page, which worked quite well. Even something at that level would be great to have.

  3. In the "explaining scaling laws" section, I think that the distinction between DcD_c and DuD_u should be commented on immediately after equation (7). This is, I believe, the most important point of this section, and also a subtle one, which the sentence immediately after equation (7) does not clarify. Specifically, I agree with the author's intuition that scaling up DD should increase both DcD_c and DuD_u, but this cannot be true in general: think, for instance, of data memorisation, or of the aforementioned ICL phenomenon where learners transition from generic predictive strategies to specialising to the individual tasks seen in training. Without a more specific definition of DuD_u and DcD_c and/or a more detailed comment on when they are expected to increase with DD, the paragraph "comparing self-play and natural-data exponents" could be misleading.

  4. The very last sentence of the main "future work. We defer a broader discussion to Appendix." does not seem to make much sense.

3 comments

Thank you for your exceptionally thoughtful review and positive assessment of our work! We are delighted that you found our research question compelling, the presentation clear, and the cross-modal transfer results significant. We especially appreciate the time you took to provide detailed feedback beyond the requirements of the review form, and welcome the opportunity to engage with you on these broader scientific questions. We respond to your comments below.

Q1: Connection to theoretical ICL

I wonder if it's possible to interpret the main observation of this paper as the model having learned some inference strategy over programs taken from a certain distribution.

We agree with this interpretation! Indeed, our approach is motivated by approximating Solomonoff induction, which fits naturally into the framework you describe. Under a prior over programs, the Bayes-optimal predictor infers a posterior over programs consistent with the observed context and uses this posterior to predict the next token. In principle, this encompasses inference over arbitrary computable generative processes, including HMMs, Gaussian processes, and more. Our KL regularization toward the uniform program prior is motivated precisely by this connection.

We also agree that learning a simple Markov approximation could already yield nontrivial performance on natural text. However, our ICL results in Section 3.2 provide evidence that the learner acquires richer predictive strategies. Tasks such as reverse string and stack require behavior beyond simple fixed-order Markov prediction, and models trained on the fixed universal prior or PCFGs largely fail on these tasks. Moreover, we have now evaluated a matched-size byte-level model pretrained on natural text: our self-play model matches its performance on associative recall and exceeds it on the other ICL evaluations.

We view these results as encouraging evidence that self-play can induce general-purpose inference strategies. Understanding precisely which inference algorithms emerge, and how they evolve with scale, is an exciting direction for future work.

Q2: Self-play with PCFG

Have the authors thought of changing the architecture of the program generator to incorporate a preference towards particular classes of data-generating processes?

We agree that incorporating domain-specific inductive biases could substantially improve practical performance. Indeed, the strong performance of PCFG pretraining on text and code suggests that hierarchical and compositional structure is particularly valuable for these domains.

While all Turing-complete programming languages can express the same class of computable data-generating processes, their inductive biases can matter substantially at finite compute. For example, probabilistic programming languages such as Church (Goodman et al., 2008) make stochastic and hierarchical structures easier to express, while learned libraries of reusable abstractions, as in DreamCoder (Ellis et al., 2021), can make complex compositional programs easier to discover.

In the present work, we deliberately use a minimal universal language to isolate the capabilities of a general-purpose learning procedure. We are nevertheless excited about richer program representations and improved search procedures, and view this as an important direction toward improving self-play pretraining.

Q3.2: Intuition for policy-gradient choices

I would have liked to have some intuitive description of the choices listed on page 5 [...]

Thank you for this suggestion. We will expand the explanation of the generator's training objective, particularly the motivation for the following components:

  1. Reward normalization. The overall magnitude of the learning-progress reward changes substantially over training. We normalize rewards within each round because the relative differences between programs are more informative for updating the generator than changes in the overall reward scale. Relative rewards also preserve the correctness of the PG update due to the score function identity but can reduce variance of the gradient estimates; this is exactly the idea of control variates in statistics.

  2. Importance sampling. Replayed programs were sampled from earlier generator policies. The importance ratio corrects for this distributional mismatch when estimating the policy gradient under the current generator.

We have incorporated these intuitions into the main text (see revised Methods section).

Q3.3: Universal and contingent data in the scaling-law ansatz

Without a more specific definition of DcD_c and DuD_u and/or a more detailed comment on when they are expected to increase with DD, the paragraph "comparing self-play and natural-data exponents" could be misleading.

We appreciate this thoughtful observation. We agree that the distinction between universal and contingent information is subtle, and that their growth with dataset size should be presented as an assumption rather than a general guarantee.

Our intended interpretation of DcD_c and DuD_u is as effective information resources accessible to a learning algorithm: contingent information specific to the target distribution and universal predictive structure shared across distributions. We recognize that defining these quantities independently of the learning procedure, without sacrificing the generality of the framework, is challenging.

The assumption that both quantities increase with DD is most natural when additional data consists of fresh samples from a fixed underlying distribution, rather than repeated exposure to a finite corpus. As the reviewer points out, memorization or a transition toward task-specific strategies can violate this intuition. We agree that these distinctions deserve explicit discussion.

We will therefore make three clarifications in the revision:

  1. Clarify the interpretation of DcD_c and DuD_u immediately after Equation 7, emphasizing that they represent effective information available to the learner rather than simply raw dataset sizes.
  2. Explicitly identify Equations 9 and 11 as assumptions. In particular, Equation 9 assumes that self-play continues to discover additional universal structure as training progresses. This is an empirical hypothesis supported by our observations, not a theoretical guarantee.
  3. Qualify the comparison between self-play and natural-data scaling exponents to clarify the conditions under which the proposed decomposition is expected to apply.

We thank the reviewer for identifying this important subtlety. We believe these changes will make the interpretation of our scaling results more precise.

Q3.4: Final sentence of the discussion

The very last sentence [...] does not seem to make much sense.

Thank you for catching this editing artifact! We will correct the sentence and use the additional space to expand the broader discussion, including the connection to theoretical ICL raised above.

Thank you again for your thoughtful engagement and constructive suggestions. We hope our responses and revisions have addressed your questions and strengthened the paper. We appreciated the opportunity to engage fruitfully with the reviewer. Given your positive assessment, we would be especially grateful if you could champion our paper during the reviewer discussion.

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

This paper proposes an approach to pretrain LLMs without using any natural data. The authors design a generator-learner setup, where the generator generates programs that are executed in a UTM to yield a sequence of bytes which is then fed to the learner for standard CE loss based NTP training. The key innovation introduced in this paper is to continuously adapt the generator to generate sequences that enable better learning. The authors do this by training the generator using RL where the reward is defined by the closeness of the gradient to the learning trajectory of the learner. The authors compare their approach against a baseline w/o trained generator, and another baseline generating data using PCFG, and claim that their approach scales relatively more universally on unseen domains such as images, music, etc.

Critical strengths
  • The main novelty and strength of this paper is the proposed approach for generating the data. The RL reward has an interesting and well-motivated design and the authors show its utility with good ablations. The authors also made some clever choices wrt the program language and execution-semantics engineering.
  • While my subjective opinion regarding the setting is mixed (see weaknesses), the universal scalability of the approach across so many different domains is indeed interesting.
Critical weaknesses

Main weaknesses:

  1. Issues wrt evaluation which make it difficult to gauge the utility of the method.

1(a) The compute accounting seems unfair. In figure 2, the x axis compute is C = K * N * D. I may be wrong, but it seems that the authors are only including learner compute in this. Since their proposed method simultaneously trains the generator, its training and sampling compute should be included.

1(b) Lack of a data-constrained/hybrid regime. The practical question that I think is interesting is we have access to a "small amt of natural data" + "infinite compute". The appendix setting is different in the sense that it only focuses on initialization/pre-pretraining. The better setting is similar to that of Kim et al. (2026) where you assume access to a fixed set of natural data -- and the goal is then to design an approach that scales best.

1(c) The ICL evaluation doesn't seem like a faithful test. It is naturally biased to favor the proposed approach since these tasks are algorithmic. It would be fairer to also show a same-sized byte-level model pretrained on DCLM evaluated on these tasks.

1(d) Insufficient comparison to natural-data training. The authors claim that the observed scaling exponents are comparable to standard pretraining in their domains, but this is not well-supported. Scaling behavior also needs reporting of irreducible errors, starting loss, etc. and it is unclear what the differences in experimental setup could be for the previous works' reported exponents (e.g., tokenization, architecture, etc). I think it is very important the authors carry out the all-else-equivalent natural-data training and compare the scaling curves similar to Fig 2.

  1. Insufficient discussion of related works and missing baselines.

2(a) There is no detailed and dedicated discussion of prior works in this paper. Self-play, synthetic data generation, and data-constrained scaling laws are very active areas of research. Some examples of missing prior works that should have been cited: zero-data self-play [2,5], teacher-student curricula with replay [3, 4], data-constrained scaling framework [6].

2(b) Missing baselines: Synthetic generators that the paper already cites but does not compare against: (Lee et al., 2026) and (Hu et al., 2025). Comparison against modality-specific generators e.g., [7].

Minor point:

  • The fact that the PCFG baseline outperforms your approach on text and code is quite significant in my opinion. It doesn't seem like a realistic setting that we would train models without access to any image/audio/other-modality data so the universality weakness feels like a strawman.

References:

[1] Hwang et al. (2025). Dynamic Chunking for End-to-End Hierarchical Sequence Modeling.

[2] Zhao et al. (2025). Absolute Zero: Reinforced Self-play Reasoning with Zero Data.

[3] Sukhbaatar et al. (2018). Intrinsic Motivation and Automatic Curricula via Asymmetric Self-Play.

[4] Dennis et al. (2020). Emergent Complexity and Zero-shot Transfer via Unsupervised Environment Design.

[5] Huang et al. (2025). R-Zero: Self-Evolving Reasoning LLM from Zero Data.

[6] Muennighoff et al. (2023). Scaling Data-Constrained Language Models.

[7] Baradad et al. (2021). Learning to See by Looking at Noise.

Questions for authors

Q1. The fixed byte-level tokenization aspect of the current approach will be painful at large scales and longer contexts. Did the authors explore dynamic tokenization methods [1]?

5 comments

Thank you for your thoughtful review! We are glad you found our generator's RL reward interesting and well motivated, the ablations convincing, and the program language and execution semantics thoughtfully designed. We appreciate your observation that predictable scaling across such diverse natural domains is an interesting result. We address your concerns below.

W1(a): Compute accounting

The authors are only including learner compute [...].

We thank the reviewer for this suggestion. We have additionally quantified the cost of generator training, sampling, and reward computation.

The largest additional cost comes from the reward computation, which uses forward-mode automatic differentiation at a cost of approximately two forward passes. Unlike standard RL settings, generator training/inference is relatively inexpensive because programs are much shorter than the learner's 4096-token context: at most 512 tokens and typically only 30–60. Together, generator inference and training cost no more than 7/16 of a learner forward pass, and typically an order of magnitude less. This is a computational advantage of our approach: short programs can generate long sequences with rich algorithmic structure, with execution handled efficiently on CPUs rather than requiring memory-bandwidth-intensive generation on GPUs; moreover this computation can potentially be overlapped with GPU.

  • Including all compute shifts the self-play scaling curves right by only 0.26 decades. We will incorporate this correction into the revised paper (Figure 12), as suggested by the reviewer.

  • This does not change our scientific conclusions. The correction preserves the observed power-law scaling across diverse natural domains.

W1(b): Data-constrained and hybrid pretraining

The practical question [...] is we have access to a "small amt of natural data" + "infinite compute".

We agree that the data-constrained setting, such as the one explored in papers including Kim et al. (2026) and Muennighoff et al. (2023), is relevant to our work and are excited by this setting; due to a formatting error in Latex, we included a relevant work section with citations to these papers in the initial submission but due to a formatting error, they were not rendered. We have since corrected this in the revised version.

However, our primary goal is to investigate the scientific limits and conceptual promise of pretraining through self-play, in the service of the scientific question about whether universal prediction is possible. Our goal is not to propose an immediately practical algorithm for data-efficient pretraining, which we agree is a very interesting setting.

Moreover, extending our approach to data-constrained settings raises substantive scientific questions that are outside of the scope of our work: how to optimally repeat a finite natural-data corpus, how to mix or schedule natural and self-play data, and how to allocate compute between them. We believe these questions deserve careful investigation and we highlight this important practical direction as future work.

We also emphasize that the data-constrained motivation makes broad cross-modal transfer particularly relevant. English and code enjoy abundant natural data and already benefit from relatively mature methods for generating synthetic data compared to other domains. Indeed, it is precisely on non-language modalities such as images, audio, speech, and music that our approach outperforms the hand-designed PCFG baseline. We believe this suggests particular promise for data-constrained settings where strong domain-specific synthetic generators are less readily available.

W1(c): ICL evaluation

The ICL evaluation doesn't seem like a faithful test [...] these tasks are algorithmic.

We agree that evaluating a matched byte-level model pretrained on DCLM would provide useful additional context. We ran the experiment suggested which shows that matched compute and tokens training on DCLM is insufficient on its own to lead to ICL in the learner (Figure 10). This is shown in the appendix of our paper. We emphasize that our ICL evaluations are meant to establish that substantial ICL capabilities can emerge without exposure to natural data and not that it is a strictly better way of obtaining ICL capabilities.

We also emphasize that these evaluations are standard for evaluating ICL capabilities in smaller models without instruction following capabilities. Moreover, they exactly evaluate whether self-play teaches the learner to infer and apply previously unseen rules from context, which is a natural test of the universal prediction perspective motivating our method. Crucially, these tasks are held out from training, and the learner must infer the relevant rule entirely in context. We also compare against the universal-prior and PCFG baselines, which generally fail to exhibit the same breadth of ICL behavior.

W1(d): Comparison to natural-data scaling

We thank the reviewer for this suggestion. We agree that a fully controlled comparison of scaling exponents would be scientifically valuable. More broadly, understanding what determines scaling exponents, and under what conditions they remain invariant to changes in architecture, tokenization, and training methodology, is itself an important open research question. Prior work suggests that exponents can be relatively robust to certain architectural choices, although this is not universal.

However, we would like to clarify the scope of the requested experiment. An all-else-equal comparison would require training and tuning an entirely new family of models on natural data, across multiple compute scales, for every dataset and encoding reported in Table 2. This would amount to a substantial independent scaling-law study, well beyond what is feasible during the rebuttal period. We agree that this would make for valuable follow-up work.

Importantly, our central empirical finding does not depend on an exact match between these exponents. The exponents in the literature provide suggestive context for the magnitude of these improvements, rather than a controlled equivalence claim.

W2(a): Related work

There is no detailed and dedicated discussion of prior works in this paper.

We apologize that a dedicated Related Work section, covering synthetic data, self-play, universal prediction and algorithmic pretraining was accidentally omitted from the submission. We have restored it as Appendix A (in red) and added all suggested references.

W2(b): Missing synthetic-data baselines

Synthetic generators that the paper already cites but does not compare against: Lee et al. (2026) and Hu et al. (2025). Comparison against modality-specific generators.

We appreciate these suggestions and agree that these are relevant approaches, both of which we cite in our new related work.

However, our goal is not to establish that self-play outperforms every hand-designed synthetic generator, but to understand whether learning to generate training data can produce transferable predictive structure. Our baselines were chosen to isolate two specific scientific questions:

  1. Does adapting the generator matter? The fixed universal-prior baseline uses exactly the same program space as self-play, isolating the contribution of learning the sampling distribution.
  2. How does learned data generation compare with a strong hand-designed structural prior? The PCFG baseline tests whether the benefits of a specialized inductive bias extend across diverse natural domains.

We believe these controlled comparisons provide meaningful evidence for our central scientific claims, independently of whether other synthetic generators might achieve better performance on particular domains. Indeed, as discussed above, we do not expect any single approach to dominate all specialized generators.

A broader comparison across synthetic pretraining methods is valuable, but addresses a different question: which synthetic distributions are most effective for particular downstream domains? Our contribution is to demonstrate that useful training distributions can themselves be learned through self-play, with predictable improvements across diverse modalities. We clarify the motivation for our baseline selection in the revision in the Appendix.

W2(b): PCFG performance on text and code

The fact that the PCFG baseline outperforms your approach on text and code is quite significant [...]

We agree that this is an important result, and we explicitly highlight it in Section 3.1. PCFGs provide a strong inductive bias toward hierarchical and compositional structures, making them particularly effective on text and code.

Our contribution is not that self-play universally dominates specialized generators, but that a single learned generator exhibits predictable scaling across remarkably different modalities without domain-specific design. Indeed, no-free-lunch considerations suggest that no single inductive bias should be optimal across all possible domains.

The PCFG results illustrate this tradeoff: specialized priors can perform better on domains that match their inductive biases, while self-play provides broader transfer. Moreover, text and code already benefit from relatively mature approaches to synthetic data generation. We believe the strong performance of self-play in other modalities highlights the promise of learned data generation, especially in domains where domain-specific synthetic data generators are not readily available.

Q1: Dynamic tokenization

Did the authors explore dynamic tokenization?

We did not explore dynamic tokenization in this work. We chose fixed byte-level tokenization because it provides a common representation for arbitrary program outputs and enables modality-agnostic evaluation.

Indeed, dynamic tokenization and hierarchical architectures such as H-Net are promising ways to address the limitations of byte-level modeling at larger scales and longer contexts. We view our approach as complementary: self-play offers a promising way to generate training data for such architectures, allowing advances in data generation and sequence modeling to be combined. We have included discussion of this in the conclusion and appendix A.

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

‌This manuscript proposes a self-play pretraining method that generates synthetic data through RL, and without training on natural data. Experiments show cross-modal transfer, predictable scaling laws, and emergent in-context learning.

Critical strengths
  1. This manuscript propose a synthetic data pretraining framework with a well-defined closed loop, and introduced a gradient projection based generator reward.
  2. The generalization across data types in experiments represents a significant contribution to the field.
Critical weaknesses
  1. Overclaim the contribution that obtain general capabillities without using natural data. Experiments do not use natural data to update the weights, but use natural data to select the training config and choose the optimal model (e.g., DCLM and DNA signals).
  2. The defined Gradient-Alignment Reward may have minor flaws. If the gradient generated by a programme is in the opposite direction to the historical learning direction, the reward remains same with the absolute value of the projection. So I wonder if positive learning is not guaranteed.
Questions for authors

‌See weaknesses.

3 comments

We thank the reviewer for their thoughtful questions and for recognizing the broad generalization across data modalities as a significant contribution of our work. Below, we address the reviewer’s comments.

…but use natural data to select the training config and choose the optimal model (e.g., DCLM and DNA signals).

We agree that leakage is in principle a concern. However, we can theoretically bound the total size of this leakage and it is very negligible.

To produce a point on the compute optimal scaling law, we compare across five rungs on our ladder and at each rung we use coordinate descent to choose four hyperparameters (importantly we do this once, for all seeds) and perform six evaluations. We also average ensembles from 1 to 8 seeds. This results in a total of log_2(5 * 6 * 8) \approx 8 bits of information from DCLM leaked into our training procedure. This is astronomically small relative to the number of tokens that models are trained on DCLM (typically on the order of billions to trillions).

The defined Gradient-Alignment Reward may have minor flaws.

We thank the reviewer for their thoughtful analysis. In our submission, we already analyzed the signed dot product that the reviewer suggests, as a candidate reward for our self-play procedure, along with 5 other reward variations. Table 4 shows the results of this ablation, and while signed dot product is competitive for text and coding evals we noticed that it is more noisy seed to seed. We therefore decided to use the absolute value version of the reward.

Thanks to the author for the clarification, which addressed my concerns. I will maintain my positive score.

AuthorsOpenReview ↗

Request to Referee

We thank the reviewer for the quick reply, and we are glad that our clarifications addressed your concerns. Since these were the two weaknesses raised in the review, we wanted to ask whether there is anything remaining that in your view holds the paper back from a higher score. If so, we would be happy to address it during the discussion period. If not, we would be grateful if you would consider updating your rating to reflect that the concerns have been resolved.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.