nemotron-twotower autopsy: 2.4x that costs a second 30B model (report + chart + Field-Reports row)

README.md

@@ -128,6 +128,7 @@ One-shot investigations that don't fit the leaderboard format — claim verifica
 
 | Report | Finding |
 |---|---|
+| [Nemotron-TwoTower autopsy: a 2.4x speedup that costs a second 30B model](reports/nemotron-twotower-autopsy.md) · [chart](reports/nemotron-twotower-autopsy.png) | NVIDIA's Nemotron-TwoTower is a diffusion LM adapted from a frozen autoregressive Nemotron-3-Nano-30B that generates 2.42x faster than plain AR at 98.7% quality (arXiv 2606.26493) — clever, and datacenter-only by construction. The speedup comes from running two full 30B backbones co-resident: a frozen context tower plus a trained denoiser that unmasks several tokens per diffusion step. The checkpoint ships both stacks (126GB bf16, ~63B params) and the card requires 2x80GB (~59GB/GPU). The towers can't be shared (the paper's own ablation: tying is "substantially worse") or run sequentially (the denoiser cross-attends to and seeds Mamba state from the live context tower every block-step), so the 2.42x is bought by doubling the model's resident memory. The comparison that matters: on one RTX 5090, speculative decoding already delivers the same multiplier for a draft head in single-digit GB — from this rig's t036 spec-decode run on Gemma-4-26B-A4B (sm_120): MTP 2.13x, DFlash 2.19x, EAGLE-3 1.69x, for ~0-2GB of drafter (MTP ships inside the model). Same ~2.2x speedup, ~60x the memory. Two honest caveats: different mechanisms on different models (an architectural argument, not a controlled A/B — TwoTower won't run on the rig), and TwoTower's 2.42x is measured vs plain AR with no speculative-decoding baseline, so against a production AR server already at ~2.2x via spec-decode the marginal win mostly disappears while still costing a second 30B backbone. Doesn't run on consumer hardware at all: 126GB exceeds a 96GB box even fully offloaded, no quant of the custom trust_remote_code arch exists, and the mamba_ssm/causal_conv1d kernels are the usual Blackwell build wall. The two HF repos are the same checkpoint (config + shard sha256 identical; -Labs- adds inference.py). Arithmetic autopsy from the published artifact, no 5090 run. Companion to the GLM-5.2 datacenter-only autopsy and the spec-decode three-way. |
 | [Making music on a gaming GPU: ACE-Step 1.5 writes a 4-minute song in 1.75s](reports/ace-step-music.md) · [chart](reports/ace-step-music.png) | First RTX-5090/sm_120 numbers for ACE-Step 1.5, an open-weights text-to-music model. One gaming GPU generates a full 4-minute song in 1.75s of compute (2B turbo, DiT-only, bf16, 8-step, batch 1) — level with the model authors' own A100 claim (~1-2s) and ~6x past the RTX 3090 (<10s), at 137x real-time. The higher-quality XL 4B tier costs ~1.65x the time (2.9s, 83x) and ~60% more VRAM (14.8 vs 9.4GB); both fit far inside 32GB, and XL would run on a 16GB card. Real-time factor RISES with length — 81x at 30s to 137x at 4min — because the turbo model's step count is fixed at 8 (distilled from ~50), so a 4-minute track is ~5x the compute of a 30-second one, not 8x. Measured out-of-box with no torch.compile and no quantization: a floor, not a ceiling. Speed only — audio quality is left to the ear (paired 2B-vs-XL samples), a prompt-alignment score the natural follow-up. Companion to the DiffusionGemma AR-vs-diffusion null. |
 | [Bias-only steering: nothing moves at bounded budget, and random rewards match correct ones](reports/bias-only-steering.md) · [chart](reports/steering-claimed-vs-measured.png) | Bias-Only Reasoning Steering (arXiv 2505.18706, EMNLP 2025) claims RL-training one bias vector per layer (~0.0016% of params, added to mlp.down_proj) matches full RL fine-tuning: Qwen2.5-Math-7B MATH500 52.2 to 79.9 (steering even beats full-FT). Their pinned stack is dead on arrival on consumer Blackwell — torch 2.6.0+cu124/vllm 0.8.5 fails its first kernel launch on sm_120 — so the recipe was reimplemented from their own configs (RLOO, steering lr 1e-3, qwen_math template, DeepScaleR) at a matched bounded budget (20 steps x 8 prompts x 8 generations, ~1,280 rollouts vs their ~645K), plus the controls neither paper reports: their-own-config LoRA (r4, down_proj only), random-reward steering (Spurious-Rewards protocol), and a zero-training 'To'-prefix probe of their companion paper's first-token-substitution mechanism. A five-arm null: base 54.6 MATH500 / 45.0 AMC23 (reproduces their 52.2/45.8 starting point), steering 54.4/45.0, LoRA 53.8/40.0, random-reward steering 54.2/45.0, 'To'-prefix 53.0 — every arm is the base. Correct rewards buy nothing over coin flips at this budget, and the claimed ~10-11pt 'To'-prefix gain lands at -1.6 on the standard template, where the base's generations already open with 'To'. Wall-clock decomposition (identical across arms): rollouts 75%, backward+update 25%, grading under 1% — the '34s vs 52m' headline counts only the optimizer sliver, and the slice that shrinks with trainable-param count is ~none of a step; on 32GB the real bias-only win is memory (full-param 7B RL does not fit at all; ~100K bias params train comfortably). Bounds where the gain is not (early), does not refute their full-recipe endpoint. Steering checkpoints served in stock vLLM via a Qwen2-to-Llama re-badge (mlp_bias=true), fp32-verified logit-identical. |
 | [Ornith-1.0-35B's self-written scaffold doesn't survive a different harness](reports/ornith-1-0-35b-anchor.md) · [chart](reports/ornith-anchor.png) | DeepReinforce's Ornith-1.0 (MIT) is an RL coder that co-trains a task-specific agent scaffold INTO the weights; the 35B claims 75.6 SWE-bench Verified (the 82.4 headline is the unrunnable 397B flagship), measured in OpenHands. Held the bugs, harness, quant (Q4_K_M), and thinking mode (off) fixed and changed only the model: against the exact base it was post-trained from (Qwen3.5-35B-A3B) in the rig's strict native loop, Ornith-35B resolves 5/12 vs the base's 7/12 — a regression, and a strict subset (it recovers nothing the base missed). The two losses (astropy-12907, xarray-3677) are bugs the base solved, lost to tool-call JSON fragility: Ornith emits multi-line bash with unescaped newlines, llama-server's strict parser 500s, and even after the loop is hardened to feed the error back and let it retry (a fix inert for the base, which never 500s), it burns its full 40-step budget producing no patch. The reading: their 75.6 lives in a lenient harness with the model's own scaffold; stripped to a strict neutral loop the self-scaffold model is more fragile than the base it was trained from, so the orchestration didn't travel. An agentic-coding number is a property of the model and the harness, not the model alone. And the rig's own synthetic Agentic Score is worse than blind to it: it ranks Ornith-35B at 98.06, ABOVE the base's 97.5 (#6 on the board), while Ornith resolves fewer real bugs — the synthetic axis inverts the ranking, scoring fluent tool-driving rather than real-bug fixing. Not a refutation of the 75.6 (different harness, temperature, and scaffold); the 397B flagship is datacenter-only and untested. The fourth Qwen-family coding tune to regress on the real anchor — only pi-tune, trained on real agent traces, improved. |

reports/nemotron-twotower-autopsy.md

@@ -0,0 +1,42 @@
+# Nemotron-TwoTower autopsy: a 2.4x speedup that costs a second 30B model
+
+NVIDIA's Nemotron-TwoTower is a diffusion language model that generates **2.42x faster than autoregressive at 98.7% of the quality** — no backbone retraining, a genuinely clever piece of engineering. It is also **datacenter-only by construction**, and not because the weights are merely large. It gets its speedup by holding *two* full 30B backbones in memory at once. On a single consumer card, the same ~2.4x throughput is already available for roughly a thousandth of the memory, and this rig has measured it. This is an autopsy from the published artifact and arithmetic — the model needs 2x80GB and does not run on the 5090.
+
+## Credit first: what it does
+
+TwoTower takes one pretrained autoregressive model (Nemotron-3-Nano-30B-A3B) and runs it in two roles. A **frozen context tower** reads the clean prompt once and produces the KV cache and Mamba state. A **trained denoiser tower** then generates a block of tokens at a time by iterative mask-diffusion, unmasking several tokens per step instead of one. Because it commits multiple tokens per diffusion step, it clears a 240-token-style block in fewer forward passes than autoregressive decoding needs — hence 2.42x throughput, at 98.7% of the base model's quality (arXiv 2606.26493, measured on 2xH100). Adapting an AR model into a competitive diffusion model without retraining the backbone is real work.
+
+## The wall: the speedup is a second 30B network
+
+The denoiser is not a lightweight add-on. It is a **full, separately-trained 30B backbone**, and at inference both towers are resident at once:
+
+- The checkpoint ships **two complete layer stacks** (`context_tower.*` and `denoiser_tower.*` in the safetensors index): **126 GB in bf16, ~63B parameters total**. The model card requires **2x A100/H100 80GB, ~59 GB per GPU**.
+- You cannot share one backbone between the roles: the paper's own ablation reports that tying the towers is "substantially worse," so the denoiser's weights genuinely diverge from the frozen context tower.
+- You cannot run the towers sequentially to halve peak memory either: the denoiser cross-attends to, and seeds its Mamba state from, the *live* context tower on every block step. The reference code places them on two separate GPUs precisely because both must be resident together.
+
+So the 2.42x is bought by **doubling the model's footprint**. That is fine on 2x80GB. It is impossible on a 32GB card, and impossible even with full CPU offload on a 64GB-RAM box: 126 GB exceeds the 96 GB of total addressable memory. No quantized two-tower runtime exists (the custom `trust_remote_code` diffusion architecture is not supported by llama.cpp, GGUF, or AWQ pipelines), and building one is a research project, not a config flag. There is also a second, independent Blackwell wall: the denoiser has a hard, no-fallback dependency on `mamba_ssm` and `causal_conv1d` CUDA kernels — the familiar Mamba-hybrid sm_120 build problem.
+
+## The comparison that matters: what does 2.4x actually cost?
+
+On one consumer 5090 the throughput problem is already solved, and far more cheaply. Speculative decoding buys the same multiplier for a draft head measured in single-digit gigabytes — often for nothing, when the draft head ships with the model. From this rig's own three-way spec-decode run on Gemma-4-26B-A4B (one RTX 5090, vLLM, sm_120, single stream):
+
+| mechanism | AR-throughput multiplier | extra memory to enable it | hardware |
+|---|---|---|---|
+| **Nemotron-TwoTower** (diffusion) | **2.42x** | **a second 30B backbone (~60 GB)** | 2x 80GB |
+| spec-decode: MTP | 2.13x | ~0 (the draft head ships with the model) | 1x 32GB |
+| spec-decode: DFlash | 2.19x | a small block drafter (~1 GB) | 1x 32GB |
+| spec-decode: EAGLE-3 | 1.69x | a 0.9B drafter (~1.8 GB) | 1x 32GB |
+
+Same target multiplier, memory costs that differ by ~50-100x. TwoTower spends a whole extra model to reach ~2.4x; MTP reaches ~2.1x by drafting from a head that is already part of the checkpoint. On a memory-constrained card, that gap is the entire story.
+
+Two honest caveats. These are different mechanisms on different models — this is not a controlled A/B (TwoTower will not run on the rig to make one), it is an architectural argument about where the throughput comes from and what it costs. And it cuts the other way too: TwoTower's 2.42x is measured against **plain autoregressive**, with no speculative-decoding baseline. A production AR deployment already runs spec-decode at ~2.1-2.2x, so TwoTower's *marginal* win over a well-tuned AR server is much smaller than 2.42x — while still costing a second 30B backbone.
+
+## Verdict
+
+The two-tower trick is clever and the quality retention is real, but the speedup is inseparable from a doubled memory footprint, which makes it a datacenter feature. On consumer hardware you do not need it: speculative decoding delivers the same ~2.4x for a rounding error of extra memory, and the rig has the numbers. If you want the model itself, the frozen backbone — `nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16` — runs fine on a 5090 with the usual GGUF/FP8 quants; you just lose the diffusion path, which is the only part that needed two GPUs.
+
+## Method
+
+Arithmetic and architecture autopsy from the published artifact: HF `nvidia/Nemotron-Labs-TwoTower-30B-A3B-Base-BF16` (config.json, safetensors index, `modeling_nemotron_twotower.py`, `inference.py`, model card) and arXiv 2606.26493, cross-referenced with this rig's measured spec-decode numbers ([Spec-decode three-way, Gemma-4-26B-A4B](reports/specdecode-gemma-4-26b-a4b.md)). The two HF repos (`Nemotron-TwoTower` and `Nemotron-Labs-TwoTower`) are the same checkpoint — config and shard sha256 byte-identical; the `-Labs-` repo adds `inference.py`. No 5090 run: the model requires 2x80GB and does not fit.
+
+*Companion pieces: [GLM-5.2 autopsy](reports/glm-5-2-autopsy.md) (datacenter-only by memory arithmetic) and the [spec-decode three-way](reports/specdecode-gemma-4-26b-a4b.md) (the cheap consumer path to the same throughput).*