Group size scales with compression squared: 8B G-STAR draws 1024px in 2.5s

G-STAR: Group-Scaled Token Capacity for Deeply Compressed Autoregressive Generation

Xu Huang, Ye Huang, Xiaotong Li, Zhengrong Yue, Jialv Zou, Minhao Jing, Haodong Li, Wenhao Yan, Yaxin Luo, Duomin Wang, Daquan Zhou

cs.CV

2026-11-09

G-STAR scales group size with compression squared. Its 8B model renders 1024px in 2.5s on one H200 (~20× vs prior discrete AR) and stays competitive on five T2I benchmarks.

What problem this solves

Discrete autoregressive image models emit tokens in order, so latency tracks sequence length. Going from 512 to 1024 quadruples the token count. Diffusion updates every spatial position in parallel at each denoising step, and that gap widens at high resolution.

Raising spatial compression from the usual 16× to 32× or 64× cuts global steps with the square of the compression factor. Each remaining cell has to carry a larger patch. A single codebook cannot hold it. Extra codes per cell restore capacity, but if the decoder reruns a full network for every code in the group, the saved steps return as head latency.

Method

The balance is product quantization. A spatial feature is split into G channel groups, and each group picks one entry from a codebook of size K. Grid length stays fixed. One cell can represent K to the power G combinations.

The nominal budget has three pieces. At per-axis compression s, global steps are HW/s², each step carries G·log2 K bits, and the image budget is the product. Multiply s by α and G by α squared, and the budget is unchanged while the step count is divided by α². That quantity is a nominal bit count implied by how many codes you store. Fidelity and semantics still have to be measured.

GSTAR-Pro-8B uses a native 32× tokenizer with G=16. The encoder is initialized from Qwen-ViT. The loss stacks pixel, perceptual, and adversarial reconstruction, vector quantization, alignment of quantized features to Qwen-ViT, and a Gram loss on second-order correlations between the input and the reconstruction. GSTAR-Flash-1.7B does not train a native 64× quantizer. It packs a 32×, G=8 grid with a lossless 2×2 grouping: four cells become one global step with 32 codes, the sequence shrinks by 4×, and codes are unpacked before the pixel decoder. That is α=2, with no extra quantization.

Codes in a group describe the same patch, so they should not be sampled independently. A fully causal head reruns the whole network for every code, and latency grows linearly with G. A fully parallel head emits every code in one pass from the backbone context alone, and the combination can mix incompatible modes. The paper calls this multimodal collision. The semi-autoregressive head runs a parallel trunk once over all slots, then samples with a single causal Transformer layer and a KV cache. The expensive features are computed once.

Both generators go through pretraining, continued training, and supervised fine-tuning at increasing resolution. Data volume and step counts for the large runs sit in the appendix.

Results

The main table covers composition, dense prompts, an overall score, text rendering, and broad instruction following. PRISM is the English combined score from a Qwen2.5-VL-72B judge, rescaled from 0–100 to 0–10. LongText is the English subset.

Pro's LongText score is 0.935, tied with 16× Z-Image, close to Qwen-Image at 0.943 and Emu3.5 at 0.976, and far above Janus-Pro at 0.019. Qwen-Image-Bench is 50.07, above Emu3.5 (49.89) and Qwen-Image (49.23), below GPT Image 1 (54.07). GenEval is 0.84, tied with GPT Image 1 and Seedream 3.0, below BAGEL at 0.88. DPG is 83.38, below Janus-Pro at 84.19. PRISM is 6.98, behind Emu3.5 at 7.52. Flash is lower on every column, with GenEval at 0.76.

At 1024 on one H200, the optimized system takes 2.5 seconds per image. The abstract reports about 20× against earlier discrete autoregressive models. The figure splits that into 21.04× for Flash versus Janus-Pro-7B, 21.57× versus BitDance-14B, and 8.36× for Pro versus Emu3.5-34B.

The cumulative stack is reported for Flash: causal head 22.23s, semi-autoregressive head 14.93s (1.49×), CUDA graph capture 5.85s (2.55×), kernel fusion 3.37s (1.74×), SGLang 2.50s (1.35×). The product is 8.9×.

With K=16,384 and compression fixed at 32×, raising G from 1 to 32 drops reconstruction rFID from 2.0624 to 0.4325 and lifts linear-probe accuracy from 81.45% to 84.55%. Generation FID does not follow: at G=32, gFID is 17.05. G=16 lands at 5.7388, better than G=8 at 6.3773. On the training curve, G=16 is slower early and passes G=8 after about 25k steps. A smaller text-to-image run initializes from Qwen3-1.7B, trains 100k steps at 512 with sequence length 8,192 and global batch 32, then does one SFT epoch. There G=16 scores GenEval / DPG / PRISM at 0.8386 / 82.48 / 5.46, against 0.8060 / 82.49 / 5.30 for G=8.

The same setup compares heads at 512.

Semi-AR matches causal PRISM, trails GenEval by 0.013, and cuts latency from 6.44s to 3.41s. Parallel takes 1.77s and drops PRISM to 4.72.

On the English full set of GEdit-Bench, Pro scores 7.85 semantic consistency, 7.45 perceptual quality, and 7.45 overall. Overall sits near Emu3.5 (7.59), Qwen-Image-Edit (7.56), and GPT-Image-1 High (7.53). Semantic consistency matches GPT-Image-1 High at 7.85.

Why it matters

A 1024 image has 32×32 = 1024 global steps at 32×, and 16×16 = 256 steps at effective 64×. Relative to a 32×, G=8 grid, Flash divides the step count by four and multiplies codes per step by four, so the nominal budget stays put. The 8B model keeps text rendering at 0.935. The 1.7B model still scores LongText 0.853, with a 1024 image in 2.5 seconds.

That is the right trade if you already generate through discrete tokens and the step count is the bottleneck. On the leaderboard the gain is compression and latency. On none of the five benchmarks is Pro ahead of both GPT Image 1 and Emu3.5.

Limitations

G=32 has the best reconstruction and the best linear probe, and a generation FID of 17.05. The square rule preserves nominal bits. Whether a generator can fit those codes depends on training actually catching up. Pro's G=16 is a measured operating point.

The 2.5 second number is not mostly the compression change. Against a causal head, the semi-autoregressive head is only 1.49×. The path from 14.93s to 2.50s is CUDA graphs, fused kernels, and SGLang. The 20× comparison is against 16× Janus-Pro-7B and BitDance-14B, so parameter count, sequence length, and the serving stack move together. The main text has no same-hardware, same-sampler latency table.

Effective 64× is packing. The quantizer is still 32×, and codes are unpacked before the pixel decoder. The main text does not show that a quantizer trained at native 64× would hold the same rFID.

Pro's DPG is below 16× Janus-Pro. PRISM is judged by Qwen2.5-VL-72B while the encoder is initialized from Qwen-ViT, and that family overlap is not discussed. The main text has no human preference study. Multimodal collision is inferred from the three downstream gaps, not from a measured collision rate.

Terms

• Product quantization: split a feature along channels and quantize each slice separately, so one spatial cell stores a tuple of codes.
• Nominal bit budget: capacity implied by codebook size and code count, not the entropy of the learned codes.
• Multimodal collision: codes sampled independently are each plausible, but the combination is not one image mode.
• Semi-autoregressive head: compute slot features in one parallel pass, then sample codes with a one-layer causal network.
• rFID / gFID: Fréchet distance of reconstructions or samples against real images. Lower is better.
• Gram loss: match pairwise feature correlations between an image and its reconstruction.

Source

• arXiv 2611.13004v1
• PDF
• Hugging Face
• GitHub · https://github.com/DAGroup-PKU/G-STAR

What people are saying

• G-STAR paper: 32–64x token compression gives 20x faster autoregressive image generation _akhaliq
• G-STAR: 32-64x token compression makes autoregressive image generation 20x faster pmttyji

Related papers

• Shape-count numbers pass panda bias to same-base VLMs, gap up to 9.92 points
• Meta FAIR unbundles vision encoders: pretraining optional, dedicated vision capacity essential
• Hybrid-attention UniSpark scores 2470.3 MME-S, a 3.23× speedup over BAGEL at 1024
• No robots on site: 1,589 LiDAR scans turned into sim scenes, teleoperation and robot trajectories
• Baking DVSM into an MLP hits 23 FPS, and grouped PSNR edges past DVSM
• Finer drafts raise structure scores, while appearance falls by up to 14.47

All paper explainers