acceptodds
Under review as a conference paper at ICLR 2027

RBEPO: From Root-Cause Diagnosis to Branching Evolutionary Prompt Optimization

Abstract

With the widespread deployment of large language models in agentic systems and domain-specific tasks, using execution feedback to enable system self-evolution has attracted increasing attention. Automatic prompt optimization provides a lightweight path for systems to continually improve task performance without updating model parameters. However, identifying problems from execution feedback does not necessarily reveal effective repair strategies; joint rewrites across multiple directions obscure the actual effects and reuse potential of individual repairs. We propose RBEPO (Root-cause-guided Branching Evolutionary Prompt Optimization), a prompt optimization framework centered on cross-instance failure modes that jointly organizes targeted branching search and mechanism-level experience accumulation. RBEPO infers repair directions through per-instance error analysis and cross-instance root-cause clustering, generates and evaluates targeted rewrite branches for individual failure modes, and integrates effective, complementary repairs. Building on these evaluated rewrites, the method distills rewrite attempts and their evaluation results into cross-iteration experience to guide subsequent rewrites. To control the resulting candidate-evaluation cost, prompt-edit fragility-guided racing is introduced. Across multiple tasks and models, RBEPO consistently achieves higher test scores than the compared baselines: its average score is approximately 3.35 points higher than that of the strongest baseline in aggregate, while its final prompts are on average only about 1/6 as long. Comparisons of evaluation strategies further show that this strategy reduces the total sample-evaluation volume to about 38% of full evaluation while maintaining performance close to that of full evaluation.

Primary area:
optimization
Keywords:
Automatic Prompt Optimization, Failure-Mode Diagnosis, Branching Search, Experience Reuse, Statistical Early Stopping

Reviews

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

RBEPO optimizes prompts through failure-mode diagnosis, targeted branching, merging of effective repairs, and reuse of editing experience. It also introduces fragility-guided racing, which prioritizes examples historically prone to regression to eliminate unfavorable candidates early. Across four public tasks and two target models, the reported results outperform the compared baselines, while the racing strategy reduces sample evaluations with performance close to full evaluation.

Critical strengths

The paper addresses a worthwhile problem with a coherent design. Connecting failure modes, concrete edits, and observed outcomes is a promising way to guide prompt optimization. The consistently positive results across eight model–task combinations are encouraging. The work also considers both candidate quality and evaluation efficiency, and the comparison with random racing provides useful evidence for exploiting historical regression information.

Critical weaknesses
  1. The individual contributions of the mechanisms are not sufficiently isolated. The cumulative ablations show that simplifying the system reduces performance, but do not clearly separate component effects and interactions. Removing branching also reduces candidate generation and search opportunities, making it difficult to attribute the gain specifically to failure-mode organization. Similarly, the experience-reuse analysis does not establish the additional value of structured mechanism-level experience over simpler historical feedback.

  2. The trade-off between early elimination and overall improvement remains unclear. Prioritizing regression-prone examples can expose harmful edits quickly, but may also discard candidates that lose locally while improving overall. The reported results demonstrate a promising performance–evaluation trade-off, yet provide limited analysis of eliminated candidates and their influence on subsequent search. It is therefore unclear how much efficiency comes from identifying poor candidates versus restricting exploration more conservatively.

Questions for authors
  1. Can representative optimization trajectories show how failure modes and accumulated experience change subsequent edits, and what they contribute beyond ordinary feedback summaries?
  2. Can a sample of eliminated candidates be fully evaluated to assess whether useful overall improvements are missed and how such eliminations affect the final search outcome?
3 comments
AuthorsOpenReview ↗

Response to Reviewer Jwpf (Part 1 of 2)

Thank you for recognizing the value of our research question and our design linking failure modes, concrete edits, and observed outcomes. Below, we address your questions about mechanism contributions and the final search outcome through optimization trajectories, follow-up evaluations of eliminated candidates, and candidate comparisons.

Question 1: Mechanism-Level Experience for Guiding Subsequent Edits

In RBEPO, diagnosis and branching-based optimization make explicit the problem targeted by each rewrite, the concrete edits, and their gains and regressions. We further organize this information into problem mechanisms, rewriting strategies, improvements, and negative effects, distilling structured mechanism-level experience for subsequent edits. Ordinary feedback summaries can also contain this information; our design emphasizes explicitly linking and organizing it, so that experience distillation follows naturally from branching-based rewriting and validation and provides a basis for subsequent optimization.

Example: FinQA (qwen3.8-27b). This example shows how experience from an unselected rewrite is distilled and used to guide subsequent optimization. The parent–child and experience-reuse relationships among the versions are shown below:

v2: shared parent prompt
├─→ v5: fixes percentage output and becomes the current best prompt
│    └─→ v8: uses v5 as its parent prompt and experience from v7 to further repair nested calls
│
└─→ v7: rewrites the prompt to address nested calls
     ├─ Eliminates nested outputs on the evaluated examples, but causes more regressions than repairs
     └─ Distilled experience ──→ guides the generation of v8

Here, the unselected v7 still provides reusable experience. Table R1 presents its target problem, rewriting strategy, validation results, and analysis of regression causes.

Table R1: Experience distilled from the v7 rewrite (FinQA, qwen3.8-27b, the same 416 DEV examples for v2 and v7). Repairs and regressions are measured relative to the parent prompt v2.

CategoryContent
Problem mechanismThe “nested function calls” error cluster: the model expresses intermediate computations as nested calls, such as divide(subtract(a, b), b), rather than decomposing them into flat steps and referencing intermediate results with #N.
Rewriting strategyAdd program-format rules that prohibit nested calls, provide correct and incorrect examples, and require every intermediate result to be assigned a #N reference and used in a subsequent step.
ImprovementsNested programs decrease from 33 to 0; 6 of the 9 evaluated examples in the target cluster are repaired; 45 examples are repaired overall among the same 416 examples.
Negative effectsObserved effects: 57 regressions; in 51 of these cases, multiply(#N, 100) or multiply(#N, 1000) was appended to a program that v2 had produced correctly.<br>Mechanism analysis: The mandatory requirement for “subsequent use” may be applied to final results as well, treating already-computed final results as intermediate results that must be referenced again and thereby inducing unnecessary scaling steps.

In the next round, v5 serves as the parent prompt, while v7 supplies the experience. Building on the parent's existing convention for percentage outputs, v8 adds rules for decomposing computations and referencing results, states that subsequent steps can use these results, and includes correct multi-step examples.

On the full DEV set, v8 repairs 82 examples and introduces 2 regressions relative to v5, raising the score from 57.2 to 73.2 and eliminating nested programs.

Table R2: Results of the subsequent edit (FinQA, qwen3.8-27b, the full set of 500 DEV examples). Repairs and regressions are measured relative to the parent prompt v5.

VersionDEV (0–100)Repairs (count)Regressions (count)
v5 (parent prompt)57.2——
v873.2822
AuthorsOpenReview ↗

Response to Reviewer Jwpf (Part 2 of 2)

Question 2: Follow-Up Evaluation of Eliminated Candidates and the Final Search Outcome

An early-eliminated candidate is counted as a “mistaken elimination” if its overall score, after completing evaluation on the full DEV set, exceeds that of its actual parent prompt. For merged candidates, the reference is the strongest actual parent prompt.

Of the 86 eliminated candidates in this follow-up evaluation, 2 meet the above criterion for mistaken elimination, accounting for 2.33%. In the full optimization comparison, the four-task average TEST scores without racing and with fragility-guided racing are 68.27 and 67.61, respectively.

Table R3: Final TEST scores and follow-up evaluations of candidates eliminated by fragility-guided racing (qwen3.8-flash, scores on a 0–100 scale).

TaskTEST without racingTEST with fragility-guided racingEliminated candidatesMistakenly eliminated candidatesMistaken elimination percentage
finqa75.6074.002414.17%
hupd49.0048.002100.00%
ecthr_a77.4978.252200.00%
hotpot_qa71.0070.201915.26%
Average / Total68.2767.618622.33%

Candidate Counts and Branching Ablation

Thank you for suggesting comparisons with the same number of candidates. All settings in the original ablation use a total of 30 proposals. Settings with branching run for 10 rounds with 3 candidates per round; settings without branching run for 30 rounds with 1 candidate per round. We add the round and proposal counts to the original ablation table below.

Table R4: The original cumulative ablation, with round and proposal counts added (qwen3.8-flash, TEST, 0–100 scale). Each row removes the listed mechanism in addition to those removed in the preceding row.

Variantfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse73.4046.6077.0269.2066.561030
− branching and merging72.8044.6076.1567.6065.293030
− structured diagnosis69.6043.0075.3765.4063.343030

In addition, with both diagnosis and experience disabled, we compare two settings: 3 candidates per round for 10 rounds, and 1 candidate per round for 30 rounds. With the same total of 30 proposals, the two settings achieve similar four-task average performance.

Table R5: Supplementary candidate-generation comparison (qwen3.8-flash, TEST, 0–100 scale).

Settingfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse − diagnosis (3 candidates per round)71.2041.2075.0067.2063.651030
− experience reuse − diagnosis − branching and merging (1 candidate per round)69.6043.0075.3765.4063.343030

Summary

We have added candidate comparisons, an experience-reuse example, follow-up evaluations of eliminated candidates, and a performance comparison with and without racing. Thank you for your suggestions. We hope these clarifications and supplementary results address your main concerns, and respectfully ask you to reconsider your assessment and rating of the paper in light of this information. If you have any remaining questions, please let us know; we would be happy to provide further clarification.

Thank you for additional experiments, clarification and cases study. The response addresses several of my concerns (W1, W2, Q2), and the case study illustrates how feedback from earlier edits can guide later ones. However, it remains unclear whether a simple summary of the same edit history would perform as well as proposed structured approach. So I will maintain my score.

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

The paper presents RBEPO, which improves prompts by finding common patterns in errors and trying a separate rewrite for each pattern. It combines useful changes and keeps a record of what worked to guide later edits. To save evaluation effort, it tests examples that have been sensitive to earlier changes first. Results on four tasks and two models show higher scores and shorter prompts than the baselines, while early stopping reduces evaluation calls at a small average performance cost.

Critical strengths
  1. Keeping track of both successful and unsuccessful edits gives later rewrites useful feedback beyond a single score.
  2. The shorter prompts are an appealing result, especially since the paper also compares with GEPA which does not add demonstrations.
Critical weaknesses
  1. It is hard to tell which change explains the drop since the method also tries fewer candidates when branching is removed. I am also unsure how reliable the smaller gains are without results from repeated searches.
  2. The paper leaves out the prompts and implementation details needed to reproduce the optimizer. It is also hard to compare overall efficiency when the methods use different settings and the cost of diagnosis and experience updates is not reported.
Questions for authors
  1. Would the branching advantage remain if the control tried the same number of ordinary rewrites with the same budget?
  2. How many times was each experiment run, and how much did the results vary? Please also give uncertainty estimates for the test-score differences.
  3. Could you share the optimizer prompts and implementation details, with an example showing how a past edit guides a later one? A breakdown of evaluation calls and optimizer token use would also help clarify the cost comparison.
2 comments
AuthorsOpenReview ↗

Response to Reviewer NsBH (Part 1 of 2)

Thank you for recognizing the value of using experience from successful and unsuccessful edits to guide later rewrites, and for your positive assessment of our results on prompt conciseness. Below, we address your questions about candidate counts, result variability, implementation details, and cost reporting.

Question 1: Candidate Counts and Budgets in the Branching Comparison

Thank you for suggesting comparisons with the same number of candidates. All settings in the original ablation use a total of 30 proposals. Settings with branching run for 10 rounds with 3 candidates per round; settings without branching run for 30 rounds with 1 candidate per round. We add the round and proposal counts to the original ablation table below.

Table R1: The original cumulative ablation, with round and proposal counts added (qwen3.8-flash, TEST, 0–100 scale). Each row removes the listed mechanism in addition to those removed in the preceding row.

Variantfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse73.4046.6077.0269.2066.561030
− branching and merging72.8044.6076.1567.6065.293030
− structured diagnosis69.6043.0075.3765.4063.343030

In addition, with both diagnosis and experience disabled, we compare two settings: 3 candidates per round for 10 rounds, and 1 candidate per round for 30 rounds. With the same total of 30 proposals, the two settings achieve similar four-task average performance.

Table R2: Supplementary candidate-generation comparison (qwen3.8-flash, TEST, 0–100 scale).

Settingfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse − diagnosis (3 candidates per round)71.2041.2075.0067.2063.651030
− experience reuse − diagnosis − branching and merging (1 candidate per round)69.6043.0075.3765.4063.343030

Question 2: Repeated Runs and Result Variability

We report additional runs of RBEPO and CAPO with three random seeds each on qwen3.8-flash. Within each method, the three runs differed only in the random seed; all other experimental settings were identical.

Averaged over the three random seeds, RBEPO achieves higher TEST scores than CAPO on all four tasks, with a 3.36-point improvement in the four-task average. These repeated runs provide supplementary evidence for the repeatability of the performance advantage.

Table R3: TEST results with three random seeds, reported as mean ± sample standard deviation (qwen3.8-flash, 0–100 scale).

Methodfinqahupdecthr_ahotpot_qaAvg
CAPO72.27 ± 1.1741.07 ± 1.1575.33 ± 1.8068.27 ± 0.5064.23 ± 0.67
RBEPO74.47 ± 0.9948.00 ± 1.2077.82 ± 0.3970.07 ± 0.8167.59 ± 0.35
RBEPO − CAPO+2.20+6.93+2.49+1.80+3.36
AuthorsOpenReview ↗

Response to Reviewer NsBH (Part 2 of 2)

Question 3: Optimizer Implementation, Editing Example, and Usage Breakdown

Optimizer Prompts and Implementation Details

We will release the full code and run configurations, including the optimizer prompts used for diagnosis, clustering, targeted rewriting, merging, edit-effect analysis, and experience updates, together with the candidate evaluation and racing implementations.

Using Past Edits to Guide Subsequent Rewrites

Example: FinQA (qwen3.8-27b). This example shows how experience from an unselected rewrite is distilled and used to guide subsequent optimization. The parent–child and experience-reuse relationships among the versions are shown below:

v2: shared parent prompt
├─→ v5: fixes percentage output and becomes the current best prompt
│    └─→ v8: uses v5 as its parent prompt and experience from v7 to further repair nested calls
│
└─→ v7: rewrites the prompt to address nested calls
     ├─ Eliminates nested outputs on the evaluated examples, but causes more regressions than repairs
     └─ Distilled experience ──→ guides the generation of v8

Here, the unselected v7 still provides reusable experience. Table R4 presents its target problem, rewriting strategy, validation results, and analysis of regression causes.

Table R4: Experience distilled from the v7 rewrite (FinQA, qwen3.8-27b, the same 416 DEV examples for v2 and v7). Repairs and regressions are measured relative to the parent prompt v2.

CategoryContent
Problem mechanismThe “nested function calls” error cluster: the model expresses intermediate computations as nested calls, such as divide(subtract(a, b), b), rather than decomposing them into flat steps and referencing intermediate results with #N.
Rewriting strategyAdd program-format rules that prohibit nested calls, provide correct and incorrect examples, and require every intermediate result to be assigned a #N reference and used in a subsequent step.
ImprovementsNested programs decrease from 33 to 0; 6 of the 9 evaluated examples in the target cluster are repaired; 45 examples are repaired overall among the same 416 examples.
Negative effectsObserved effects: 57 regressions; in 51 of these cases, multiply(#N, 100) or multiply(#N, 1000) was appended to a program that v2 had produced correctly.<br>Mechanism analysis: The mandatory requirement for “subsequent use” may be applied to final results as well, treating already-computed final results as intermediate results that must be referenced again and thereby inducing unnecessary scaling steps.

In the next round, v5 serves as the parent prompt, while v7 supplies the experience. Building on the parent's existing convention for percentage outputs, v8 adds rules for decomposing computations and referencing results, states that subsequent steps can use these results, and includes correct multi-step examples.

On the full DEV set, v8 repairs 82 examples and introduces 2 regressions relative to v5, raising the score from 57.2 to 73.2 and eliminating nested programs.

Table R5: Results of the subsequent edit (FinQA, qwen3.8-27b, the full set of 500 DEV examples). Repairs and regressions are measured relative to the parent prompt v5.

VersionDEV (0–100)Repairs (count)Regressions (count)
v5 (parent prompt)57.2——
v873.2822

Optimization Performance and Token Usage

Averaged over the two models and four tasks, RBEPO achieves a higher TEST score than the listed baselines; compared with CAPO, the second-best method by TEST score, it reduces total token usage by approximately 70%.

Table R6: TEST scores from the paper's main results table and optimization-stage token usage (equally weighted across qwen3.8-27b and qwen3.8-flash, averaged over four tasks). “—” indicates that the category does not apply; total tokens are the sum of all usage categories.

MethodAvg TEST (0–100)Total tokensTarget-model evaluation tokensPrompt-rewriting tokensDiagnosis tokensExperience-update tokens
MIPRO v264.3626,743,455.1326,379,056.38364,398.75——
GEPA64.1417,685,550.1317,229,041.38456,508.75——
CAPO64.4989,194,134.5089,159,997.2534,137.25——
RBEPO67.8424,122,583.3915,801,761.38647,869.636,829,573.38843,379.00

Summary

We have added candidate comparisons, multi-seed results, an experience-reuse example, and a breakdown of token usage. Thank you for your suggestions. We hope these clarifications and supplementary results address your main concerns, and respectfully ask you to reconsider your assessment and rating of the paper in light of this information. If you have any remaining questions, please let us know; we would be happy to provide further clarification.

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

The paper presents REBPO, a method for prompt optimization. The main motivation is to resolve issues with existing optimizers that often rewrite a prompt after looking at several failures together. The main argument authors use to motivate their method is that rewrite in previous approaches makes several changes simultaneously, hence it becomes difficult to tell which change helped, which caused regressions, and what should be reused later.

REBPO groups failures into recurring error types, generates separate prompt candidates targeting those errors, evaluates the candidates, and combines successful repairs. It maintains a written record of which changes worked or failed. Further reduce evaluation costs, it tests new prompts first on examples that previous rewrites tended to break. The authors also compare their method against several state of the art methods and tasks showing improvements in performance albeit modest in several of them.

Critical strengths
  • The core motivation of the paper is reasonable - it indeed makes sense to target group based issues to avoid regressions. Additionally, and the paper is easy to follow.
  • The method also shows improvements in all cases and on HUPD, it is particularly quite good. However, the absence of multiple seeds is a problem and except HUPD, the gains are relatively modest.
Critical weaknesses
  • The methodological contribution is incremental in my opinion and not very novel. CARO for example already separates error modes and generates targeted and consolidated repairs, GEPA and RPT incorporate complementary search and historical feedback. RBEPO combines these ideas but there is no convincing evidence on why their specific organization is useful.
  • Except HUPD, the gains are marginal and absence of multi seed experiments make it even more harder to quantify the gains.
  • Also, I feel some design choices need better ablation. For example, removing branching also reduces the number of candidate prompts evaluated, so the performance drop could simply reflect less search. I would like to see comparisons with the same number of candidates, especially to understand whether organizing rewrites around distinct failure modes actually helps.
Questions for authors

Please see weaknesses. In particular:

  • Can you please average results on several seeds to know show how stable the method is?
  • Can you please ablate the design more thoroughly as I mentioned in the weakness?
2 comments
AuthorsOpenReview ↗

Response to Reviewer WyMm

Thank you for your positive assessment of our motivation and the paper’s clarity. Below, we address our contribution, result stability, and ablation design.

Methodological Contribution and Overall Design

Our design is inspired by how people iteratively improve complex solutions: identify and separate problems, try changes targeted at specific problems, check whether those changes achieve their intended effects or introduce new problems, integrate effective approaches, and use successes and lessons from failures to guide subsequent improvements. This process both improves the current solution and accumulates experience on how to improve it further.

In prompt optimization, the key is to maintain the connection among repair targets, concrete edits, and observed outcomes. Combining multiple types of repairs in a single rewrite can obscure this connection, making it difficult to assess individual repairs and derive a basis for subsequent edits. We therefore aim to give each rewrite a clear target, so that validation results serve both candidate selection and experience accumulation.

RBEPO organizes iterations around failure modes shared across examples: it generates separate targeted candidates from the same parent prompt, validates edits using improvements on the target problem and effects on other examples, and integrates effective, complementary repairs. It then distills applicability conditions and side effects from repair targets, concrete edits, and observed outcomes to guide subsequent generation. Even when a rewrite is not selected, the ineffective strategies or regression risks it reveals can inform the next round.

Question 1: Repeated Runs and Result Stability

We report additional runs of RBEPO and CAPO with three random seeds each on qwen3.8-flash. Within each method, the three runs differed only in the random seed; all other experimental settings were identical.

Averaged over the three random seeds, RBEPO achieves higher TEST scores than CAPO on all four tasks, with a 3.36-point improvement in the four-task average. These repeated runs provide supplementary evidence for the repeatability of the performance advantage.

Table R1: TEST results with three random seeds, reported as mean ± sample standard deviation (qwen3.8-flash, 0–100 scale).

Methodfinqahupdecthr_ahotpot_qaAvg
CAPO72.27 ± 1.1741.07 ± 1.1575.33 ± 1.8068.27 ± 0.5064.23 ± 0.67
RBEPO74.47 ± 0.9948.00 ± 1.2077.82 ± 0.3970.07 ± 0.8167.59 ± 0.35
RBEPO − CAPO+2.20+6.93+2.49+1.80+3.36

Question 2: Candidate Counts and Branching Ablation

Thank you for suggesting comparisons with the same number of candidates. All settings in the original ablation use a total of 30 proposals. Settings with branching run for 10 rounds with 3 candidates per round; settings without branching run for 30 rounds with 1 candidate per round. We add the round and proposal counts to the original ablation table below.

Table R2: The original cumulative ablation, with round and proposal counts added (qwen3.8-flash, TEST, 0–100 scale). Each row removes the listed mechanism in addition to those removed in the preceding row.

Variantfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse73.4046.6077.0269.2066.561030
− branching and merging72.8044.6076.1567.6065.293030
− structured diagnosis69.6043.0075.3765.4063.343030

In addition, with both diagnosis and experience disabled, we compare two settings: 3 candidates per round for 10 rounds, and 1 candidate per round for 30 rounds. With the same total of 30 proposals, the two settings achieve similar four-task average performance.

Table R3: Supplementary candidate-generation comparison (qwen3.8-flash, TEST, 0–100 scale).

Settingfinqahupdecthr_ahotpot_qaAvgRoundsProposals
Full74.0048.0078.2570.2067.611030
− experience reuse − diagnosis (3 candidates per round)71.2041.2075.0067.2063.651030
− experience reuse − diagnosis − branching and merging (1 candidate per round)69.6043.0075.3765.4063.343030

Summary

We have explained the problem-driven overall design and added multi-seed results and candidate comparisons. Thank you for your suggestions. We hope these clarifications and supplementary results address your main concerns, and respectfully ask you to reconsider your assessment and rating of the paper in light of this information. If you have any remaining questions, please let us know; we would be happy to provide further clarification.

Reviewer_WyMmOpenReview ↗

Response to authors

Thank you for the additional experiments - additional seeds and clarification regarding equal proposal counts.

However, my concern regarding the methodological contribution remains. I understand your motivation quite well but I am not sure if the methodologically is still very novel compared to previous approaches. In particular, CARO already generates and evaluates mode-specific and consolidated repairs, while RPT already combines recurring failure diagnosis with historical reports and revisions.

A very granular difference I notice is perhaps the validation of targeted branches before merging and finally distilling the edits into resuable experience. However, the ablations do not talk about this part and benefits from this. But again, this is a very granular level detail, I still find the method has reasonable overlaps with previous approaches, therefore I wil retain my score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.