Upload reports/diffusion-vs-ar.md with huggingface_hub

reports/diffusion-vs-ar.md

@@ -0,0 +1,81 @@
+# Block diffusion vs its autoregressive twin on one RTX 5090: the hyped speedup doesn't show — AR wins at every length
+
+**Rig:** one RTX 5090 32GB · llama.cpp diffusion-gemma build (PR #24427, sm_120 CUDA) ·
+**gemma-4-26B-A4B-it** (autoregressive) vs **diffusiongemma-26B-A4B-it** (block diffusion) ·
+both **Q4_K_M**, both **source-converted through the same pipeline** · batch 1 · temp 0.4
+
+**Setup:** These are the same Gemma-4 26B-A4B checkpoint family — one trained autoregressive, one as a
+block-diffusion variant — so the only variable is the *generation paradigm*. Both were converted from the
+original `google/…` safetensors with the **same** `convert_hf_to_gguf.py` and **plain** `Q4_K_M` (no imatrix),
+run on the **same** llama.cpp build, same GPU. AR is served via `llama-server` (reasoning off → clean final
+answers); diffusion via `llama-diffusion-gemma-cli` (128 steps, entropy-bound early-stop to ~48). Throughput
+is each runtime's own **load-excluded** generation timing. **Effective answer tok/s = answer_tokens /
+generation_seconds** — the fair cross-paradigm metric, because diffusion pays a *fixed* canvas cost
+regardless of how long the answer is.
+
+## The board
+
+| prompt | answer len | AR tok/s | diffusion **eff** tok/s | diffusion raw canvas tok/s | AR faster by |
+|---|---|---|---|---|---|
+| factual-short | 2 | 114\* | 0.8 | 104 | **142×** |
+| factual | 32 | 242 | 9.0 | 72 | **27×** |
+| math | 16 | 249 | 4.5 | 73 | **55×** |
+| reasoning | 256 | 248 | 107.6 | 107 | **2.3×** |
+| explain-med | 256 | 245 | 72.5 | 72 | **3.4×** |
+| generate-long | 256 | 251 | 71.9 | 72 | **3.5×** |
+
+\* factual-short's AR rate is cold-start / 3-token measurement noise; AR steady-state is ~248 tok/s.
+**VRAM: AR 17.6 GB · diffusion 19.6 GB.**
+
+## The finding
+
+**On its own autoregressive twin — identical training family, params, quant, hardware — block diffusion is
+slower at every answer length, and uses more VRAM.** AR holds a rock-steady **~248 tok/s**. Diffusion pays a
+fixed **~2.5–3.5 s** cost to denoise a 256-token canvas no matter how short the answer is, so:
+
+- **Short answers are catastrophic** — a 2-token reply ("Canberra") still costs the whole canvas: **0.8 eff
+  tok/s vs ~240** (≈140–300× slower).
+- **Even its best case loses** — a reasoning answer that *fills* the 256 canvas peaks at **107 tok/s, still
+  2.3× slower than AR**.
+- **The raw canvas rate (72–108 tok/s) never reaches AR's ~248 either** — so the gap isn't only wasted canvas;
+  the paradigm is intrinsically slower at this scale.
+
+The widely-shared day-0 claim ("~120+ t/s, *faster* than autoregressive") **does not reproduce** on a single
+5090 at Q4_K_M, batch 1.
+
+## Quality
+
+Both answer the factual prompts correctly (Canberra; Leonardo da Vinci, ~1503). In no-think mode **AR produced
+clean, correct, complete answers on all six — including the bat-and-ball trap (`$0.05`, correct, with no
+thinking channel)**. Diffusion **can't** be put in no-think mode (the CLI exposes no thinking control), so on
+the four reasoning-heavy prompts it dumped raw `<|channel>thought` into the canvas and never resolved a clean
+final answer (math truncated mid-formula at 16 tokens). So in practice AR was both faster *and* cleaner — with
+the honest caveat that the diffusion CLI's lack of no-think control handicaps it on those prompts.
+
+## Why diffusion might still matter (just not here)
+
+Block diffusion's theoretical win is **parallelism** — denoising many tokens at once should amortize on long
+outputs and, especially, under heavy **batching**. This test is **batch 1** on one GPU — the worst case for
+it. The honest read: any throughput advantage needs serving load this rig didn't test, or more mature kernels
+(PR #24427 is a draft). What's *measured*: at the single-stream interactive scale most people run locally,
+autoregressive wins decisively.
+
+## Caveats
+
+- Single RTX 5090, **batch 1**, Q4_K_M, temp 0.4 — no batching/concurrency (diffusion's best case is untested).
+- diffusion-gemma support is an **unmerged draft PR (#24427)** with an experimental sampler — kernels may improve.
+- Both models were **converted from source** with the PR's own converter, because *every* public GGUF (unsloth,
+  AlexAtomic, …) is missing the PR's self-conditioning tensors and won't load.
+- AR forced no-think (clean answers); diffusion has **no** no-think control — the quality comparison is
+  asymmetric on reasoning prompts.
+
+## Worth it?
+
+For **local single-stream use on a 5090 today: autoregressive Gemma-4 is the pick** — 2–300× faster and
+cleaner output. Block diffusion is a genuinely interesting paradigm worth re-testing under batching and once
+the kernels mature — but the day-0 "faster than AR" hype isn't real at this scale.
+
+**Sources**
+- llama.cpp diffusion-gemma PR: https://github.com/ggml-org/llama.cpp/pull/24427
+- google/diffusiongemma-26B-A4B-it: https://huggingface.co/google/diffusiongemma-26B-A4B-it
+- runner + chart: https://github.com/notwitcheer/llm-bench-rig (`scripts/diff_vs_ar.py`, `scripts/chart_diff_vs_ar.py`)