Moebius beats FLUX at 0.22B, FID swings 3.2× on retraining, Ant blames E2M1

TL;DR

• Moebius (0.22B) beats FLUX.1-Fill-Dev (11.9B) on Places2 FID at 15× the speed.
• Retraining shifts FID 3.2× more than resampling, with a 1.3% coefficient-of-variation floor.
• Lucky training seeds match unlucky seeds’ FID at half the compute, gutting efficiency claims.
• Ant’s UFP4 cuts the BF16 loss gap from 1.73% to 1.39% on a 124B MoE by switching to uniform INT4.
• Blackwell’s FP4 cores are float-only, forcing the INT4 fix into throughput-killing emulation.

Today’s research leads share an unflattering reflex: take the headline metric, then go looking for the variable nobody printed. Moebius posts a 15× speedup over FLUX at one-fiftieth the parameters — but the real story is that it’s a distilled specialist competing against a generalist, and Simon Willison has already ported the 1.3GB checkpoint to WebGPU. The FID Lottery paper shows reported diffusion FIDs swing 3.2× more from retraining than from resampling, meaning a lucky seed can match an unlucky one at half the compute. And Ant’s UFP4 attributes FP4 training drift not to bit-width but to E2M1’s asymmetric bin geometry — a fix that works on paper but stalls on Blackwell’s float-only tensor cores.

Read together, they’re a reminder that headline numbers in this field are conditional on a knob the headline doesn’t name. The briefs underneath extend the pattern: IBM’s agent-leaderboard critique and WRBench’s world-model audit argue that aggregate scores hide the dimensions that actually matter at deployment.

Moebius runs FLUX-class inpainting in 0.2B params and a browser

Source: hf-daily-papers · published 2026-06-16

TL;DR

• Moebius (0.22B params) beats FLUX.1-Fill-Dev (11.9B) on Places2 FID at 15× the speed (5.39 vs. 10.13, 0.52s vs. 8.05s).
• The headline comparison is specialist-vs-generalist: Moebius is distilled from PixelHacker (0.86B), itself an inpainting specialist.
• Architecture recycles SANA’s primitives — ReLU-linear attention plus depthwise Mix-FFN — applied to inpainting with E-LatentLPIPS supervision.
• Simon Willison ported it to WebGPU via ONNX Runtime Web, shipping ~1.3GB of weights for fully client-side inference.

The claim, and the asterisk

Moebius, from HUST and VIVO AI Lab, is a 0.22B-parameter diffusion inpainting model that posts an FID of 5.39 on Places2 — better than FLUX.1-Fill-Dev’s 10.13 at 11.9B parameters and SD3.5 Large’s 11.80, with total inference time of 0.52s versus FLUX’s 8.05s. On paper that is a ~54× parameter reduction with a quality gain.

The asterisk is in the framing. Moebius is distilled from PixelHacker, an 0.86B specialist trained with Latent Categories Guidance on 14M image-mask pairs that already scores FID 8.59 on Places2 ¹. The honest comparison is “a distilled student of an inpainting specialist beats a text-to-image generalist on the specialist’s home benchmark.” FLUX’s broader text conditioning and out-of-distribution behavior aren’t in the table. FID rewards distributional match; it does not penalize an inpainted patch that looks suspiciously smoother than its surroundings — a failure mode users of the browser demo are already flagging.

Architecture: SANA’s primitives, applied to inpainting

The paper’s headline block — Local-λ Mix Interaction (LλMI) — is less novel than the abstract suggests. SANA had already replaced softmax attention with ReLU-based linear attention and swapped standard FFNs for depthwise-augmented Mix-FFNs at multi-megapixel resolutions ². Moebius adopts both primitives nearly verbatim. The genuine extension is the Interactive-λ module, which threads PixelHacker’s Latent Categories Guidance through a linear cross-attention — earlier linear-attention variants like GLA couldn’t handle cross-attention cleanly.

The distillation side leans on E-LatentLPIPS from the Diffusion2GAN line, which operates on latents directly: ~9.7× faster and per-iteration VRAM down from 15.0GB to 0.6GB on an A100 versus decoding to pixels ³. Combined with adaptive gradient-norm loss balancing across coarse (16×16), fine (64×64), and perceptual objectives, that’s how a 0.22B student actually converges. Ablating the teacher pushes FID from 26.43 to 33.42 — the distillation, not the architecture, is doing the heavy lifting.

Read as engineering, this is a careful integration of SANA-style efficient blocks with latent-space perceptual distillation, applied to a task where a strong teacher exists. That’s a useful recipe, but it’s a recipe, not a new primitive.

The browser port is the real story

Days after the arxiv drop, Simon Willison ported Moebius to run entirely client-side via ONNX Runtime Web and WebGPU ⁴. He bypassed Transformers.js to manage WebGPU backends directly, with Claude Code doing most of the PyTorch-to-ONNX translation ⁵. The demo ships ~1.3GB of fp32 weights on first load — commenters noted fp16 would roughly halve that — but inference runs locally with no server round-trip ⁴.

That port is the strongest independent validation that the latency numbers survive outside the authors’ benchmark harness, and it reframes Moebius from “another FID table” to “small enough to ship in a tab.” For privacy-sensitive inpainting workflows — faces, documents, anything you don’t want to upload — that’s the durable contribution.

What’s missing

The repo confirms experiments are 512×512 only, with no ComfyUI node, no LoRA ecosystem, and a setup that requires a separate VAE checkpoint plus flash-linear-attention ⁶. Scaling to 2K+ and integrating into existing creative pipelines is unfinished work. The interesting question isn’t whether Moebius beats FLUX — it’s whether this distillation recipe generalizes to other specialist tasks where a mid-size teacher already exists.

---

FID Lottery: retraining shifts scores 3.2× more than resampling

Source: hf-daily-papers · published 2026-06-17

TL;DR

• Retraining a diffusion model shifts FID 3.2× more than drawing new samples from a fixed network.
• A 1.3% coefficient-of-variation floor survives all model scales and compute budgets tested up to SiT-XL and 2M steps.
• A lucky training seed matches an unlucky seed’s FID at half the compute — gutting recent efficiency claims.
• Authors ship GS-FID and an error-bar calculator so any reported FID can be converted to a 95% confidence interval.

The lottery nobody was running the numbers on

Dufour, Efros and Pérez ran the experiment the diffusion field has been avoiding: train the same architecture many times with different seeds and measure how much FID actually moves. On a converged SiT-B/2, the between-training-run standard deviation was 0.438 FID — 3.2× larger than the 0.137 jitter from resampling a single trained network. The dominant culprit inside training isn’t initialization or data order but the per-step Gaussian noise injected by the flow-matching loss itself, which alone accounts for 77% of the baseline spread.

Scale doesn’t save you. Across S/2, B/2, L/2 and XL/2 — trained with μP so learning rates transfer cleanly — the coefficient of variation stayed pinned in a 1–2% band, median 1.30%. More parameters and more steps lowered the mean FID but left the relative noise floor essentially untouched.

What this does to the leaderboard

The collateral damage lands closest to home. SiT’s own headline result was beating DiT 2.27 → 2.06 on ImageNet-256, a 0.21 gap ⁷. At that performance level, a 1.3% CoV is roughly 0.03 FID — the gap itself is well outside noise, but plenty of more recent “we beat SiT by 0.1” claims aren’t. The reference SiT repository, like essentially every checkpoint on the ImageNet diffusion leaderboard, ships single-seed numbers ⁸.

Efficiency claims fare worse. The paper shows that for SiT-XL, a lucky training seed reaches the same FID with 2× less compute than an unlucky one. A lot of recent “we match SOTA at half the FLOPs” results need to be re-read as “we might have drawn a better seed.”

Rankings at 200k steps correlate with rankings at 2M steps at only Spearman ρ ≈ 0.4–0.6. Early-training leaderboards are barely better than coin flips.

And the fix isn’t free: switching to GS-FID, which uses a golden-section search to tune classifier-free guidance per seed, reshuffles rankings versus unguided FID at ρ = 0.73. “Use the better protocol” changes who wins.

A fourth crack in FID, and the one that hurts most

This sits in a four-year stack of FID critiques: Parmar et al.’s Clean-FID exposed library-level resizing bugs that flip leaderboards ⁹; “Rethinking FID” attacked the Gaussian feature assumption and weak human-judgment correlation ¹⁰; DINOv2-based metrics have beaten Inception and CLIP in human psychophysics ¹¹. The FID Lottery is the orthogonal axis none of those fixed — and crucially, the authors verify the lottery persists when FID is computed in DINOv2 feature space. Swapping backbones doesn’t rescue reproducibility.

Kyutai released GS-FID code and an online error-bar calculator that converts any reported FID into a 95% CI from the measured noise floor ¹². The logarithmic CFG sweep — roughly 14 evaluations per seed — is tractable. The other ask isn’t: training SiT-XL five times to put error bars on a paper. The field has refused that overhead for cheaper experiments. The honest open question is whether anyone retrains at frontier scale to comply, or whether the community quietly migrates to a new metric and leaves the lottery unmeasured under it too.

---

Ant’s UFP4 blames E2M1 geometry for FP4 training drift

Source: hf-daily-papers · published 2026-06-17

TL;DR

• Ant Group’s Ling Team names “shrinkage bias” — a systematic negative rounding error baked into E2M1’s asymmetric bins.
• Random Hadamard Transforms make it worse, pushing rotated data into E2M1’s most lopsided bins.
• Switching to a uniform E1M2/INT4 grid cuts the BF16 loss gap from 1.73% to 1.39% on a 124B MoE.
• The catch is silicon: Blackwell’s 4-bit tensor cores are floating-point-only, so INT4 needs throughput-killing emulation.

The bias hiding in E2M1

The Ling Team’s argument is geometric, not empirical. In a non-uniform format like E2M1 (2 exponent bits, 1 mantissa bit), the spacing between representable values widens as magnitudes grow. Round-to-Nearest-Even bins inherit that asymmetry: the “upper” half of each bin is wider than the lower half, so RTNE systematically rounds magnitudes down. That’s shrinkage bias — and unlike zero-mean quantization noise, it compounds multiplicatively across layers, decaying the signal as it propagates.

The Random Hadamard Transform makes the problem sharper. RHT is the standard fix for outlier-heavy activations: rotate the tensor so the energy spreads across coordinates. But once rotated, the distribution lands squarely in E2M1’s most asymmetric bins, amplifying the per-step bias. That’s why existing recipes like NVFP4 restrict RHT to the weight-gradient path — a workaround, not a cure.

What UFP4 actually changes

UFP4 swaps E2M1 for a uniform grid (E1M2 or INT4-style), where bin spacing is constant and expected rounding error is zero by construction. With the bias gone, the authors apply RHT to all three training GEMMs — forward, activation gradient, and weight gradient — and restrict stochastic rounding to the upstream gradient to preserve expectations without inflating variance. A fused RHT-quantization kernel matches the Hadamard block size to the 16-element quantization block, keeping rotation in-register and adding just 6-7% latency over plain quantization.

The pretraining results, measured as LM loss gap vs. BF16 (lower is better):

The Ling scaling-law sweep from 10M to 324M parameters shows the UFP4 curve sitting consistently below E2M1, so the gap doesn’t close as compute grows.

The competing fixes — and the hardware problem

Ling isn’t alone in noticing E2M1’s quirks. An AMD/Penn State result this year found that swapping randomized Hadamard for a deterministic one cut FP4 Wgrad overhead from 27% to 9% versus FP8 ¹³ — a cheaper patch that keeps the E2M1 grid current hardware is tuned for. CVPR 2026’s FAAR work goes further, learning rounding decisions tailored to E2M1’s asymmetry rather than abandoning it ¹⁴. NVIDIA’s own NVFP4 pitch leans on a two-level FP8/FP32 scaling hierarchy plus Quantization-Aware Distillation from a high-precision teacher ¹⁵ — increasingly treating raw RTNE accuracy as something to paper over with distillation.

The independent stakes are real: Spheron measured an 8B run where MXFP4 needed 36% more tokens than NVFP4 to hit the same loss ¹⁶. Recipe choice at 4 bits compounds into large compute deltas.

But Ling’s prescription runs into Blackwell. The architecture’s 4-bit tensor cores are floating-point-only; INT4 requires software emulation that erases the speedup ¹⁷, and E1M2 — though OCP-listed — is not a first-class primitive. UFP4 may be mathematically the cleaner answer, while FAAR-style learned rounding and deterministic Hadamard are the answers that ship on hardware enterprises already bought. The next round of accelerators will decide which thesis wins.

Round-ups

Agent leaderboards fail predictive validity, IBM benchmark argues

Source: hf-daily-papers

Aggregate scores on agent benchmarks mask rank instability and miss deployment-relevant dimensions like cost and reliability. The paper, tied to IBM’s AssetOpsBench, calls for falsifiable out-of-distribution criteria and HELM-style successors built around predictive validity instead of single-number rankings.

WRBench finds world models lose physical state when unobserved

Source: hf-daily-papers

Today’s video world models drift on hidden physical state once the camera looks away, prioritizing appearance fidelity over worldline consistency. The WRBench evaluation argues AGI-aimed systems need a persistent state core rather than better pixels, with code released for reproducible testing.

Taylor-Calibrate warm-starts linear attention from Transformer teachers

Source: hf-daily-papers

Converting pretrained Transformers into hybrid linear attention models like Gated DeltaNet usually loses quality at init. Taylor-Calibrate uses teacher attention statistics to align write gates, output gates and projections before distillation, cutting the token budget needed to recover full softmax performance.

FAPO edits prompts and pipeline structure together for LLM agents

Source: hf-daily-papers

Cisco’s FAPO goes beyond prompt-only optimizers like GEPA by also rewriting the chain structure of multi-step LLM pipelines. Using a prompt-first search driven by Claude Code, it beats baselines on CTIBench-RCM and a CVE-to-CWE security mapping task.

ContextRL rewards picking the right context for multimodal agents

Source: hf-daily-papers

ContextRL trains agentic and multimodal LLMs with an indirect auxiliary reward for selecting context that supports the correct answer. Built on contrastive context data, it beats data-augmentation baselines on long-horizon reasoning and visual question answering across diverse benchmarks.

Visual grounding in reasoning traces lifts VLM spatial accuracy

Source: hf-daily-papers

Interleaving natural-language reasoning with explicit point and box grounding helps vision-language models stay tied to image evidence. A SAM3-based agent synthesizes training traces at scale, and grounding-aware reinforcement learning improves results on counting and spatial reasoning benchmarks.

LOCUS opens U.S. local ordinances as a machine-readable corpus

Source: hf-daily-papers

LOCUS assembles a comprehensive corpus of U.S. municipal and county ordinance codes with an access layer built for legal AI research. The pipeline pairs OCR with ModernBERT-based classifiers and scorers, filling a long-standing gap in authoritative local legal text at scale.

Footnotes

1. HUSTVL — PixelHacker project page — https://hustvl.github.io/PixelHacker/

   PixelHacker (0.86B) introduces Latent Categories Guidance (LCG) with 116 foreground and 21 background categories, achieving FID 8.59 on Places2 at 512 — and serves as the teacher model distilled into Moebius.

   ↩

2. SANA paper (arxiv 2410.10629) — https://arxiv.org/html/2410.10629v2

   SANA replaces vanilla attention with ReLU-based linear attention, removes positional embeddings, and uses Mix-FFNs that integrate depth-wise convolutions — the same architectural primitives Moebius’s LλMI block adopts.

   ↩

3. Diffusion2GAN / E-LatentLPIPS project page — https://mingukkang.github.io/Diffusion2GAN/

   E-LatentLPIPS operates directly on latents, delivering ~9.7× speedup and reducing per-iteration VRAM from 15.0GB to 0.6GB on an A100 versus decoding to pixels for standard LPIPS.

   ↩

4. Simon Willison — ‘Porting Moebius’ — https://simonwillison.net/2026/Jun/22/porting-moebius/

   Porting the 0.2B Moebius inpainting model to run entirely in the browser using ONNX Runtime Web and WebGPU — about 1.3GB of weights, but inference runs locally with no server.

   ↩ ↩²

5. Simon Willison Substack — porting writeup — https://simonw.substack.com/p/porting-the-moebius-02b-image-inpainting

   I had to bypass the higher-level Transformers.js library in favor of raw ONNX Runtime Web to properly manage the WebGPU backends — Claude Code did most of the translation from the PyTorch reference.

   ↩

6. GitHub hustvl/Moebius repo — https://github.com/hustvl/Moebius

   Experiments primarily conducted at 512×512; users report VAE checkpoint must be placed in ./weight/vae and the project depends on flash-linear-attention plus a specific diffusers version — no open issues yet and no ComfyUI integration.

   ↩

7. Scalable Interpolant Transformers (SiT), ECCV 2024 — https://www.ecva.net/papers/eccv_2024/papers_ECCV/papers/09828.pdf

   SiT achieves FID 2.06 on ImageNet 256×256, surpassing DiT’s 2.27 without increasing parameter counts or GFLOPs.

   ↩

8. willisma/sit GitHub repository — https://github.com/willisma/sit

   Reference SiT training code used as the experimental substrate; published checkpoints report single-seed FIDs without variance over training restarts.

   ↩

9. Clean-FID project page (Parmar et al., CMU) — https://www.cs.cmu.edu/~clean-fid/

   Most popular deep learning libraries (PyTorch, TensorFlow, OpenCV) implement image resizing incorrectly… resulting in vastly different FID scores for the same model.

   ↩

10. Rethinking FID (arXiv 2510.00815) — https://arxiv.org/html/2510.00815v1

    FID — even in its ‘clean’ form — assumes a Gaussian distribution of features that may not exist in modern, complex text-to-image datasets, and correlates poorly with human judgment on diffusion outputs.

    ↩

11. r/MachineLearning thread on ‘Exposing Flaws of Generative Model Evaluation Metrics’ — https://www.reddit.com/r/MachineLearning/comments/14n4rvx/r_exposing_flaws_of_generative_model_evaluation/

    DINOv2-ViT-L/14 consistently outperforms FID and CLIP-based scores in large-scale human psychophysics experiments on realism judgments.

    ↩

12. Kyutai papers page — https://kyutai.org/papers/

    Companion error-bar calculator and GS-FID code are released so practitioners can convert any reported FID into a 95% confidence interval based on the measured seed-noise floor.

    ↩

13. 36Kr — AMD/Penn State FP4 training writeup — https://eu.36kr.com/en/p/3827014998233733

    deterministic Hadamard rotations provide better convergence, reducing overhead from 27% to roughly 9% compared to randomized versions

    ↩

14. CVPR 2026 Workshop — ‘Not All NVFP4 QAT Recipes Are Equal’ (Du et al.) — https://openaccess.thecvf.com/content/CVPR2026W/VAND/papers/Du_Not_All_NVFP4_QAT_Recipes_Are_Equal_How_Architecture_and_CVPRW_2026_paper.pdf

    FAAR (Format-Aware Adaptive Rounding) uses learnable parameters to optimize rounding decisions specifically for the non-uniform E2M1 grid

    ↩

15. NVIDIA Research — NVFP4 QAD Report — https://research.nvidia.com/labs/nemotron/files/NVFP4-QAD-Report.pdf

    NVFP4 utilizes an E2M1 structure… supplemented by a two-level scaling hierarchy: per-block FP8 scales and per-tensor FP32 scales… QAD employs a high-precision teacher model to guide a quantized student model through KL divergence loss

    ↩

16. Spheron Network — NVFP4 vs MXFP4 guide — https://www.spheron.network/blog/nvfp4-vs-mxfp4-gpu-cloud-4bit-quantization-guide/

    an 8-billion-parameter model… using MXFP4 required 36% more training tokens to reach the same loss level as the NVFP4-trained model

    ↩

17. APXML — LLM Compression course notes on Blackwell INT4 — https://apxml.com/courses/llm-compression-acceleration/chapter-2-advanced-quantization-techniques/extreme-quantization-llms

    Blackwell’s Tensor Cores are ‘all-in’ on floating-point; running INT4 models often requires software emulation, which negates the architecture’s performance gains

    ↩