- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper proposes Reflective Masking (RM), a post-training framework that allows mask diffusion models (MDMs) to revisit previously revealed tokens. At each denoising step, a visible token is re-masked when the model assigns a higher probability to MASK than to the current token, while masked positions are filled with a predicted vocabulary token. The method trains this behavior using synthetic revision trajectories and oracle labels derived from target sequences. The paper further introduces History Reference (HR), which aggregates embeddings of previous denoising states using relative-distance rotations and temporal decay, and uses the resulting history-aware representation to condition the model. The paper provides a Bayes-consistency argument for predicting oracle revision actions, a plug-in excess-risk bound, and an information-monotonicity proposition for adding history. Experiments cover instruction-based image editing with Lumina-DiMOO, Sudoku correction with a small custom model, and text tasks using LLaDA. The reported results improve over base-model and vanilla-SFT baselines on the selected tasks. The paper positions RM as a lightweight alternative to approaches that add a dedicated remasking policy stream or require larger training pipelines.
Critical strengths
- A simple and interpretable mechanism for in-place revision.
The rule re-masks a visible token when the model assigns greater probability to MASK than to the current token, allowing the existing MDM output distribution to drive revision without introducing a separate policy stream. This is a practical design choice and is easy to understand.
- Evaluation across several task types with useful ablations.
The paper evaluates image editing, Sudoku correction, and text tasks. Reported results include 99.73% edit precision and 73.02% edit coverage for image editing; 93.4% exact Sudoku accuracy for the full RM+HR+decay+HER variant versus 82.4% for RM without HR; and MATH-500 accuracy of 24.8% versus 22.4% for Vanilla SFT, as well as MBPP pass rate of 39.4% versus 30.6%. The paper also studies the accuracy–computation trade-off and the contribution of HR under different corruption proposals.
Critical weaknesses
- The incremental contribution over existing remasking methods is not fully isolated.
Remasking and self-reflective revision have already been explored by methods such as ReMDM (NeurIPS 2025) and RemeDi (ICLR 2026). The paper’s distinctive value appears to be the lightweight post-training recipe and History Reference, rather than the general idea of revisiting committed tokens. However, the direct comparison with RemeDi is limited to MATH-500, where the reported scores are close (24.8% for RM versus 24.4% for RemeDi), and the paper does not provide a broad, compute- and data-matched comparison with existing remasking samplers across its main tasks. The theoretical results also provide limited support for the practical claims: the history monotonicity proposition is a generic “more information cannot worsen Bayes-optimal risk” result, while Theorem 1 assumes a sufficiently rich model family and conditions on an analyst-side variable that contains more information than the compressed representation actually passed to the model. Thus, the paper does not yet establish how much of the gains are uniquely attributable to the proposed RM/HR design.
- The training/evaluation protocol and empirical robustness need clearer validation.
The training procedure constructs histories by independently sampling per-position state transitions. For text, the practical wrong-token proposal is drawn from a frozen model’s top-k predictions on the clean target sequence, which may differ from the correlated error patterns encountered in the model’s own inference trajectories. The paper also states that MBPP is split randomly into 30% training and 70% testing, but does not make clear whether this split is within the official training partition or across the full benchmark; this makes the reported 39.4% difficult to compare with standard MBPP results. Main results are reported without multi-seed variance or confidence intervals, which matters for relatively small gains such as +2.4 percentage points on MATH-500 and +0.4 points over RemeDi. Finally, the submitted code archive lacks a README/environment manifest and a fully self-contained text preprocessing workflow. The code also instantiates a trainable history_output_norm LayerNorm even though HR is described as parameter-free, and the provided text launchers use different history-step defaults for training and evaluation. These details should be clarified for reproducibility and for interpreting the “parameter-free” claim.
Questions for authors
- Comparison and attribution.
Could the authors provide a more direct comparison with an inference-time remasking baseline such as ReMDM, and clarify the exact matching of base checkpoint, decoding budget, and training data when comparing with RemeDi? Which existing ablation best isolates the contribution of the RM decision rule from HR and ordinary task-specific SFT?
- MBPP protocol and uncertainty.
Does the stated 30%/70% MBPP split apply only within the official training split, or is it drawn from the full benchmark? Please clarify the exact data partition and any overlap with the canonical test set. Are multiple seeds or confidence intervals available for MATH-500, MBPP, Sudoku, and the image-editing user-study results?
- Training/inference alignment and HR implementation.
How well do the synthetic, independently sampled histories match the model’s actual inference-time error trajectories? Also, the released code includes a trainable history_output_norm LayerNorm and the provided training/evaluation launchers use different history-step defaults (6 versus 3). Could the authors clarify which settings produced the reported results, in what sense HR is parameter-free, and provide a fully reproducible setup for text preprocessing and training?
4 comments
W1/Q1. Comparison and attribution
Theory. Prop. 9 is only a sanity check that history cannot hurt at the Bayes level, and whether HR helps is left to the experiments (App. B.3). The method relies on Prop. 4 and Theorem 7. By Prop. 4, the minimizer at a visible position is , where is the probability that the current token is correct. Eq. 1 therefore re-masks a token exactly when , which is the Bayes decision on whether it is wrong. The rich-family assumption is the usual one for cross-entropy, and Theorem 7 covers an imperfect model: the excess decision error is at most twice the expected TV distance to the minimizer.
On the analyst-side variable, App. B conditions on , while the model receives . We close this gap with the following result, which we will add to App. B.3.
Proposition. If the history length is smaller than , then for almost every embedding matrix, the accumulated embedding of Eq. 2 uniquely determines the current state and the full history. This also holds when a normalization with non-zero gain is applied, as in App. D.
Hence, conditioning on is equivalent to conditioning on , where is the current state, the earlier states of the trajectory, and the task condition. Theorem 1 therefore applies to the input the model actually receives. The key is the rotation in Eq. 2, which depends on the distance from the current step and works like a time stamp. Two different trajectories give the same input only if the embedding matrix satisfies a linear equation. On the -th rotation block, the coefficient of one token's embedding in this equation is a non-zero polynomial of degree at most , evaluated at . With distinct angles, the equation is non-trivial on at least one block, so such embedding matrices form a measure-zero set. For LLaDA-8B, , far above the history lengths we use. The same argument covers the text implementation, where the history sum is normalized before it is added to the current embedding (see Q3 below).
W2/Q2. MBPP protocol and uncertainty
MBPP split. As described in Sec. 3.3, MBPP is split at random. We take all 974 problems of the full MBPP configuration (Muennighoff/mbpp) and divide them with seed 42 into 30% for training (292 problems) and 70% for testing (682 problems). The two parts are disjoint. Vanilla SFT and RM are trained on the same 292 problems, and LLaDA, Vanilla SFT and RM are evaluated on the same 682 problems, so the MBPP comparison in Tab. 3 is controlled in both training data and evaluation. We will add the seed and the problem counts to Sec. 3.3.
Uncertainty. We report 95% binomial intervals and tests computed from the existing evaluations. On MBPP, RM solves 269 of the 682 test problems and Vanilla SFT 209. The intervals are 39.4 ± 3.7 and 30.6 ± 3.5, which do not overlap, and a two-proportion test gives . This unpaired test is conservative, since both models are evaluated on the same problems. On Sudoku, the full model and RM without HR reach 93.4 ± 2.2 and 82.4 ± 3.3 on the 500 test boards (Tab. 2). On MATH-500, the effect of revision can be measured on the same problems. After reflective revision, 21 problems change from incorrect to correct and none from correct to incorrect, which gives under an exact two-sided sign test. The direction of the effect is also stable across settings. In all four paired runs of Tab. 6, turning revision on with the same checkpoint improves MATH-500 by 2.2–2.6 points. On the larger 5,000-problem Minerva MATH evaluation (App. F), RM improves the aggregate accuracy over Vanilla SFT from 22.62% to 24.10% and is better or equal in all seven subject categories.
W2/Q3. Training–inference alignment and the HR implementation
Synthetic histories and inference-time errors. The synthetic histories target the two main failure modes at inference. The first is a plausible but wrong token, so training wrong tokens are drawn from the frozen backbone's top-50 predictions (App. D). This is closer to inference than uniform wrong tokens and gives 24.8% against 20.0% on MATH-500 (Sec. 3.3). The second is putting back an error that was just erased. The training trajectories contain this wrong token → MASK → gold token path, and with HR the replay-mistake rate on Sudoku drops from 0.57% to 0.03% (Tab. 2). Although targets are built per position, every decision at inference is predicted from the full sequence and history, so corrections remain coupled (Fig. 4). On the model's own inference trajectories, revision turns 21 incorrect MATH-500 answers into correct ones and none in the other direction.
Settings of the reported results. All reported text models are trained with trajectory length T = 6 (train.sh) and decoded with a history window of 3 (eval.sh). The current step is sampled along the six-step trajectory, so training covers histories of different lengths, and the window of 3 lies within this range.
In what sense HR is parameter-free. The aggregation of Eq. 2 has no learned parameters, since the rotations are fixed sinusoidal blocks, the decay is a fixed hyperparameter, and the rotated states are summed. In the text model, the history sum is normalized before it is added to the current embedding, and only the gain and bias of this normalization (history_output_norm) are trained. They amount to 8,192 parameters, about of LLaDA-8B, compared with roughly 0.9B for the policy stream of RemeDi. We will state this in Sec. 2.2.
W2/Q3. Training–inference alignment and the HR implementation
Reproducible setup.
Following the reviewer's suggestion, we provide the complete recipe below, and we will add it to the appendix.
Text recipe (LLaDA, implemented with the dLLM library; the same training recipe is used for MATH-500, MBPP and ARC-Challenge):
| Text | |
|---|---|
| Base model | LLaDA-8B-Instruct, full fine-tuning |
| Training data | MATH: 7,500 training problems; MBPP: a random 30% of the full benchmark (292 of 974 problems, seed 42); ARC-C: training split (1,119 questions) |
| Test data | MATH-500; MBPP: the remaining 70% (682 problems); ARC-C: test split (1,172 questions) |
| Optimizer | AdamW (fused), β₁ = 0.9, β₂ = 0.999, ε = 1e-8, weight decay 0, gradient clipping 1.0 |
| LR schedule | lr 2e-5, cosine decay, warmup ratio 0.1 |
| Precision | bf16, FSDP full-shard |
| Batch and length | batch 2 per GPU, gradient accumulation 4, 2 GPUs (global batch 16); max length 2048 |
| Epochs | 1 |
| Loss | per-position cross-entropy on keep / re-mask / reveal targets (Eq. 4), all weights 1.0 |
| Wrong tokens | sampled from the top-50 predictions of the frozen base model, computed once on the clean target and excluding the target token (App. D) |
| History (HR) | trajectory length T = 6, temporal_history_decay = 0.2, rotary distance encoding (base 10000) |
| Decoding | 0-shot, chat template, lm-evaluation-harness; Eq. 1 applied at every step; cfg scale 0. ARC-C is evaluated forward-only with revision disabled (Sec. 3.3) |
| Decoding length | Tab. 3: generation length 512 in a single block (block size 512). |
| Decoding steps | each step both unmasks and re-masks tokens, so the number of steps is not fixed; decoding stops once the sequence no longer changes |
Sudoku recipe:
| Sudoku | |
|---|---|
| Model | 4-layer Transformer MDM, hidden size 128, 4 heads, MLP ratio 4, dropout 0.1 (0.81M parameters) |
| Data | Ritvik19/Sudoku-Dataset on HuggingFace (about 17M puzzle–solution pairs). Training boards are sampled from its train split; validation and test boards come from its valid split, divided by a fixed hash of each puzzle (2,000 validation and 500 test boards) |
| Stage 1 | 4,000 boards: the dataset's original puzzles, with blank cells as MASK |
| Stage 2 | 8,000 boards: solved boards with 4–20 cells masked and 4–20 cells set to wrong digits |
| Optimizer | AdamW, lr 1e-3, weight decay 1e-4, cosine schedule, batch 16, gradient clipping 1.0, fp32 |
| Loss | cross-entropy over the full board, edited cells weighted 8× |
| History (HR) | T = 6, temporal_history_decay = 0.4, rotary distance encoding, history feature dropout 0.1, trajectory perturbation rate 0.3 |
| Seed | 7 |
| Test | 500 boards: solved boards with injected wrong digits; |
Code. The training and history settings above are those in Text/examples/llada/train.sh and Sudoku/configs/repair_9x9_temporal_rope.yaml, and the submitted eval.sh is set to the Tab. 6 decoding configuration. The public code release will also include a README with the environment setup and the text preprocessing scripts (top-k wrong-token sampling and trajectory construction).
We thank the reviewer 8hnA again for the constructive feedback.
We thank the reviewer 8hnA for the careful assessment, for inspecting our code, and for recognizing the simple and interpretable revision rule and the range of tasks and ablations in our evaluation.
W1/Q1. Comparison and attribution
As the reviewer notes, the distinctive parts of our method are the post-training recipe, which obtains revision from the model's own output distribution without a separate policy (Prop. 4), and HR. The existing ablations attribute the gains to these parts as follows.
Attribution of the gains. Each of the following comparisons changes one factor and keeps the others fixed.
Comparison with inference-time re-masking(ReMDM). Item 1 above is also the most direct comparison with an inference-time re-masking sampler in the paper. RM-off decodes the same checkpoint with LLaDA's standard low-confidence re-masking, and RM-on adds the learned decision of Eq. 1. The gain does not come from extra forward passes. RM-on reaches 22.6% with 132 forward passes when two tokens are revealed per step, and 21.6% with 70 when four are revealed, while RM-off reaches only 20.2% even with 256. ReMDM belongs to the same class of samplers. It returns decoded tokens to MASK with a probability set by a schedule, optionally scaled by their confidence, and the model is not trained to judge whether a committed token is wrong. RM trains this judgment into the model, so ReMDM can also be run on top of an RM model.
RemeDi. The comparison is matched in the base checkpoint and the evaluation. Both methods are built on LLaDA-8B-Instruct, and we evaluate RemeDi's released checkpoint on the same MATH-500 problems with block size 512, our evaluation setting. Training is not matched, because RemeDi is used as released and retraining it on our data would not reflect the method as proposed:
RM reaches comparable accuracy without an auxiliary policy network and with more than 2,000 times fewer training samples. RemeDi generates text only, so it cannot be compared in image editing.