Upload README.md with huggingface_hub

README.md

@@ -135,6 +135,7 @@ One-shot investigations that don't fit the leaderboard format — claim verifica
 
 | Report | Finding |
 |---|---|
+| [First EAGLE-3 draft head for Hermes-4.3-36B: trained on one 5090, converged at 39% of the epoch, 1.29–1.57x](reports/hermes-drafter-epoch1.md) · [chart](reports/hermes-drafter-epoch1.png) | Hermes-4.3-36B (Seed-OSS architecture) had no speculative-decoding draft head anywhere on Hugging Face; this run trained the first one entirely on a single RTX 5090, using SpecForge's online mode with a 4-bit AWQ teacher (six memory patches, five filed upstream), 54K curated conversations, 54,000 steps across 8 unattended nights (~55 GPU-h, every night rc=0). Release bench (sglang 0.5.14, cuda graphs, 8 fixed prompts/workload, 66 tok/s no-drafter baseline): tree-3-4-8 wins all four workloads at 1.29–1.57x real decode speedup, while the wider tree-5-8-16 accepts deeper (accept-len to 2.22) yet lands slower everywhere — the draft cost eats more than the extra accepted tokens return. Two findings beyond the table: the head converged at step 21,000 (the epoch-end bench reproduces the 39%-of-epoch dry run within noise, so the last five nights of training moved nothing), and the 1.7–2.2x trained-head precedent band is out of reach at batch 1 on one card, where roughly a quarter of the theoretical accept-len gain pays for the draft pass itself. Decision recorded in the report: no epoch 2 on the same data; a v2 changes the data mix, not the step count. Weights + model card follow with the release. |
 | [LTX-2.3 audio-video on a 5090: synced sound, decode-bound wall time](reports/ltx-2.3.md) · [chart](reports/ltx-2.3.png) · [clips](reports/assets/ltx/bench/) | First consumer-Blackwell (sm_120) numbers for LTX-2.3, Lightricks' ~19B dual-stream DiT (14B video + 5B audio) that generates video and synchronized audio in one pass. The distilled two-stage pipeline (8+4 steps, fp8-cast, tiled VAE, SDPA) makes a 97-frame ~4s clip with h264 + AAC 48kHz output in ~40s at 768x512 (steady state) and ~50s at 1280x704 on one RTX 5090: 10.8 and 12.3 seconds of compute per second of output video. The surprise is the shape of the cost: 2.5x the pixels adds only ~14% wall time, and true peak VRAM (torch counter) is flat at 24.2GB in both configs, because the DiT accounts for just ~5-12s of the wall while tiled VAE decode + audio decode + mp4/AAC encode dominate. Consequences: render at the higher resolution (the quality jump is nearly free) and expect DiT-side speedups to move at most ~a quarter of wall time at these clip lengths. Honest limits flagged in the report: the first generation at a new shape pays ~+20s of one-time lazy init (kept in the published mean), and the vendor's "5.7x faster than Wan2.2 on a 5090" claim is cited, not re-measured. All ten clips attached. Completes the artifact-first modality arc: music (ACE-Step), image (Z-Image), now video-with-audio, all on one card. |
 | [Z-Image-Turbo on a 5090: few-step distillation, measured](reports/z-image-turbo.md) · [chart](reports/z-image-turbo.png) · [samples](reports/assets/zimage-montage.png) | First RTX-5090/sm_120 numbers for Z-Image-Turbo, an open-weights (Apache-2.0) 6B text-to-image DiT with a Qwen3-4B text encoder, measured out-of-box (bf16, SDPA, no torch.compile, no quant). A 1024px image takes 3.18s (~19/min), a 512px one 0.83s. The "turbo" is distillation from the ~50 denoising steps a normal diffusion model runs down to 8, and compute is exactly linear in the step count (each step is one DiT forward): 1.69s at 4 steps, 3.20s at 8, 6.23s at 16, with 4 steps near-indistinguishable from 8 on portraits. Resolution is the real cost, not memory: 0.83/3.18/9.99/23.36s at 512/1024/1536/2048, super-linear because attention scales with pixel count squared. The whole model fits a 32GB card at every tested size (true per-image peak 20.4/21.7/24.6/28.8GB), so 2048px keeps ~4GB of headroom: a time wall, never a VRAM wall. The classically-hard cases hold at 8 steps, where it renders exact text on a sign ("WITCHEER", letters correct) and draws exactly-N objects on request, with colours and spatial relations landing too (sample grid attached). Measurement note: per-image VRAM comes from torch.cuda.max_memory_allocated() with reset_peak_memory_stats() each iteration, because nvidia-smi over-reports. PyTorch's caching allocator retains its high-water mark and never releases it between generations, flattening a naive VRAM curve to a wrong constant. Speed and footprint only; a GenEval quality pass (its mmcv/mmdet detector needs a from-source sm_120 build) is the natural follow-up. Companion to the ACE-Step music bench, the other few-step distilled generator on this rig. |
 | [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. |