Teaching a Music Model Chopin in Five Minutes

A music model you can run at home

ACE-Step 1.5 is a music generator that works the way image generators do, but for sound: you type a short description of the music you want — optionally with lyrics — and it plays you finished stereo audio, minutes long at 48 kHz, that it invented on the spot. It is open-weights under the MIT licence, which means the model itself is free to download and run, all 2.4 billion parameters of it — the adjustable numbers inside it — on one ordinary graphics card in your own machine. No account, no cloud, no per-song fee. It ships in a fast variant and a slower one that takes roughly six times as many rendering steps; everything on this page uses the fast variant.

Out of the box it is a generalist: name a style and it will attempt it. What it doesn't have is your taste, or a deep commitment to any one corner of music. That is the gap this article is about.

What it sounds like on its own

Before teaching it anything, listen to what it already does. We asked for sixty seconds of solo piano with this exact request, verbatim:

pd-shakedown, solo piano nocturne, romantic era, expressive rubato, gentle left-hand arpeggios, intimate close-miked grand piano, instrumental

(That odd first "word" is a made-up label — the next section explains what it is for.)

🔊 Listen 1 — the model with nothing added · sha256 (first 16) dffb1ddde7bbf477

That is the model with nothing added — one sentence of request and no Chopin at all. It is the floor every other clip on this page is measured against. What changes it is a file smaller than a photo album. Here is what that file is.

The trick: a small adapter, not a new model

Retraining all 2.4 billion parameters on your own music would outgrow one consumer card on arithmetic alone — the weights, their gradients, and the optimizer's bookkeeping — and take a great deal more than an evening. The trick that makes this an evening project instead is called LoRA: it leaves the big model completely frozen and trains a small add-on that rides on top of it, nudging its behaviour toward whatever the add-on was trained on. Think of a lens screwed onto a camera body: the camera is untouched, the picture changes, and you can unscrew it.

Our add-on — an adapter, from here on — is a single 88-megabyte file. It adds about 44 million parameters of its own, under two percent of the model's. Detach it and the big model is exactly what it was; the same file works for anyone running the same model. (Adapters have one main capacity knob, called rank — ours is set to 64. What that knob actually buys is a later piece's question.)

Two small mechanics, because the experiment below depends on them. First, the made-up label in the request — pd-shakedown — is the adapter's name tag: every recording it trained on carried that label in its caption, so the finished adapter was trained with it always in place, and we render with it in place too. That way the request never changes; only the adapter does. Second, the adapter's strength is a dial from zero to full, and turning it to zero cancels everything the adapter contributes — which is why Listen 1 above, rendered with the adapter attached and turned to zero, is the cleanest possible baseline: every clip below differs from it in exactly one way.

Five minutes of training, honestly accounted

The corpus. Twenty-four recordings of Chopin — nocturnes, ballades, impromptus — from Musopen, a non-profit whose crowd-funded campaign, called — with no ambiguity at all — Set Chopin Free, paid for newly commissioned recordings in order to give them away under the CC0 public-domain dedication. Chopin died in 1849, so the music itself has been out of copyright for over a century; what Musopen freed was the recordings, which are normally the licensing problem. We verified that chain rather than trusting a label on a file.

One wrinkle from that verification: the campaign's own FAQ — where the CC0 promise was made — had to be read from an Internet Archive snapshot, because the live crowdfunding site answers any client that isn't a browser with a refusal, and we don't disguise our tools as browsers.

Nineteen of the twenty-four recordings went into training; five were held back, split by piece rather than by file so the same piece can never sit on both sides of the test — reserved for a test that hasn't run yet. One honest residue: the training set holds two different recordings of the same nocturne — mild memorisation pressure, written down here so it can't hide later. Each training clip was captioned mechanically — the name tag, "solo piano," and the filename itself. Nobody wrote descriptions.

The machine. A five-year-old RTX 3090 — 24 gigabytes of memory, power-capped at 250 watts — in a consumer-grade box whose motherboard, memory, and nearly everything else dates to about 2021. Nothing in this story required new hardware.

The training. The run: 2026-08-29, ten passes over the nineteen recordings. The recordings go through four at a time, so each pass makes five weight updates — fifty in all, a startlingly small number of times to change a model's mind about anything — in 4 minutes 49 seconds by the trainer's own clock (4:51 counting loading the model and saving the adapter). Peak memory inside the training process: 5.7 gigabytes by the trainer's own bookkeeping; the card itself showed 6.8 in use a minute into the run (7,003 MiB on its own meter, a reading that also includes a small always-on embedding model sharing the card) — under a third of the card either way. Small enough to raise an obvious question: would the GPU in an ordinary gaming laptop have done this? We haven't measured it, so we don't know — the test is queued, and a later piece will report the answer either way.

For anyone reproducing it, the settings in full — skip this if it means nothing to you: LoRA rank 64 (alpha 128, dropout 0.1) on the model's attention projections, batch size 1 with 4-step gradient accumulation, gradient checkpointing on and bf16 throughout, learning rate 1e-4 on a cosine schedule, training samples capped at four minutes each, against the model's fast variant, random seed fixed at 42. The memory figure above was measured at exactly this configuration — keep every flag if you want the same peak.

Here is what that bought, and exactly where it stops. The trainer's per-pass training error fell from 0.94 to 0.61 across the ten passes — with one bump upward at pass nine — so the adapter learned something from those nineteen recordings. It does not follow that the something is Chopin. That distinction runs through everything below.

The dial

Here is the whole experiment in five clips. The same request as Listen 1, the same rendering seed, the same settings — the only thing that moves is the adapter's strength: how much of its full effect is applied, from none of it to all of it. We know that holds because everything else was pinned, and because submitting the identical request twice produces byte-identical files — verified on the full-strength clip itself. Any difference you hear is the dial and nothing else.

🔊 0% — the same clip as Listen 1 above · dffb1ddde7bbf477

🔊 Listen 2 — the dial at 25% · a5c545d2ccc305a2

🔊 Listen 3 — the dial at 50% · ade46063bda30988

🔊 Listen 4 — the dial at 75% · 5b0dbc18d58e41e3

🔊 Listen 5 — full strength · 4a7dd68409b8fc41

Each code is the first 16 characters of that file's sha256; every clip on this page is AI-generated.

Rendering each sixty-second clip took two to four seconds, on another consumer GPU. As you climb the ladder, there is no wrong thing to notice — but three things worth listening for: how the left hand moves, whether the tempo breathes or marches, and how much room there seems to be around the piano.

Now the honesty line, stated once and meant everywhere. To check that the clips really differ, we line two of them up and compare them moment by moment, adding up how far apart the two waveforms sit. By that ruler, each step of the dial moves the audio measurably further from the 0% baseline — no step backtracks. But it is a crude ruler: it tells you how much the sound changed, never whether it changed in a Chopin-shaped direction. (A later piece measures just how crude, and it is humbling — though crude rulers can still prove that five things are five different things.) And no formal, blinded listening test has been run on these clips; building that test properly is its own project, and a later chapter of this series. On this page, your ears are the instrument, and your verdict is as good as ours.

What we did NOT measure

Whether any clip on this page sounds like Chopin — no blinded listening test has been run, and building one properly is its own project. Whether the tempo and key we pinned in the request were actually honoured in the audio — pinning a thing and getting it are different claims, and we checked neither here. Whether a smaller GPU could have run this training — the test is queued, and a later piece reports it. What happens past ten passes. And the five held-back pieces are still waiting for the test they were held back for.

What to take with you

• A style adapter is a small, detachable file: 88 megabytes riding on a 2.4-billion-parameter model, and the model itself is never touched.
• Teaching it one composer took under five minutes, fifty weight updates, and a five-year-old consumer graphics card in a 2021-era box. The cost of trying has effectively vanished.
• The captions that taught it were mechanical — a made-up name tag plus the filename. Nobody wrote a word of description.
• Read the rights chain, not the licence flag. Every recording here traces to a crowd-funded project whose whole purpose was giving the recordings away — and we checked that at the source, not the label.
• The dial provably changes the sound, and in strict order. But "changed" is not "Chopin" — no listening gate has ruled, and your ears are as good as ours.

How to check our work

Every number on this page traces to the training log's own per-pass lines, the render service's records, or a rights receipt read at acquisition time. The data kit beside this article carries the full sha256 fingerprints and the map from each player to its file, the request payload verbatim, the training log's epoch lines, the corpus manifest with its checksums, and the rights-chain receipts. The request printed above is character-exact; the clips are the exact bytes we measured.

Who ran this, and thanks

The recordings that taught the adapter: Musopen's Set Chopin Free project, dedicated to the public domain under CC0 — a dedication that demands no credit, which is exactly why we give it. The model: ACE-Step 1.5 (MIT), whose model card asks users to clearly disclose AI involvement — every clip on this page is AI-generated, and says so. The trainer: Side-Step (github.com/koda-dernet/Side-Step), the corrected-timestep LoRA trainer vendored in ACE-Step 1.5; its upstream licence is CC BY-NC-SA 4.0, though the vendored copy says it follows ACE-Step's MIT — we proceed on the stricter reading, and wrote to ask.

And beneath all of it, the open tools this work stood on without modifying: PyTorch and torchaudio, which ran the training; Hugging Face's PEFT library, which is the LoRA machinery itself; FFmpeg, the decoder that read every training file; and the Internet Archive's Wayback Machine, which held the licence page the living web refused us. None of them owed us anything. A small team and a fleet of AI agents did the work; the humans signed the numbers.

The rest of the seminar

This was the first adapter we trained, and the simplest possible story about it. The same week, the same recipe taught the same model two more dead composers: John Philip Sousa — a corpus of a hundred and six marches by a full military band, which is where things get loud — and Johann Sebastian Bach, whose recordings arrived with a licensing story all their own. Between the three of them, the whole training bill came to just under half an hour of GPU time — a story that gets its own piece.

Also coming: what a corpus actually costs to teach — which turns out to be bought by the second of audio, not by the track; what happens when you try to blend two composers into one adapter with linear algebra, where the obvious approach is mathematically wrong in an instructive way; and the measurements that lied to us until we caught them — this series has a standing rule of publishing its retractions with the same care as its results. One piece at a time.