acceptodds
Under review as a conference paper at ICLR 2027

Can the Same Generator Be Its Own Corrector without Text Feedback?

Abstract

Text-to-image generators have achieved remarkable visual quality, yet a single generation can still violate the prompt through incorrect counting, attribute binding, or spatial relations. Correcting such errors usually takes more models: a VLM or LLM diagnoses the image and writes an edit instruction, and a separate editor carries it out. An underexplored question is whether the image generator itself can take over this role: rather than treating an imperfect output as terminal, can the same generator interpret it as an intermediate state and move it toward a more prompt-consistent result, without any text feedback? We introduce SelfFix, which learns a prompt-conditioned transition from an initial generation to a selectively corrected one inside the generator itself. SelfFix keeps the generator frozen and adds a lightweight adapter of 37.5M parameters; switching the adapter off recovers the original generator bit for bit, so generation is lossless. Given only the original prompt and the current image, the corrector learns to recognize prompt-image inconsistencies, and a Content-Aware Correction (CAC) module decides for every token whether to preserve the input content or revise it. This correction behavior requires no external LLM or VLM analysis, textual error description, or editing instruction at inference. On GenEval, a single correction raises SANA-1.0-1.6B from 0.66 to 0.77, and with a budget of 20 generator calls SelfFix reaches 0.91, surpassing fine-tuned and VLM-guided reflection baselines under the same budget as well as SANA-1.5-4.8B with Best-of-2048. Training only 2.3% of the parameters, SelfFix also outperforms full fine-tuning of the generator. On Emu Edit, it aligns the image with the target caption better than re-generation, on both Emu Edit and PIE-Bench it preserves far more of the source, and on real photographs it revises only the mismatched object, indicating that the correction transfers beyond the training templates.

Primary area:
generative models
Keywords:
test time refinement, generative models

Reviews

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

This paper proposes SelfFix, a self-correction framework that enables a text-to-image generator to correct its own outputs without external LLM/VLM feedback at inference time. Built on SANA-1.0-1.6B, SelfFix freezes the original generator and trains a lightweight adapter with a Content-Aware Correction (CAC) module to determine which image tokens should be preserved or revised. The training data consists of negative-positive image pairs constructed using detector feedback, GPT-4o, and FLUX.1-Kontext-dev. Experiments show that SelfFix improves GenEval from 0.66 to 0.77 with a single correction and achieves 0.91 under a Best-of-20 setting. Additional experiments on Emu Edit and PIE-Bench demonstrate improved image preservation compared to re-generation.

Critical strengths

Interesting and practical problem. The paper addresses an important problem in text-to-image generation: correcting prompt-image inconsistencies without requiring external LLM/VLM feedback or explicit editing instructions at inference time.

Lightweight and effective design. The proposed CAC module provides a simple mechanism for selectively preserving or revising image content. SelfFix trains only 37.5M additional parameters while keeping the original generator unchanged.

Critical weaknesses
  • Limited generalization evaluation. The training data is constructed from approximately 3.9K GenEval-style prompts, which closely match the evaluation categories. Although test prompts are excluded, the strong GenEval results may partly reflect this task-specific training distribution. While Emu Edit and PIE-Bench provide additional evidence, the comparisons are mainly against re-generation. Experiments on more diverse prompts, benchmarks, or base generators would better demonstrate generalization.

  • Unclear fairness and computational cost of the comparisons. Table 2 compares SelfFix against standalone generators with different training data and inference budgets. In particular, the Best-of-20 result (0.91) depends on an additional candidate selector, but the paper does not clearly specify its implementation or computational cost. Although the authors use the same selector across Best-of-N methods, generator calls alone do not provide a complete measure of inference cost. More detailed reporting of the selection procedure and inference costs would make these comparisons more convincing.

  • Insufficient analysis of content preservation in the training pairs. A corrected image should both satisfy the prompt and preserve the parts of the negative image that are already correct; these are distinct requirements. FLUX.1-Kontext-dev may correct an erroneous object while also changing unrelated regions. If such changes appear in the training targets, SelfFix may learn unnecessary modifications. Section 3.1 and Appendix A describe filtering successful corrections using image-quality metrics, but do not report a dedicated quantitative analysis of content preservation in the correction pairs. Such an analysis would help assess the quality of the supervision for conservative correction.

  • The LoRA-only baseline on a frozen base diverges to NaN during training. However, divergence to NaN demonstrates optimization instability and does not by itself establish insufficient model capacity or the necessity of CAC. Because this baseline is important for isolating the contribution of Content-Aware Correction (CAC), the evaluation would be more convincing if the authors demonstrated that this divergence is not an artifact of the chosen training configuration. It would strengthen the empirical conclusions if the authors tested whether this baseline still diverges after adjusting the learning rate, optimizer settings, gradient clipping, initialization scale, or rank.

  • The "Generative Models" and "Image Modification" subsections in Related Work could be combined and shortened. The saved space could be used to present additional experiments or more detailed ablation studies. I would say the paper is well written but lacks sufficient experiments to substantiate its main claims. (Just a suggestion; no response is necessary.)

Questions for authors

Please see the weaknesses above.

4 comments
AuthorsOpenReview ↗

Response to Reviewer BvC1 (Part 1)

Dear Reviewer BvC1,

We sincerely thank you for your careful review and for recognizing the practical problem and the lightweight design. Your concerns cover generalization, the cost and fairness of the Best-of-20 comparison, preservation inside the training pairs, and whether the LoRA-only result isolates CAC. We now add a benchmark outside GenEval and specify the selector and its cost. We also measure how much each training target changes its negative image. Finally, we retrain the LoRA-only variant (a) with the same recipe as SelfFix. Below, we address each of your concerns in turn.


1. Generalization beyond GenEval-style prompts (W1)

We agree that the training prompts follow GenEval templates. They come from Reflect-DiT, the closest prior work, which also improves SANA-1.0-1.6B at test time by conditioning on its previous outputs. We build on its released data, about 3.9k GenEval-style prompts with generated images and detector feedback (Section 3.1 of the paper). SelfFix, Reflect-DiT and SFT are thus trained on the same data and compared on equal terms (the † rows of Table 2). Every test prompt is filtered out, but the categories are the same, which is why we also test beyond the templates.

Evidence outside the templates. Emu Edit and PIE-Bench use captions written for editing, not GenEval templates, and their source images were not generated by SANA. SelfFix receives only the source image and the target caption there. It moves the image toward the caption while keeping far more of the source than re-generation (Table 4 of the paper). The real photographs in Section 4 show the same behavior.

More benchmarks outside GenEval. On T2I-CompBench (2D spatial, 300 prompts, two seeds, official scorer), one correction raises the score from 0.30 to 0.36. Re-generation at the same budget stays at 0.30. The gain is significant in a paired bootstrap over prompts. Other base generators require new failure data and retraining, which we list as the main next step.

2. Fairness and cost of the Best-of-20 comparison (W2)

Selector. Best-of-N with a verifier is the common form of test-time scaling for text-to-image generators. We follow the protocol of SANA-1.5. All Best-of-N rows that we measured use the same selector, NVILA-Lite-2B-Verifier. It is the public verifier that the SANA authors released for inference-time scaling, and we use it as released. It sees only the prompt and the image and answers "yes" or "no". Candidates are ranked by this answer and its logit, with one pass per candidate. It uses no GenEval feedback, and the GenEval detector scores only the selected image. Reflect-DiT (without †) and SANA-1.5 Best-of-2048 are taken from those papers, as the caption of Table 2 states.

Controlled comparison. The generators at the top of Table 2 of the paper (SDXL, DALLE 3, …) are listed for reference only. The controlled comparison is the SANA-1.0-1.6B block. Every row there uses the same generator, and the † rows also share our training data. At the same budget of 20 generator calls, SANA-1.0-1.6B samples 20 images, while SelfFix samples 10 and corrects each of them once. In both cases, the verifier picks one of the 20 resulting images. With the same verifier, prompts and seeds, the base generator reaches 0.85 and SelfFix 0.91. The selector and the number of calls are identical, so the gain comes from replacing ten new samples with ten self-corrections. The generator judges what in its own image violates the prompt and what to keep. These judgments yield better candidates than sampling again.

Cost beyond generator calls. On one B200 GPU at 1024×10241024\times1024, a generation takes 0.56 s and a correction 1.52 s. The correction is slower because it adds the current image to the token sequence. The common alternative uses a VLM to diagnose the image and a separate editor to carry out the edit. We measured Qwen2.5-VL-7B as the VLM and FLUX.1 Kontext [dev] as the editor on the same GPU. The diagnosis takes 0.40 s and each edit 13.1 s. SelfFix diagnoses and edits in one pass, so its correction is about nine times faster. These two models add 25.16B parameters on top of the generator. Their weights alone take about 50 GB in 16-bit precision, four times the 12 GB peak memory of SelfFix with the generator included.

AuthorsOpenReview ↗

Response to Reviewer BvC1 (Part 2)

3. Preservation inside the training pairs (W3)

We measured how much each training target changes its negative image. As a reference, we pair each negative with another independent sample of the same prompt.

Table 1. Change from the negative image to its target (medians over pairs, at 512 px).

PairLPIPS ↓DINO ↑Changed area ↓
Correction pairs (14,800 training targets)0.370.9334%
Re-generation (same prompt, new sample)0.670.7582%

Targets keep most of the negative image. The training targets keep the content and layout of their negatives (high DINO similarity), far more than an independent sample does. They are not pixel-identical, though, which is why preservation does not rest on the targets alone.

Identity pairs. We add 4,440 identity pairs, in which a correct input must come back unchanged. As Section 4.3 of the paper explains, these pairs teach the model when not to intervene. Within an image that does need revision, CAC keeps the correct regions.

4. The LoRA-only baseline and the role of CAC (W4)

We agree that divergence to NaN does not establish insufficient capacity or the necessity of CAC.

Training stability. The NaN in the paper is what we observed. With the same backbone and training data, (a) diverged in our attempts while SelfFix trained stably. Training without CAC is therefore less robust. To test capacity and the role of CAC directly, we retrained (a) from scratch several times. Under this recipe, (a) completes all 60k steps.

CAC protects correct content. On the same GenEval images, (a) fixes about as many wrong images as SelfFix (32% vs. 34%). But it breaks more correct ones (9% vs. 7%), and its GenEval score is 0.019 lower. Switching CAC off in the trained SelfFix doubles the broken correct images.


5. Related Work (W5)

Thank you for the suggestion. We will merge the "Generative Models" and "Image Modification" subsections and use the space for the analyses above.

Thank you for your response and the additional experiments. They have addressed most of my concerns. However, I will maintain my original score, as I still believe the paper does not meet the acceptance bar for this venue.

Thank you for your kind reply. We are glad that the additional experiments addressed most of your concerns.

Your review raised five specific points, namely generalization beyond the GenEval templates, the fairness and cost of Best-of-20, preservation inside the training pairs, the LoRA-only baseline, and Related Work. Our response answered each of them with new measurements or a concrete revision, and you now consider most of them resolved.

We would therefore be grateful to know which concern remains. Keeping the score without a stated reason leaves us nothing concrete to address. If a specific issue still stands, we would like to address it. If no major issue remains, please reconsider the score in light of the resolved concerns.

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

This paper presents SelfFix, a framework enables a generation-only image model to correct itself using the current image and the original prompt. By including a lightweight adapter with a Content-Aware Correction module, SelfFix identifies prompt–image inconsistencies, corrects relevant content, and preserves unrelated visual information without relying on additional editing instructions. The validation of the proposed SelfFix is demonstrated with a suite of experiments, which shows SelfFix improves the baseline model by a notable margin.

Critical strengths

The presentation of this paper is clear, with enough details to easily understand it. Besides, the idea of correcting the image generator by including a lightweight adapter with a Content-Aware Correction module is interesting. Switching the adapter off recovers the original generator bit for bit, while switching the adapter on in inference performs the generation correction.

Critical weaknesses
  1. Discussion of the related work is limited. There are many works trying on improving image generation ability by self correction or self reflection of the generation model [1,2,3]. These works are expected to detailed discussed, and the difference between these works and the proposed work in this paper needs to be distinguished. Moreover, the advancement of the proposed method over these existing methods should be clearly presented.

  2. The evaluation of the proposed method is inadequate. The proposed SelfFix is compared with some image generation models such as SDXL, DALLE 3, Flux.1-Dev, etc. While more advanced generators should be compared to, such as OmniGen2, BAGEL, Lumina, etc., which achieve much higher GenEval score. Besides, more metrics can be adopted to evaluated the proposed method, such as the Aesthetics score, which can measure if the generated image quality (mainly the appearance and human preference) degrades. Moreover, the inference speed of the proposed SelfFix should be discussed, which is very important for image generation model.

[1] Luo, Yinyi, Hrishikesh Gokhale, Marios Savvides, Jindong Wang, and Shengfeng He. "Self-Corrected Image Generation with Explainable Latent Rewards." 2026.

[2] Wu, Tsung-Han, Long Lian, Joseph E. Gonzalez, Boyi Li, and Trevor Darrell. "Self-correcting llm-controlled diffusion models." 2024.

[3] Guo, Ziyu, Renrui Zhang, Chengzhuo Tong, Zhizheng Zhao, Rui Huang, Haoquan Zhang, Manyuan Zhang et al. "Can we generate images with cot? let's verify and reinforce image generation step by step." 2025.

Questions for authors
  1. The proposed SelfFix framework improves the SANA-1.0-1.6B by a remarkable margin, and the gains come mainly from position and attribute binding. The SANA-1.0-1.6B is a less advanced baseline which achieves only 0.66 GenEval score, and the performance of SANA-1.0-1.6B on position and attribute binding is quite bad. Thus, the proposed SelfFix framework improves the baseline notably. Will the proposed SelfFix improves more advanced baselines, e.g., Lumina, OminiGen2? and how much improvement can be expected?

  2. How much inference time will be increased by including the SelfFix framework? or how will the proposed framework influence the inference time of the baseline model?

  3. With a budget of 20 generator calls, SelfFix reaches 0.91, which is much higher than generating and correcting only one image. Does this mean the proposed SelfFix is unstable?

1 comment
AuthorsOpenReview ↗

Response to Reviewer 87vw

Dear Reviewer 87vw,

We sincerely thank you for your careful review and for finding the idea of a lossless, switchable corrector interesting. Your questions concern related self-correcting generators, inference cost and image quality. You also ask why Best-of-20 scores so much higher than one correction. We measured the inference time and the image quality of SelfFix, and its repair and damage rates over several seeds. Below, we address each of your concerns in turn.


1. Self-correction and self-reflection methods (W1)

Thank you for these references. We will discuss all three in Related Work. SLD uses an LLM with a detector, PARM++ a reward model, and xLARD a separate latent corrector. All three rely on a module outside the generator to diagnose or correct the image. In SelfFix, the generator itself corrects its own image from the original prompt alone. CAC decides for every token whether to keep or revise it.

2. Stronger base generators (W2, Q1)

Why SANA-1.0-1.6B. We follow Reflect-DiT and build on its released prompts, images and detector feedback. SelfFix and the Reflect-DiT and SFT baselines thus share one generator and one training set. The adapter is trained on the weights of one generator and should learn from that generator's own failures. Moving to OmniGen2, BAGEL or Lumina therefore means collecting their failures, rebuilding the correction pairs and retraining. This does not fit into the discussion period, and we list it as the main next step.

Expected gain. A stronger generator leaves fewer wrong images to repair, so we expect a smaller gain. It should concentrate on the categories where the generator still fails, such as position and attribute binding. Because SelfFix rarely damages a correct image (point 5 below), its correction should remain safe to apply on top of a strong generator.

3. Inference time (W2, Q2)

With the adapter off, SelfFix is the original generator bit for bit. Generating an image therefore costs exactly what it did before, 0.56 s on one B200 GPU at 1024×10241024\times1024. A correction runs the same 20 steps and takes 1.52 s, since the current image joins the token sequence. Generation and correction share one set of weights, and peak memory stays near 12 GB.

4. Image quality (W2)

We scored the 553 GenEval images before and after one correction.

Table 1. Image quality before and after one SelfFix correction (means over 553 images).

ImageHPS v2.1 ↑LAION aesthetic ↑CLIPScore ↑
Initial (SANA-1.0-1.6B)30.535.7229.35
After SelfFix30.705.7029.60

Quality is kept. Human-preference and aesthetic scores stay at the level of the initial images, while CLIPScore rises with prompt alignment.

5. Is SelfFix unstable? Best-of-20 vs. one correction (Q3)

Best-of-20 measures selection. Best-of-20 samples ten initial images and corrects each of them once. The verifier then keeps the one of all twenty images it prefers. Its score therefore reflects the best of many attempts, not the reliability of a single one. The base generator shows the same effect. With the same verifier, SANA-1.0-1.6B alone rises from 0.66 with one image to 0.85 with twenty. At the same 20 calls, SelfFix reaches 0.91 by correcting ten of its own images instead of sampling ten more.

Single corrections are stable. We repeated one correction on ten seeds of initial images. The share of wrong images it repairs stays within 0.31–0.41, and the share of correct images it damages within 0.05–0.08.

Correcting again. SelfFix can also correct its own output. Over three seeds, a second correction repairs more of the initially wrong images (0.34 → 0.42) and adds 0.014 GenEval. A third no longer helps, because damage to initially correct images accumulates (0.07 → 0.09 → 0.11). Further calls are therefore better spent on new initial images and selection, which is what Best-of-20 does.

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

This paper addresses post-hoc correction of text-to-image generation results. Generation models often get counts, attributes, and spatial relations wrong, and existing correction methods rely on a pipeline of several models, where a VLM diagnoses the errors and a separate editor fixes them. The paper therefore proposes a method that lets the generator correct its own output by looking only at the original prompt and the current image. The proposed method, SelfFix, trains a small adapter made of LoRA and a Content-Aware Correction (CAC) module on top of a frozen generator, and CAC decides for each token whether to keep the content of the current image or to redraw it. The authors claim that correction is possible with a single model, without a VLM or edit instructions at inference, and that it outperforms larger models and VLM-based correction methods.

Critical strengths
  1. The problem setting and the method are clear and simple. The motivation and the problem analysis on whether the generator itself can correct its output after generation come through well, and the resulting method and its comparison with existing approaches are also clear. The design goal of fixing only part of the input image while keeping the rest consistent made it easy to see why this work is needed.

  2. The experiments are set up well to check the design choices under the same conditions. The paper compares a LoRA-only structure, full fine-tuning, and the proposed structure on the same backbone and the same data, and shows why CAC is needed. The Reflect-DiT and SFT baselines are also retrained on the authors’ data, as an attempt to separate the effect of the data from the effect of the method.

Critical weaknesses

1. The value of this method beyond saving resources is unclear. Compared with existing pipelines that use a VLM for diagnosis and an editor, the only advantage the paper claims is the smaller number of models and parameters. If resources are sufficient, using several strong models together may be a more effective alternative. This is a test-time scaling method, but the paper reports only the performance gain and its cost comparison is weak. Only the number of generator calls is matched, and time or NFE (number of function evaluations) is not reported, so from the current results I cannot tell whether SelfFix is a better method at the same cost or an alternative for when memory is limited. In addition, there has been a lot of work that automatically finds the region to fix and edits only that part [1, 2]. From the paper alone, it is hard to tell how SelfFix fundamentally differs from these methods apart from the input format. Also, there is no result of sampling the base generator 20 times with the same selector, so it is unclear how much of the 0.91 comes from the correction.

2. There is not enough evidence that the correction works properly or that the method performs better. The accuracy with which the model judges what is wrong is not reported. There is no rate of wrong images fixed to correct ones or of correct images changed to wrong ones, and the evidence is only a few examples. More evidence is needed that each module works reliably. The quantitative evaluation is also not enough to support the claims. On GenEval, several works have already reported scores higher than 0.91 [3], so it can be seen as a somewhat saturated benchmark, and the compared models are mostly old. However, there is no comparison with other models or methods on other benchmarks, so it is hard to judge whether the proposed method is a good one. I think it would be good to evaluate whether it outperforms existing methods on more recent and harder image generation benchmarks.

[1] Couairon et al. DiffEdit: Diffusion-based Semantic Image Editing with Mask Guidance. ICLR 2023.

[2] Mirzaei et al. Watch Your Steps: Local Image and Scene Editing by Text Instructions. ECCV 2024.

[3] Liu et al. Flow-GRPO: Training Flow Matching Models via Online RL. NeurIPS 2025.

Questions for authors
  1. How does the method perform against existing pipelines that use a VLM for diagnosis and an editor, at the same cost in time or NFE? Does it have any advantage over such pipelines beyond saving resources?
  2. Apart from the input format, how does it fundamentally differ from existing methods that automatically find the region to fix and edit it [1, 2]?
  3. What is the selector for Best-of-20? Can you compare with sampling the base generator 20 times using the same selector? What happens when N in Best-of-N is varied? Does SelfFix work best at a particular N, or does performance keep increasing as N grows?
  4. What are the rates of wrong images fixed to correct ones and of correct images changed to wrong ones? How much do images that already satisfy the prompt change, and how well do the regions CAC decides to revise match the actual error regions?
  5. (Suggestion) Comparing with other methods on more recent, harder, and more diverse image generation benchmarks would make the advantages of the proposed method clearer.
6 comments
AuthorsOpenReview ↗

Response to Reviewer DntA (Part 1)

Dear Reviewer DntA,

We sincerely thank you for your detailed review and for recognizing the clarity of the setting and the controlled ablations. Your central question is whether SelfFix is useful beyond saving parameters. SelfFix is a single model that generates, diagnoses and corrects. On the same images, it repairs almost five times as many errors as a VLM + editor pipeline (point 1). Below, we address each of your concerns in turn.


1. Cost, and value beyond saving resources (W1, Q1)

The review suggests that, given enough resources, combining several strong models may be more effective. Our measurements show the opposite. We ran the VLM + editor pipeline (Qwen2.5-VL-7B diagnosis, FLUX.1 Kontext [dev] edit) on exactly the initial images that SelfFix corrects.

Table 1. One correction of the same 553 initial images (GenEval).

CorrectorExtra parameters ↓Repair ↑Damage ↓
Qwen2.5-VL-7B + FLUX.1 Kontext [dev]25.16B0.070.00
SelfFix37.5M0.330.08

The bottleneck is diagnosis, not compute. The pipeline repairs 7% of the wrong images. SelfFix repairs 33%, almost five times as many. The VLM declared three quarters of the wrong images correct, so the pipeline never touched them. The pipeline rarely edits at all, which also explains its zero damage. SelfFix repairs a third of exactly these images, which alone is more than three times all repairs of the pipeline. An error that the VLM cannot put into words is never fixed, however strong the editor.

One model generates, diagnoses and corrects. This is what SelfFix offers beyond saving resources. The pipeline needs three models (Table 1 of the paper), and SelfFix is one. With the adapter off, it is the original generator. With the adapter on, the same model judges what in its own image violates the prompt and revises it while keeping the rest. Its diagnosis is not limited to what a VLM can put into words, which is why it fixes errors that Qwen2.5-VL-7B misses. It also returns about a fifth of the correct images unchanged, against none for re-generation (Table 3). SelfFix is therefore not a cheaper approximation of the pipeline. It succeeds where the pipeline fails.

Cost. On one B200 GPU at 1024×10241024\times1024, a SelfFix correction takes 1.52 s with 20 steps (NFE 20). Peak memory stays near 12 GB. On the same GPU, Qwen2.5-VL-7B takes 0.40 s to diagnose an image, and FLUX.1 Kontext [dev] takes 13.1 s for each edit. A SelfFix correction is therefore about nine times faster than a diagnosis plus an edit.

2. Difference from DiffEdit and Watch Your Steps (W1, Q2)

Thank you for these references. We will discuss both in Related Work.

What is given. DiffEdit derives its mask by contrasting noise predictions under a reference text and a query text. Watch Your Steps derives its relevance map by contrasting an editor's predictions with and without the edit instruction. In both, the change is specified in text before editing begins. SelfFix receives only the original generation prompt, which the image already partly satisfies. There is no second text to contrast, so SelfFix must itself decide whether the image violates the prompt and where.

Deciding inside one pass. For an image that already satisfies its prompt, the right output is the input itself. A mask-based editor always carries out the edit it is given, whereas SelfFix learns from identity pairs to leave such images unchanged. CAC makes this keep-or-revise decision for every token, inside the same pass that produces the correction. There is no separate masking stage and no inversion.

AuthorsOpenReview ↗

Response to Reviewer DntA (Part 2)

3. Selector, same-selector Best-of-20 and varying N (W1, Q3)

Selector. Best-of-N with a verifier is the common form of test-time scaling for text-to-image generators. We follow the protocol of SANA-1.5. The selector is NVILA-Lite-2B-Verifier, the public verifier released by the SANA authors for inference-time scaling, used as released. It sees only the prompt and the image and answers "yes" or "no". Candidates are ranked by this answer and its logit, with one pass per candidate. It uses no GenEval feedback, and the GenEval detector scores only the selected image.

Table 2. GenEval of Best-of-N with the same selector, prompts and seeds. SelfFix spends N/2 calls on generation and N/2 on correction, and the verifier selects among all N candidates of Algorithm 1.

Generator calls N481620
SANA-1.0-1.6B, Best-of-N0.790.820.840.85
SelfFix0.820.860.910.91

SelfFix leads at every N. Both curves rise with N and flatten towards N = 20, so SelfFix does not depend on one particular N.

Without a selector. Extra calls can also go to correcting SelfFix's own output again, with no verifier at all. Over three seeds, a second correction adds 0.014 GenEval to one correction. A third adds nothing because damage to correct images accumulates. Beyond two corrections, the budget is better spent on new initial images and selection, as in Algorithm 1.

4. Repair and damage rates, changes to correct images, and localization (W2, Q4)

All methods start from the same initial images of the frozen generator, which the GenEval detector judges as correct (C) or wrong (W).

  • Repair = P(C after | W before). Damage = P(W after | C before).
  • Unchanged = share of correct images with LPIPS(before, after) ≤ 0.05.

Table 3. Paired rates on the 553 GenEval prompts, same initial images, pooled over three seeds.

MethodRepair ↑Damage ↓Unchanged ↑
Re-generation (new seed)0.270.150%
SelfFix0.340.0720%

Repair and damage. SelfFix repairs more wrong images than re-generation and damages about half as many correct ones. Over ten seeds, its repair and damage rates stay within 0.31–0.41 and 0.05–0.08. Switching CAC off at inference doubles damage to 0.16, as high as re-generation.

5. Harder benchmarks and GenEval saturation (W2, Q5)

Why GenEval. We agree that GenEval alone is not enough. We use it because its detector gives a verdict for every image, which the paired analysis of Table 3 requires. Flow-GRPO raises the score by fine-tuning the generator with reinforcement learning. SelfFix leaves the generator unchanged and could correct the outputs of such a generator as well.

Other benchmarks. Beyond GenEval, the paper evaluates instruction-free editing on Emu Edit and PIE-Bench and corrections of real photographs. We also ran T2I-CompBench. One correction raises the score from 0.30 to 0.36, while re-generation at the same budget stays at 0.30. The gain is significant in a paired bootstrap over prompts.

Reviewer_DntAOpenReview ↗

Response to Authors

Thank you for running so many experiments in a short time. Thanks to the cost analysis, the comparison with Best-of-N using the same selector, and the analysis of the repair, damage, and unchanged rates, some of my concerns are now resolved. However, the following points remain.

First, there is not enough analysis of whether the proposed components work as intended. The unchanged rate is only an outcome, and there is no analysis of how well the model learns from the identity pairs when not to correct. I also asked how well the regions that CAC decides to revise match the actual error regions, but this is not reported. So it is still hard to judge how well each contribution works at the level of its mechanism, not only its final numbers. As for the difference from existing mask-based editing methods, the explanation in the response is conceptual and is not supported by experiments. It is therefore still unclear what the contribution is beyond the input format.

Second, the comparison with the VLM pipeline looks like a problem that would naturally go away as the diagnosis VLM gets stronger. The experiment used only Qwen2.5-VL-7B, and I think this alone is not enough to support the claim that SelfFix is more effective than combining several strong models. The cost comparison should also take into account that SelfFix requires training. In addition, a fair comparison on datasets outside the distribution of the training data would make the results more reliable.

Third, the 0.77 in Table 2 does not seem to match the repair and damage rates in the response. Accuracy after correction is accuracy before correction × (1 − damage) + (1 − accuracy before correction) × repair. Plugging in 0.66, repair = 0.34, and damage = 0.07 gives about 0.73. If I have misunderstood something, please let me know where my mistake is.

Fourth, many recent models already reach high scores on GenEval, so I think this benchmark alone is not enough to show the effect of the method. Only the 2D spatial result is reported for the newly added T2I-CompBench (according to the response to Reviewer BvC1), so the result is not sufficiently reliable. It would be good to see the results on the other sub-categories as well.

If these concerns are not addressed, it will be difficult for me to raise my score.

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

This paper asks whether an image generator can correct prompt violations using only the original prompt and its current image, without textual diagnostic feedback at inference. SelfFix freezes SANA-1.0-1.6B and trains approximately 37.5M adapter parameters, including a Content-Aware Correction (CAC) module. Training pairs are constructed offline using detector feedback, GPT-4o, and FLUX Kontext, with additional positive identity pairs intended to teach preservation. The paper reports a GenEval improvement from 0.66 to 0.77 after one correction and a Best-of-20 score of 0.91, compared with 0.87 for an SFT baseline, together with instruction-free editing and content-preservation results.

Critical strengths
  1. The problem formulation is meaningful. Correcting a partially successful generation can reuse existing content and potentially reduce dependence on a separate runtime diagnosis-and-editing stack. The distinction between an original target prompt and an explicit edit instruction is worth studying.
  2. The system design is practically attractive. A frozen backbone with lightweight adapters is an appealing implementation. Combining correction pairs with identity pairs also provides a concrete mechanism for learning to revise errors while preserving correct content.
  3. The evaluation goes beyond one aggregate score. The reported improvements cover counting, color, position, and attribute binding, while Emu Edit, PIE-Bench, and real-image examples explore applications beyond GenEval templates.
Critical weaknesses
  1. The Best-of-20 selector is insufficiently specified, affecting interpretation of both the results and system cost. Algorithm 1 allocates ten calls to initial generation and ten to correction, but the final result also depends on the unspecified selector s(x,c). Its model, training source, scoring rule, tie-breaking, and computational cost all affect the interpretation of the 0.91 result. In particular, it is important to clarify whether candidate selection uses GenEval evaluation feedback. The scope of “the same selector” should also be explicit: which rows are evaluated locally with this rule, and which are historical results? Historical Reflect-DiT and SANA scores should not automatically be interpreted as having undergone a new common selection procedure. A single correction may require no external diagnostic model, but whether that statement applies to the complete Best-of-N system depends on the selection stage.
  2. The current evidence does not fully establish the central claim of reliable correction with preservation. The paper claims not only improved prompt alignment, but also the ability to make appropriate local changes and avoid unnecessary intervention when an input is already correct. Marginal accuracy before and after correction does not reveal how many incorrect images were repaired or how many initially correct images were damaged. The same net gain can arise from substantially different repair and damage rates. I would therefore find paired statistics on the same initial images particularly informative, including correct→correct, correct→incorrect, and incorrect→correct transitions, as well as preservation on held-out initially correct images. The re-generation comparison in Table 4 supports the benefit of using the source instead of redrawing the image, but re-generation does not itself condition on the source. A source-conditioned baseline with the same available inputs would provide a more discriminating test of preservation.
Questions for authors
  1. What is the exact implementation of s(x,c), which experimental rows use it, and does it require an additional model or evaluation feedback? How is its cost accounted for in the full-system comparison?
  2. What are the repair and damage rates on paired initial and corrected images? How often does SelfFix unnecessarily alter an already correct image, and how does it compare with a suitable source-conditioned baseline?
  3. Is 0.66 measured on the same initial images that produce the 0.77 correction result? Please specify the base checkpoint and aggregation protocol so that the improvement can be interpreted on the same evaluation population.
1 comment
AuthorsOpenReview ↗

Response to Reviewer khVs

Dear Reviewer khVs,

We sincerely thank you for your careful review and constructive suggestions. We now specify the selector and the rows that use it. We also ran Best-of-N with the base generator alone, using the same verifier. This separates the gain of correction from the gain of selection. Finally, we report paired repair and damage rates on the same initial images, against re-generation and a source-conditioned baseline. Below, we address each of your concerns in turn.


1. The selector s(x,c)s(x,c) in Best-of-20 (W1, Q1)

A standard selector. Best-of-N with a verifier is the common form of test-time scaling for text-to-image generators. We follow the protocol of SANA-1.5. ss is NVILA-Lite-2B-Verifier, the public verifier that the SANA authors released for inference-time scaling. It also produces the SANA-1.5-4.8B Best-of-2048 row of Table 2. We use it as released. It sees only the original prompt and one image and answers "yes" or "no" to whether they match. The candidates of Algorithm 1 are ranked by this answer and its logit. It never sees the GenEval detector, which scores only the selected image.

Same budget, same selector. Both methods spend 20 generator calls. SANA-1.0-1.6B samples 20 images, while SelfFix samples 10 and corrects each of them once (Algorithm 1). In both cases, the verifier picks one of the 20 resulting images. With the same verifier, prompts and seeds, SANA-1.0-1.6B reaches 0.85 and SelfFix 0.91. The selector and the number of calls are identical, so the gain comes from replacing ten new samples with ten self-corrections. The generator judges what in its own image violates the prompt and what to keep. These judgments yield better candidates than sampling again.

Scope and cost. In Table 2, SFT†, Reflect-DiT† and SelfFix (Best-of-20) were all selected by us with this verifier. Reflect-DiT (N = 20) and SANA-1.5-4.8B (Best-of-2048) are taken from their papers, as the caption of Table 2 states. We agree that only a single correction is free of external models. Best-of-20 uses the verifier to pick the final image, as every Best-of-N method does. On one B200 GPU, a generation takes 0.56 s and a correction 1.52 s, both with 20 steps. Selection adds one verifier pass per candidate.

2. Paired repair and damage rates (W2, Q2)

For each prompt, the frozen generator (adapter off) produces one initial image, and every method below starts from that image. The GenEval detector judges each image as correct (C) or wrong (W).

  • Repair = P(C after | W before). Damage = P(W after | C before).
  • Unchanged = share of initially correct images with LPIPS(before, after) ≤ 0.05.

Table 1. Paired rates on the 553 GenEval prompts, each method starting from the same initial images. SelfFix and re-generation are pooled over three seeds of initial images, and SDEdit uses one of them. SDEdit receives the initial image and the original prompt, with no diagnosis.

MethodUses the imageRepair ↑Damage ↓Unchanged ↑
Re-generation (new seed)✗0.270.150%
SDEdit, same generator (strength 0.5)✓0.080.042%
SelfFix✓0.340.0720%

Only SelfFix both repairs and preserves. Re-generation repairs and damages about equally, so it gains nothing on average. SDEdit with the same generator keeps the layout of the initial image, so it rarely breaks a correct image. But it repairs only 0.08 of the wrong ones and leaves almost no correct image unchanged. SelfFix repairs four times as many, keeps damage below 0.10, and returns a fifth of the correct images unchanged. Over ten seeds, its repair rate stays within 0.31–0.41 and its damage rate within 0.05–0.08.

Role of CAC. Switching CAC off at inference keeps the same adapter and the same inputs. Damage then doubles to 0.16, as high as re-generation, and no correct image stays unchanged. A model retrained without CAC under the same recipe also damages more correct images and is less accurate. Using the source image is therefore not enough by itself. The keep-or-revise decision of CAC is what keeps correct content from being broken.

3. Same initial images and protocol (Q3)

Base checkpoint and population. The 0.66 in Table 2 is the published SANA-1.0-1.6B score, not a separate run on our initial images. The initial images come from the base checkpoint (Sana_1600M_1024px_MultiLing). SelfFix with the adapter off reproduces this checkpoint bit for bit, and each correction is applied to exactly these images. Measured directly, they score 0.65 ± 0.01 across ten seeds, so the published value represents the population that SelfFix corrects.

Aggregation. We use one image per prompt and the official GenEval score, the mean of the six task accuracies.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.