ace-step 1.5 music-gen: first RTX-5090 numbers (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 |
 |---|---|
+| [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. |
 | [Swap the agent harness, not the model: a +1/12 persistence lever](reports/omp-harness-as-variable.md) · [chart](reports/omp-harness-as-variable.png) | How much of an agentic-coding score is the model and how much is the harness wrapped around it? Held the model fixed (Qwen3.6-27B-Q6_K, one local llama-server on a 5090, think-off, temp 0) and swapped only the agent scaffold, graded on 12 SWE-bench Verified bugs with the official harness. The rig-native tool loop (40-step budget) resolves 8/12; omp v16.1.14 (a deps-free CLI agent, 450s budget, same model and `:8090` endpoint) resolves 9/12 — a strict superset, the lone delta being sphinx-8621. The mechanism is persistence, not reasoning: on the 4 hard bugs the native loop committed no patch (gave up) 3 times, omp once; omp lands patches where native quits, and one of those passed. Both harnesses miss the same 3 bugs (seaborn-3187, requests-1921, pylint-7080) — same model, same ceiling, so the scaffold only moves the give-up rate. Empty-patch rate is the give-up tell, here separating two harnesses on a fixed model. Honest limits: n=12 single seed, so the +1 is inside the noise (the signal is the direction plus the mechanism); the budgets differ by construction (steps vs wall-clock), which is the point — a harness is prompt plus tools plus stopping policy, bundled. The inverse of the Ornith-1.0 claim the rig tests next (RL that bakes the scaffold into training). |

reports/ace-step-music.md

@@ -0,0 +1,56 @@
+# Making music on a gaming GPU: ACE-Step 1.5 on one RTX 5090
+
+**A full 4-minute song in under 2 seconds, on a consumer graphics card.** ACE-Step 1.5 is an open-weights text-to-music model. Point it at one RTX 5090 (the current top gaming GPU) and it writes a complete 4-minute track in about 1.75 seconds of compute. That is roughly what the model's makers report for a datacenter A100, and about 6x faster than the last-gen RTX 3090 they also cite. These are the first numbers for this model on consumer Blackwell (sm_120).
+
+The point of the benchmark is simple: you do not need a data center to make music with AI. A card you can buy for a gaming PC does it faster than the song plays.
+
+## The numbers
+
+Two model sizes, both the fast "turbo" variant (8 diffusion steps). Each cell is 6 prompts across different genres, one seed, warm-up discarded.
+
+| model | 30s song | 2-min song | 4-min song | vs real-time (4-min) | peak VRAM |
+|---|---|---|---|---|---|
+| **2B turbo** | 0.37s | 0.92s | **1.75s** | **137x faster** | 9.4 GB |
+| **XL 4B turbo** (higher quality) | 0.58s | 1.43s | **2.9s** | **83x faster** | 14.8 GB |
+
+Times are generation compute (diffusion + audio decode), the same basis as the vendor's own figures. Writing the file to disk adds about 0.2 to 0.4s. Real-time factor (RTF) is song length divided by generation time: 137x means the 4-minute song is written 137 times faster than you could listen to it.
+
+**Where the 5090 lands.** ACE-Step's team reports the 2B turbo at roughly 1 to 2 seconds per 4-minute song on an A100 80GB, and under 10 seconds on an RTX 3090. The 5090 comes in at 1.75s: level with the datacenter card, and far ahead of the 3090. And this is the plain out-of-box path (bf16, no torch.compile, no quantization), so it is a floor, not a ceiling.
+
+## Three things worth knowing
+
+**1. The fast tier is A100-class on a gaming card.** 1.75s for a 4-minute song is the headline. A card built for games keeps pace with a card built for data centers, on a model anyone can download.
+
+**2. Quality costs time, and not much of it.** The XL 4B model is the higher-quality tier. It takes about 1.65x longer than the 2B (2.9s vs 1.75s for a 4-minute song) and about 60% more memory. Still under 3 seconds, still on a single card. Listen to the paired samples and decide whether your ear wants the bigger model.
+
+**3. Longer songs are proportionally cheaper.** RTF climbs from 81x at 30 seconds to 137x at 4 minutes for the 2B model. Because the step count is fixed at 8 regardless of length, the fixed overhead spreads thinner over a longer track. A 4-minute song is not 8x the work of a 30-second one; it is closer to 5x.
+
+## What we did not measure
+
+Speed is the finding here. Audio *quality* is not scored: "which song sounds better" is a subjective call, and a made-up number would not help. Instead the run saves the actual songs, and the paired 2B-vs-XL clips are attached so you can judge by ear. A quality-alignment score (does the audio match the prompt) is the natural follow-up.
+
+The run is DiT-only: the diffusion model generates directly from a text caption, with no planning language model in front. That matches how the vendor measured the speed claim, and it is the path most people will use.
+
+## Config
+
+DiT-only, bf16, SDPA attention (flash-attn not required on sm_120), 8-step turbo, guidance off (turbo has no CFG), batch size 1, seed 0, 48 kHz stereo. RTX 5090 32GB, torch 2.10.0+cu128, ACE-Step 1.5 (v0.1.8). No torch.compile, no quantization. Donald (the box's resident model server) drained for the GPU window and restored after.
+
+## Reproduce
+
+```
+# capsule (RTX 5090), in the ACE-Step 1.5 clone + its uv env:
+ACESTEP_INIT_LLM=false .venv/bin/python ace_synth.py \
+  --model-tier 2b --config-path acestep-v15-turbo \
+  --prompts prompts.json --durations 30,120,240 --steps 8 --seed 0 \
+  --out-dir ~/ace-out --synth-json ~/ace-out/synth-2b.json --save-audio
+# (repeat with --model-tier xl --config-path acestep-v15-xl-turbo)
+
+# Mac: aggregate + chart
+python3 -m scripts.ace_bench --synth results/ace_step/synth-2b.json results/ace_step/synth-xl.json \
+  --out results/ace_step/ace-step-music.json
+python3 scripts/chart_ace.py
+```
+
+Prompt set (`dataset/ace_step/prompts.json`): pop, lo-fi, orchestral, EDM, acoustic, hip-hop. Metric helpers `lib/ace_step/` (RTF, aggregation) are unit-tested.
+
+*Model: [ACE-Step 1.5](https://github.com/ace-step/ACE-Step-1.5) (Apache-2.0), paper [arXiv 2602.00744](https://arxiv.org/abs/2602.00744). First RTX-5090/sm_120 figures.*