acceptodds
Under review as a conference paper at ICLR 2027

FlashAR: Efficient Post-training Acceleration for Autoregressive Image Generation

Abstract

Large-scale autoregressive models have demonstrated remarkable capabilities in image generation. However, their sequential raster-scan decoding relies on strictly next-token prediction, making inference prohibitively expensive. Existing acceleration methods typically either introduce entirely new generation paradigms that necessitate costly pre-training from scratch, or enable parallel generation at the expense of a training-inference gap or altered prediction objectives. In this paper, we introduce FlashAR, a lightweight post-training adaptation framework that efficiently adapts a pre-trained raster-scan autoregressive model into a highly parallel generator based on two-way next-token prediction. Our key insight is that effective adaptation should minimize modifications to the pre-trained model’s original training objective to preserve its learned prior. Accordingly, we retain the original AR head as a horizontal head for row-wise prediction and introduce a complementary, lightweight vertical head for column-wise prediction. To facilitate efficient adaptation, we branch the vertical head from a pre-final layer rather than the final layer, bypassing the inherent horizontal head bias. Moreover, since horizontal and vertical predictions capture complementary dependencies whose relative importance varies across target positions, we employ a learnable fusion gate to dynamically combine the two predictions at each position. To further reduce adaptation cost, we propose a two-stage adaptation pipeline: the vertical head is first initialized through adaptation from the pre-trained autoregressive model before jointly fine-tuned with backbone to adapt to the new decoding paradigm. Extensive experiments on LlamaGen, GLM-Image and Emu3.5-Image show that FlashAR achieves a 13.03 speedup for generation using approximately 0.05% of its pre-training tokens.

Primary area:
generative models
Keywords:
autoregressive image generation

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

FlashAR converts pretrained raster-order image generators into diagonal-parallel generators through post-training. It retains the horizontal prediction pathway, adds a vertical branch from a pre-final layer, and learns a gate to combine the two predictions. Adaptation first trains the added components and then finetunes the full model. Experiments cover LlamaGen, Emu3.5-Image, and the autoregressive component of GLM-Image.

Critical strengths
  1. The paper demonstrates a substantial speedup against an optimized raster baseline.

  2. Reusing pretrained models makes the approach practically useful. Across four LlamaGen scales, 25 epochs of adaptation improve FID over the original checkpoints and outperform the reported BlockDiffusion results. The branching, gating, and training-schedule ablations provide evidence that the adaptation choices each help.

Critical weaknesses
  1. Diagonal two-direction decoding is inherited from NAR, so the main contribution is how it is adapted to pretrained models. The "naive adaptation" baseline in Figure 4 is not specified precisely enough to establish the gain over a straightforward NAR-style finetuning baseline. The ablations are also confined to LlamaGen-L, leaving the importance of these components in the main 34B experiment untested.

  2. The adaptation cost claim needs better accounting. The paper reports approximately 80K image-text pairs, 50K optimizer steps, and 80M post-training tokens, but does not state the text-to-image global batch size or distinguish unique dataset tokens from total token presentations. Without that distinction, the claim of using a small percent of pretraining tokens is difficult to interpret as a training-cost comparison.

Questions for authors
  1. What exactly changes in the naive-adaptation baseline, including branch placement, attention mask, fusion rule, and training schedule? Is it equivalent to finetuning a NAR-style model from the same raster checkpoint?

  2. Does the 80M-token figure count unique corpus tokens or all tokens processed during optimization? Please report the global batch size, total token presentations, and GPU-hours for both adaptation stages.

2 comments

We thank the reviewer for the positive assessment, supportive rating, and constructive questions regarding the Naive Adaptation baseline specification, 34B component ablations, and token/cost accounting.

Q1: What exactly changes in the naive-adaptation baseline, including branch placement, attention mask, fusion rule, and training schedule? Is it equivalent to finetuning a NAR-style model from the same raster checkpoint? And how do these components perform on the 34B model?

A1: (1) Exact specification of the Naive Adaptation baseline (Fig. 4b): Yes, the Naive Adaptation baseline in Fig. 4(b) is equivalent to fine-tuning a standard NAR-style dual-head model initialized from the pre-trained raster-scan checkpoint. In Fig. 4(b) (evaluated on LlamaGen-L at fixed CFG=1.5 after 25 epochs), each variant modifies one component at a time:

Variant in Fig. 4(b)Branch PlacementAttention MaskLogit FusionAdaptation ScheduleFID (CFG=1.5) ↓
Naive AdaptationFinal (m = 24, no V-block)Anti-diagonalUniform (g = 0.5)1-Stage (25 ep)4.36
+ Upper BranchPre-final (m = 23, +V-block)Anti-diagonalUniform (g = 0.5)1-Stage (25 ep)4.16
+ Fusion GatePre-final (m = 23, +V-block)Anti-diagonalLearned Gate gp,qg_{p,q}1-Stage (25 ep)4.12
FlashAR (Full)Pre-final (m = 23, +V-block)Anti-diagonalLearned Gate gp,qg_{p,q}2-Stage (5 + 20 ep)3.98

At CFG=2.0, full FlashAR reaches FID 3.16. We will add this explicit specification to Section 4.3.

(2) Component ablations on Emu3.5-Image-34B (L=64L=64): To verify the importance of our design choices on the 34B T2I backbone, we ablate the branch point mm and the auxiliary directional loss weight λaux\lambda_{\mathrm{aux}} on Emu3.5-Image using PickScore [1]:

Branch point m (Emu3.5-34B)m=48m=56m=60 (Pre-final, Default)m=64 (Final Layer, NAR-style)
PickScore ↑0.21840.22610.22620.2196
Auxiliary weight λaux\lambda_{\mathrm{aux}} (Emu3.5-34B)0.000.010.05 (Default)0.10
PickScore ↑0.18370.22520.22620.2251

Consistent with LlamaGen-L, attaching the vertical head directly to the final layer (m=64m=64) or removing the auxiliary directional supervision (λaux=0\lambda_{\mathrm{aux}}=0) substantially degrades performance on Emu3.5-Image. We will include these 34B ablations in the revised manuscript.

Q2: Does the 80M-token figure count unique corpus tokens or all tokens processed during optimization? Please report the global batch size, total token presentations, and GPU-hours for both adaptation stages.

A2: Thank you for pointing out this important distinction. The 80M tokens figure reported in the paper counts unique corpus visual tokens (∼80,000 unique image-text pairs×1,024 visual tokens/image≈81.92M\sim 80{,}000 \text{ unique image-text pairs} \times 1{,}024 \text{ visual tokens/image} \approx 81.92\text{M} unique visual tokens at 512×512512\times 512 resolution, corresponding to 0.05%0.05\% of Emu3.5's 150B150\text{B} pre-training tokens). Below we report the complete accounting across both adaptation stages, including the global batch size, total token presentations, peak GPU memory, and GPU-hours:

Accounting MetricStage 1 (Frozen-Backbone Warm-up, 20%)Stage 2 (Full-Model Joint Adaptation, 80%)Total Adaptation (Stage 1 + Stage 2)
Unique Corpus Size~80K pairs (~81.92M visual tokens)~80K pairs (~81.92M visual tokens)~80K unique pairs (~81.92M unique visual tokens)
Global Batch Size (GBS)8 (1 sample/GPU × 8 GPUs)8 (1 sample/GPU × 8 GPUs)8 (8,192 visual tokens/step)
Optimizer Steps10,000 steps (~1 epoch)40,000 steps (~4 epochs)50,000 steps (~5 epochs total)
Total Visual Token Presentations81.92M visual tokens327.68M visual tokens409.60M (≈ 0.41B) visual token presentations
Total Token Presentations (incl. Text Prefix)~92.16M tokens~368.64M tokens~460.80M (≈ 0.46B) total token presentations
Trainable Parameters3.41B (9.1% of total)37.51B (Base 34.10B + Added 3.41B)37.51B
Wall-Clock Hours & GPU-Hours (8×B200)3.07 hrs / 24.5 GPU-hrs12.87 hrs / 102.9 GPU-hrs15.94 hrs / 127.5 GPU-hrs
Peak Allocated GPU Memory / GPU39.07 GiB (54.02 GiB res)61.49 GiB (84.67 GiB res)61.49 GiB

Even when measured by total visual token presentations (409.6M409.6\text{M} tokens across 50,000 steps at Global Batch Size = 8), our post-training budget represents only 0.27% of Emu3.5's 150B pre-training token budget (and 0.05% in unique corpus tokens). We will explicitly report both unique dataset tokens and total token presentations alongside the global batch size and GPU-hours in the revised manuscript.

Reference:

[1] Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation

Reviewer_rdzWOpenReview ↗

Response to Rebuttal

Thanks for the answers and new experiments. The baseline details and training costs clear up most of my questions. Please make it clear that 0.05% counts unique tokens, not all tokens used during training. The 34B tests help, but gating and the two-stage training are still not tested separately there. I will keep my score at 3.

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

FlashAR converts pretrained raster-scan autoregressive image models into parallel generators through horizontal and vertical prediction with learnable fusion. Its two-stage post-training procedure substantially accelerates decoding while largely retaining generation quality.

Critical strengths
  • FlashAR achieves substantial practical acceleration across multiple pretrained autoregressive image models, including over (13×)(13\times) speedup on Emu3.5-Image while largely preserving generation quality.

  • The post-training approach requires substantially less data and optimization than training a parallel autoregressive model from scratch, making it practical for adapting existing large-scale models.

Critical weaknesses
  • The main architecture closely overlaps with prior work: NAR already uses horizontal and vertical decoding heads for parallel generation, while ZipAR adapts pretrained raster-order models for inter-row parallel decoding. FlashAR’s distinct contribution therefore appears mainly limited to branch placement, learned fusion, and the adaptation recipe.

  • No direct comparison with ZipAR is provided, making it difficult to determine whether full-model post-training offers sufficient benefits over a training-free alternative. Moreover, the absolute cost of adapting the 34B model is not reported despite the “lightweight” characterization.

  • Parallel decoding assumes conditional independence among tokens within each anti-diagonal. This changes the dependency structure learned during raster-scan pretraining and causes measurable degradation in fine-grained alignment, including color-attribute binding on Emu3.5 and GLM-Image (for example, color_attr drops from 70.25 to 64.00 in Table3).

Questions for authors
  • Could the authors clarify the distinction between FlashAR and the closely related ZipAR and NAR methods, particularly regarding pretrained-model reuse and horizontal/vertical parallel decoding?

  • Could the authors provide a matched comparison with ZipAR, or explain why such a comparison is not applicable?

  • What are the absolute post-training cost, GPU hours, and peak memory for Emu3.5-Image-34B?

  • Could the authors explain the notable color-attribute degradation in Tables 3 and 7, and whether it results from conditional independence within each anti-diagonal?

3 comments

We thank the reviewer for the positive assessment of our presentation, practical acceleration across multiple models, and data-efficient post-training pipeline.

Q1: Could the authors clarify the distinction between FlashAR and the closely related ZipAR and NAR methods, particularly regarding pretrained-model reuse and horizontal/vertical parallel decoding?

A1: While NAR [1], ZipAR [2], and FlashAR all exploit 2D spatial structure for parallel decoding, they address distinct settings and operate via different mechanisms:

  • vs. NAR [1] (From-Scratch Pre-training vs. Lightweight Adaptation): NAR trains a diagonal generator from scratch (e.g., 300 epochs on ImageNet), attaching both horizontal and vertical heads to the final Transformer layer (m=Lm=L) with uniform averaging (g=0.5g=0.5). By contrast, FlashAR reuses pre-trained AR checkpoints and enables diagonal decoding with only 25 adaptation epochs on ImageNet for LlamaGen-L. This efficient adaptation is achieved through pre-final branching (m<Lm < L) with direction-specific vertical Transformer blocks, position-dependent gated logit fusion, and a two-stage adaptation schedule with directional auxiliary supervision.
  • vs. ZipAR [2] (Training-Free Heuristic vs. Adapted Two-Direction Decoding): ZipAR is a training-free framework that retains only the original horizontal head and uses a sliding window size ww (the number of tokens decoded in row r−1r-1 before decoding of row rr begins) to schedule parallel row decoding. Because the model has no vertical prediction pathway and its attention distribution is never adapted to diagonal frontiers, reducing the window size ww toward full diagonal parallelism (ours, w=1w=1) leads to substantial quality degradation.

Q2: Could the authors provide a matched comparison with ZipAR, or explain why such a comparison is not applicable?

A2: Thank you for the suggestion. We conducted matched quantitative evaluations of fixed-window ZipAR [2] (where ZipAR's window size ww is the number of tokens decoded in row r−1r-1 before row rr begins) on both Emu3.5-Image (512×512512\times 512, w∈{1,2,4,8,16}w \in \{1, 2, 4, 8, 16\}, all 553 GenEval prompts ×\times 4 images = 11,060 images, CFG=5.0) and LlamaGen-L (256×256256\times 256 with w∈{8,4,2}w \in \{8, 4, 2\}, 50,000 samples per setting):

Model & SettingMethodTrainingZipAR Window wForward StepsQuality MetricLatency / Speedup
Emu3.5-Image (512²)Base ARPre-trained-1024GenEval: 80.4846.38s (1.00×)
ZipARTraining-free16528GenEval: 81.4324.78s (1.87×)
ZipARTraining-free8280GenEval: 78.6513.17s (3.52×)
ZipARTraining-free4156GenEval: 79.337.37s (6.29×)
ZipARTraining-free294GenEval: 77.05 (Counting: 30.00)3.78s (12.27×)
ZipARTraining-free1 (Full Diag.)63GenEval: 73.67 (Counting: 30.63, Color Attr.: 53.00)2.54s (18.26×)
FlashAR (Ours)Post-trainedFull Diag.63GenEval: 80.17 (Counting: 53.75, Color Attr.: 64.00)2.50s (18.55×)
LlamaGen-L (256²)Base ARPre-trained-256FID: 3.77 (Paper: 3.80), IS: 245.01.00×
ZipARTraining-free8136FID: 3.73, IS: 222.71.76×
ZipARTraining-free476FID: 12.43, IS: 108.12.85×
ZipARTraining-free246FID: 47.41, IS: 34.14.10×
FlashAR (Ours)Post-trainedFull Diag.31FID: 3.12 ± 0.01 (Paper: 3.16), IS: 284.5 ± 0.57.08×

As shown above, when ZipAR's window is reduced to match FlashAR's 63-step diagonal schedule on Emu3.5-Image (w=1w=1, 63 steps; or w=2w=2, 94 steps), GenEval drops to 73.67 and 77.05, respectively. On LlamaGen-L (which lacks EOL tokens), shrinking ww below 8 causes severe FID degradation (12.4312.43 at w=4w=4 and 47.4147.41 at w=2w=2). Furthermore, by fusing the top-kk horizontal and vertical branches and visual heads via batched matrix multiplications (torch.bmm), single-image 512×512512\times 512 FlashAR inference on B200 GPU takes only 2.50s---matching single-head w=1w=1 ZipAR (2.542.54s) while achieving +6.5+6.5 higher GenEval. We will include this comparison in the revised manuscript.

Q3: What are the absolute post-training cost, GPU hours, and peak memory for Emu3.5-Image-34B?

A3: In our Emu3.5-Image-34B adaptation (50,000 total optimizer steps), the base model has 34.10B34.10\text{B} parameters (32.65B32.65\text{B} backbone + 1.45B1.45\text{B} horizontal head) and the added vertical pathway has 3.41B3.41\text{B} parameters (1.95B1.95\text{B} 4-layer vertical block + 1.45B1.45\text{B} vertical head + 6.56M6.56\text{M} gate), totaling 37.51B37.51\text{B} parameters. Stage 1 (first 20% = 10,000 steps) freezes the backbone and horizontal head to warm up the 3.41B3.41\text{B} branch, and Stage 2 (40,000 steps) jointly fine-tunes all 37.51B37.51\text{B} parameters:

Adaptation StageTrainable ParamsOptimizer StepsGlobal BatchStep Latency (8×B200)Wall-Clock TimeTotal GPU-HoursPeak Memory / GPU
Stage 1 (Branch Warm-up, 20%)3.41B (9.1%)10,0008 (1×8 GPUs)1.10 s/step3.07 hrs24.5 GPU-hrs39.07 GiB alloc (54.02 GiB res)
Stage 2 (Joint Adaptation, 80%)37.51B (100%)40,0008 (1×8 GPUs)1.16 s/step12.87 hrs102.9 GPU-hrs61.49 GiB alloc (84.67 GiB res)
Total Post-Training37.51B (Base 34.10B + Added 3.41B)50,0008 (8,192 tok/step)-15.94 hrs127.5 GPU-hrs61.49 GiB alloc (84.67 GiB res)

We will report these complete resource metrics in Section 4.1 of the revised manuscript.

Q4: Could the authors explain the notable color-attribute degradation in Tables 3 and 7, and whether it results from conditional independence within each anti-diagonal?

A4: Yes, conditional independence (CI) among distant tokens sampled simultaneously on the same anti-diagonal accounts for the multi-object color_attr trade-off, while FlashAR's two-direction design substantially mitigates local CI:

  1. Why anti-diagonal CI affects long-range multi-object color_attr: In GenEval, color_attr evaluates prompts binding distinct colors to multiple separate objects (e.g., "a red A and a blue B"). When two distinct objects lie on distant regions of the same anti-diagonal, their initial anchor tokens are sampled simultaneously in the same step without observing each other's realized color tokens. Occasional long-range attribute competition across distant anti-diagonal coordinates leads to the color_attr decrease (70.25→64.0070.25 \rightarrow 64.00 on Emu3.5-Image and 44.05→43.1944.05 \rightarrow 43.19 on GLM-Image).
  2. How FlashAR mitigates local CI via shared-parent coordination: For adjacent parallel positions (p,q)(p, q) and (p−1,q+1)(p-1, q+1) on the same anti-diagonal Dt\mathcal{D}_{t}, the fused logits are:

zp,q=gp,q zp,q−1H+(1−gp,q) zp−1,qV,zp−1,q+1=gp−1,q+1 zp−1,qH+(1−gp−1,q+1) zp−2,q+1V.z_{p,q} = g_{p,q} \, z^{H}_{p,q-1} + (1-g_{p,q}) \, z^{V}_{p-1,q}, \qquad z_{p-1,q+1} = g_{p-1,q+1} \, z^{H}_{p-1,q} + (1-g_{p-1,q+1}) \, z^{V}_{p-2,q+1}.

Here, zp−1,qVz^{V}_{p-1,q} (used by zp,qz_{p,q}) and zp−1,qHz^{H}_{p-1,q} (used by zp−1,q+1z_{p-1,q+1}) are both projected from the same parent state hp−1,qh_{p-1,q} at the previous step, providing a shared local context that coordinates adjacent sampling distributions and prevents diagonal seam artifacts (Figs. 5--6). 3. Empirical verification that FlashAR mitigates anti-diagonal CI: Comparing 63-step training-free ZipAR (w=1w=1) [2]---which decodes along the exact same 63 anti-diagonals using only the horizontal head---against 63-step FlashAR on Emu3.5-Image shows that color_attr drops to 53.00 under w=1w=1 ZipAR (and to 58.44 under 64-step BlockDiffusion/DiDA), whereas FlashAR's vertical pathway and learned fusion gate recover color_attr to 64.00 (+11.00 points over w=1 ZipAR), while improving Position (73.00→80.0073.00 \rightarrow \mathbf{80.00}) and Colors (90.96→92.5590.96 \rightarrow \mathbf{92.55}). Moreover, on T2I-CompBench (Table 3), FlashAR achieves 0.82 on Color binding compared with 0.810.81 for the base AR model. We will add this analysis to Section 4.

References:

[1] NAR: Neighboring Autoregressive Modeling for Efficient Visual Generation

[2] ZipAR: Accelerating Autoregressive Image Generation through Spatial Locality

Dear jVK2,

I hope this message finds you well. As the discussion period is nearing its end with less than three days remaining, I wanted to ensure we have addressed all your concerns satisfactorily. If there are any additional points or feedback you’d like us to consider, please let us know. Your insights are invaluable to us, and we’re eager to address any remaining issues to improve our work.

Thank you for your time and effort in reviewing our paper.

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

The paper converts a pre-trained raster AR model into NAR-style diagonal parallel decoding through post-training, adding a pre-final vertical branch and a learnable fusion gate. It gets a 13× speedup on Emu3.5-34B with almost unchanged GenEval.

Critical strengths

Accelerating an existing large AR model by about 13× at low cost has high practical value. The evaluation covers four LlamaGen scales and two large T2I models.

Critical weaknesses

The core framework comes from NAR, and the new components bring small gains (FID 3.29→3.16, 4.36→4.12) with no variance reported. Directly relevant baselines are missing (ZipAR, LPD, speculative decoding, Emu3.5's official DiDA), and fine-tuning on GPT-4o synthetic data may itself change GenEval.

Questions for authors

How does the original AR model score after fine-tuning on the same 80K pairs? How does FlashAR compare with ZipAR and DiDA, and is BlockDiffusion trained for 75 or 25 epochs?

4 comments

We thank the reviewer for the constructive comments on framework novelty, evaluation variance, baseline coverage, and post-training data controls.

Q1: The core framework comes from NAR, and the new components bring relatively modest FID gains (3.29$\rightarrow$3.16, 4.36$\rightarrow$4.12). What is the primary contribution of these designs?

A1: The contribution is not diagonal decoding itself. FlashAR is a post-training framework that adapts existing pre-trained raster-scan AR checkpoints to two-direction decoding, without training a new parallel generator from scratch as in NAR [1]. The primary value of our designs lies beyond the incremental FID gains: they enable diagonal decoding through lightweight adaptation of pre-trained AR models. On LlamaGen-L, FlashAR requires only 25 adaptation epochs, compared with 300 epochs of from-scratch training for NAR [1] and LlamaGen. It reduces decoding steps from 256 to 31 (7.08×7.08\times speedup) and improves FID from 3.803.80 to 3.163.16, approaching NAR-L's 3.063.06.

This efficiency is particularly valuable for Emu3.5-Image-34B, whose pre-training data and GPU resources are unavailable to us. FlashAR adapts the released checkpoint using 80M visual tokens, approximately 0.05%0.05\% of its reported pre-training tokens. It reduces decoding steps from 1024 to 63 and H20 latency from 103.57s103.57\text{s} to 7.95s7.95\text{s} (13.03×13.03\times speedup; 46.38s46.38\text{s} to 2.50s2.50\text{s} on B200, 18.55×18.55\times speedup), while retaining comparable GenEval performance (80.1780.17 vs. 80.4880.48). Our pre-final branch, position-dependent fusion gate, and two-stage adaptation enable this efficient conversion:

  • In Table 6 (evaluated at CFG=2.0), 3.29→3.163.29 \rightarrow 3.16 isolates the benefit of pre-final branching (m=23m=23) over final-layer branching (m=24m=24).
  • In Fig. 4(b) and Table 7 (evaluated at fixed CFG=1.5), each component provides a consistent cumulative gain over straightforward NAR-style fine-tuning: Naive Adaptation (4.364.36) →\rightarrow +Upper Branch (4.164.16) →\rightarrow +Fusion Gate (4.124.12) →\rightarrow FlashAR with Two-stage Adaptation (3.983.98, and 3.16 at CFG=2.0).

Q2: No evaluation variance is reported. How significant are the improvements relative to evaluation variance?

A2: To quantify the evaluation variance across 50,000 generated images, we evaluate the FlashAR checkpoints across three independent random sampling seeds (50,000 images per seed):

Model ScaleParamsSeed 0 FID ↓\downarrowSeed 1 FID ↓\downarrowSeed 2 FID ↓\downarrowFID (Mean ±\pm Std) ↓\downarrowsFID (Mean ±\pm Std) ↓\downarrowIS (Mean ±\pm Std) ↑\uparrow
FlashAR-B111M4.67334.65324.71124.6792 ±\pm 0.02956.6976 ±\pm 0.0157206.02 ±\pm 1.55
FlashAR-L343M3.11083.13383.12243.1223 ±\pm 0.01156.3037 ±\pm 0.0233284.53 ±\pm 0.51
FlashAR-XL775M2.98713.01593.01573.0062 ±\pm 0.01666.6298 ±\pm 0.0312286.46 ±\pm 0.66
FlashAR-XXL1.4B2.76212.80062.77712.7799 ±\pm 0.01946.5216 ±\pm 0.0340258.03 ±\pm 1.30

As shown above, the 50,000-sample evaluation standard deviation on FlashAR-L is only ±0.0115\pm 0.0115, which is an order of magnitude smaller than the 0.130.13 (3.29→3.163.29\rightarrow 3.16), 0.240.24 (4.36→4.124.36\rightarrow 4.12), and 0.380.38 (4.36→3.984.36\rightarrow 3.98) component FID gains. On the deeper 34B Emu3.5-Image model, these components bring even more pronounced gains: pre-final branching (m=60m=60 vs. m=64m=64) improves PickScore from 0.21960.2196 to 0.2262, and directional auxiliary supervision (λaux=0.05\lambda_{\mathrm{aux}}=0.05 vs. 00) improves PickScore from 0.18370.1837 to 0.2262. We will include these variance measurements and ablations in the revised manuscript.


Q3: Fine-tuning on GPT-4o synthetic data may itself change GenEval. How does the original AR model score after fine-tuning on the same 80K pairs?

A3: Thank you for raising this important control question. We fine-tuned the original raster-scan Emu3.5-Image model (retaining its native causal mask and single horizontal head) on the post-training image-text dataset under the same optimization settings:

MethodDecoding OrderStepsOverall ↑\uparrowSingleTwoCountingColorsPositionColor Attr.
Emu3.5-Image (Pre-trained)Raster AR102480.48100.0094.9553.7590.9673.0070.25
Emu3.5-Image + Raster AR SFTRaster AR102480.0498.7589.9053.4489.6377.2571.25
BlockDiffusion DiDA [2,3]Block Denoising6474.2296.8888.8947.5085.6468.0058.44
FlashAR (Ours)Anti-diagonal6380.1798.7591.9253.7592.5580.0064.00

Fine-tuning the original 1,024-step raster-AR model on the synthetic pairs yields an overall GenEval score of 80.0480.04 (vs. 80.4880.48 before fine-tuning), confirming that the synthetic data itself does not boost overall GenEval. We will include this control in the revised manuscript.


Q4: How does FlashAR compare with ZipAR, DiDA, LPD, and speculative decoding, and is BlockDiffusion trained for 75 or 25 epochs?

A4:

(1) Comparison with DiDA [2], BlockDiffusion [3], ZipAR [4], LPD [5], and Speculative Decoding [6]:

We already provided comparisons against BlockDiffusion / DiDA [2,3] in the main paper (Table 1 on ImageNet and Table 2 on Emu3.5-Image). Below, we expand this comparison to include ZipAR [4], LPD [5], and Speculative Decoding (SJD) [6] on Emu3.5-Image (512×512512\times 512, all 553 GenEval prompts ×\times 4 images = 2,212 images per setting, CFG=5.0) and on LlamaGen-L and LlamaGen-B (50,000 samples each). In ZipAR [4], the window size ww is the number of tokens decoded in row r−1r-1 before row rr starts (w=1w=1 is full anti-diagonal decoding):

Emu3.5-Image MethodParadigm / TrainingWindow wwStepsSingleTwoCountingColorsPositionColor Attr.Overall ↑\uparrowLatency (s/img)
Emu3.5-Image (Base AR)Raster AR (Pre-trained)-1024100.0094.9553.7590.9673.0070.2580.4846.38s (1.00×1.00\times)
Speculative Decoding (SJD) [6]Training-free Jacobi DraftW=16W=16493.8100.0094.9553.7590.9673.0070.2580.4825.93s (1.79×1.79\times)
ZipAR [4]Training-free Window AR16528100.0093.4356.2590.1679.7569.0081.4324.78s (1.87×1.87\times)
ZipAR [4]Training-free Window AR828099.0694.7043.7589.6378.5066.2578.6513.17s (3.52×3.52\times)
ZipAR [4]Training-free Window AR415699.6995.4543.4490.1680.0067.2579.337.37s (6.29×6.29\times)
ZipAR [4]Training-free Window AR29499.3891.6730.0091.4982.2567.5077.053.78s (12.27×12.27\times)
ZipAR [4]Training-free Diag. AR1 (Full Diag.)6399.6991.1630.6392.8274.7553.0073.672.54s (18.26×18.26\times)
BlockDiffusion DiDA [2,3]Post-trained Block Denoising-6496.8888.8947.5085.6468.0058.4474.222.92s (15.88×15.88\times)
FlashAR (Ours)Post-trained 2D Diag. ARFull Diag.6398.7591.9253.7592.5580.0064.0080.172.50s (18.55$\times$)
LlamaGen SettingMethodTraining BudgetWindow wwStepsSpeedup ↑\uparrowFID ↓\downarrowsFID ↓\downarrowIS ↑\uparrow
LlamaGen-L (256×256256\times 256)Base ARPre-trained (300 ep)-2561.00×1.00\times3.77 (Paper: 3.80)8.46245.0 (Paper: 248.3)
LlamaGen-L (256×256256\times 256)Speculative Decoding (SJD) [6]Training-free16121.11.86×1.86\times4.087.77279.5
LlamaGen-L (256×256256\times 256)ZipAR [4]Training-free81361.76×1.76\times3.738.59222.7
LlamaGen-L (256×256256\times 256)ZipAR [4]Training-free4762.85×2.85\times12.4313.23108.1
LlamaGen-L (256×256256\times 256)ZipAR [4]Training-free2464.10×4.10\times47.4122.0134.1
LlamaGen-L (256×256256\times 256)BlockDiffusion [3]Post-trained (75 ep)-642.19×2.19\times4.55-243.5
LlamaGen-L (256×256256\times 256)LPD (From-scratch) [5]From-scratch (450 ep)-326.78×6.78\times2.295.25294.1
LlamaGen-L (256×256256\times 256)FlashAR (Ours)Post-trained (25 ep)Full Diag.317.08$\times$3.12 ±\pm 0.01 (Paper: 3.16)6.30 ±\pm 0.02284.5 ±\pm 0.5 (Paper: 289.0)
LlamaGen-B (256×256256\times 256)Base ARPre-trained (300 ep)-2561.00×1.00\times5.40 (Paper: 5.46)7.45191.8 (Paper: 193.6)
LlamaGen-B (256×256256\times 256)Speculative Decoding (SJD) [6]Training-free16115.81.77×1.77\times5.247.50187.5
LlamaGen-B (256×256256\times 256)ZipAR [4]Training-free81361.87×1.87\times8.009.37133.4
LlamaGen-B (256×256256\times 256)ZipAR [4]Training-free4762.97×2.97\times26.6520.3357.3
LlamaGen-B (256×256256\times 256)ZipAR [4]Training-free2463.42×3.42\times69.6831.2720.1
LlamaGen-B (256×256256\times 256)FlashAR (Ours)Post-trained (25 ep)Full Diag.316.26$\times$4.68 ±\pm 0.03 (Paper: 4.68)6.70 ±\pm 0.02206.0 ±\pm 1.6 (Paper: 208.3)

Key takeaways from the comparisons above:

  • vs. ZipAR [4]: When pushed to high parallelism on Emu3.5-Image (w=2w=2, 94 steps; or w=1w=1, 63 steps, matching FlashAR's 63-step diagonal schedule), training-free ZipAR degrades sharply to 77.05 (w=2w=2) and 73.67 (w=1w=1), where Counting drops to 30.6330.63 and Color Attr. drops to 53.0053.00 (vs. 80.17, 53.7553.75, and 64.0064.00 for FlashAR). On LlamaGen (which has no EOL token and predicts row rr's first token from the end of row r−1r-1), official ZipAR requires w≥2w \ge 2 to start a new row (so w=1w=1 is inapplicable) and already collapses to FID 12.4312.43 at w=4w=4 and 47.4147.41 at w=2w=2.
  • vs. DiDA [2] / BlockDiffusion [3]: In the Emu3.5 report [2], official DiDA relies on billions of SFT and self-distillation tokens with duplicated clean and noisy sequences. Under a matched post-training budget, converting the causal AR model into bidirectional block denoising degrades GenEval to 74.2274.22 (and FID to 4.554.55 on LlamaGen-L), whereas FlashAR retains causal next-token prediction in both pathways and achieves 80.1780.17 on Emu3.5-Image and 3.163.16 FID on LlamaGen-L.
  • vs. LPD [5] and Speculative Decoding [6]: LPD [5] replaces standard next-token prediction with learnable position query tokens (mask_token) and trains from scratch for 450 epochs at batch size 2048 (its own 450-epoch raster baseline already has FID 2.482.48, and its from-scratch T2I models reach 58.00–62.0058.00\text{--}62.00 GenEval), so it cannot be directly applied for low-cost post-training of pre-trained raster-AR models. Training-free speculative decoding (SJD [6], W=16W=16) preserves quality (4.084.08 FID on LlamaGen-L), but requires 121.1121.1 steps on LlamaGen-L (1.86×1.86\times speedup) and 493.8493.8 steps on Emu3.5-Image (25.93s25.93\text{s}, 1.79×1.79\times speedup) due to low acceptance rates on high-entropy visual tokens, compared with 3131 and 6363 steps for FlashAR.

(2) BlockDiffusion training epochs (75 vs. 25 epochs): Thank you for catching this inconsistency between Table 1 and Section 4.3 / Fig. 4(a). In Table 1 (main comparison), BlockDiffusion was trained for 75 epochs (3×3\times FlashAR's 25-epoch budget) and reached FID 4.554.55 (vs. 3.163.16 for FlashAR at 25 epochs). In Section 4.3 and Fig. 4(a) (convergence comparison), both methods are evaluated over the matched 25-epoch window to compare convergence speed under the same epoch budget. We will revise Section 4.3 and Table 1 to state both settings consistently.

References:

  • [1] NAR: Neighboring Autoregressive Modeling for Efficient Visual Generation
  • [2] Emu3.5: Native Multimodal Models are World Learners
  • [3] Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models
  • [4] ZipAR: Accelerating Autoregressive Image Generation through Spatial Locality
  • [5] LPD: Locality-aware Parallel Decoding for Efficient Autoregressive Image Generation
  • [6] Accelerating Autoregressive Text-to-Image Generation with Training-Free Speculative Jacobi Decoding

Dear 9bUy,

I hope this message finds you well. As the discussion period is nearing its end with less than three days remaining, I wanted to ensure we have addressed all your concerns satisfactorily. If there are any additional points or feedback you’d like us to consider, please let us know. Your insights are invaluable to us, and we’re eager to address any remaining issues to improve our work.

Thank you for your time and effort in reviewing our paper.

Comments on the paper

1 comment

Dear AC, SAC, and PC,

Thank you very much for your time and effort in overseeing the review process of our submission (Paper #30396, FlashAR).

With only one day remaining in the discussion period, we have not yet heard back from Reviewer 9bUy and Reviewer jVK2 after posting our detailed responses on Nov 13 and gentle reminders on Nov 17. Since both reviewers raised concrete technical questions that we have directly addressed with new experiments, we would be very grateful if you could help nudge them to check our rebuttal, or kindly consider these updates in your assessment:

Reviewer 9bUy mainly asked about our distinction from NAR, evaluation variance, whether fine-tuning on the 80K synthetic data itself boosted GenEval, and missing comparisons with ZipAR, DiDA, LPD, and Speculative Decoding. In response, we:

  1. Clarified that FlashAR's core contribution is lightweight post-training adaptation of existing raster AR checkpoints (requiring only 25 epochs vs. 300 from-scratch epochs for NAR on ImageNet, and ~0.08% of pre-training tokens on Emu3.5-34B), rather than proposing diagonal decoding from scratch;
  2. Evaluated 3 random seeds across all four LlamaGen scales (50K images/seed), confirming the FID standard deviation (±0.0115\pm 0.0115 on FlashAR-L) is an order of magnitude smaller than our component gains;
  3. Added a strict control experiment fine-tuning the original raster Emu3.5-34B on the exact same 80K synthetic pairs, which scored 80.04 on GenEval (vs. 80.48 pre-trained and 80.17 for FlashAR), ruling out any data-induced boost;
  4. Added comprehensive head-to-head comparisons against ZipAR, DiDA/BlockDiffusion, LPD, and Speculative Decoding (SJD) on both Emu3.5-34B and LlamaGen, and clarified the 25 vs. 75 epoch settings for BlockDiffusion.

Reviewer jVK2 focused on the conceptual and empirical differences from NAR and training-free ZipAR, the exact post-training compute cost on Emu3.5-34B, and the drop in GenEval color_attr.

In response, we:

  1. Conducted matched comparisons with ZipAR across window sizes (w=16,8,4,2,1w=16, 8, 4, 2, 1) on Emu3.5-34B and LlamaGen-L, showing that at matched 63-step diagonal parallelism (w=1w=1), training-free ZipAR drops to 73.67 GenEval (Counting: 30.63, Color Attr.: 53.00), whereas FlashAR reaches 80.17 at the same latency (2.50s vs. 2.54s);
  2. Reported the exact post-training resource breakdown for Emu3.5-34B (15.94 wall-clock hours / 127.5 GPU-hours in total on 8×B200, with 61.49 GiB peak allocated memory per GPU);
  3. Provided both theoretical and empirical analysis explaining why long-range conditional independence along anti-diagonals affects multi-object color_attr, and how our vertical branch + learned fusion gate recover +11.00 points on color_attr compared with single-head diagonal decoding (ZipAR w=1w=1).

We truly appreciate your help and support during this busy period.

Best regards,
The Authors of Submission #30396 (FlashAR)

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.