Downloads ยท 30 days
0
becausereasons/yue2-cnzn-canzone-italiana
yue2-cnzn-canzone-italiana is a text-to-audio model from becausereasons. Use it for the text-to-audio task on the model card, and read the license before you ship it in a product. The card lists the license as cc-by-nc-4.0.
Artist-style LoRAs that push YuE2-3B into classic Italian pop: the Sanremo-era ballad with a warm, raspy male baritone, piano, strings and a sweeping singalong chorus, and on request Italo disco, new wave and funk-popโฆ
Downloads ยท 30 days
0
Access
Public
Updated Nov 3, 2026
Repo size
749 MB
Likes
3
Public
Click a slice to open those files.
.safetensors647 MB ยท 86%
From the Hugging Face model README
Artist-style LoRAs that push YuE2-3B into classic Italian pop: the Sanremo-era ballad with a warm, raspy male baritone, piano, strings and a sweeping singalong chorus, and on request Italo disco, new wave and funk-pop. Vocals are sung in Italian. Trigger word: cnzn.
September 2026 update: second generation. Four new checkpoints trained with a different trainer (the experimental YuE2 support in Ostris AI Toolkit). They capture the voices and the vocal tonality of the idiom far more closely than the first release: a darker, raspier baritone, choir backings, whispered and spoken passages, and songs that end on their own. The first release, cnzn_sanremo, stays available below; it is looser in voice but very forgiving.
Last updated: 20 September 2026 (second-generation files, demos and the trainer comparison below).
ComfyUI workflows: download both: a core ComfyUI version (built-in nodes only, no custom nodes) and an FS_Audio Suite version. Each has a setup note and the recommended settings for every LoRA in this YuE2 series.
Every file patches both halves of YuE2: the autoregressive planner (writes the score, the arrangement and the vocal lines, and carries most of the singer identity) and the flow-matching decoder (the sound).
| LoRA | File | Character | Start here | |
|---|---|---|---|---|
| ๐ | CNZN Notte | cnzn_notte.safetensors | The identity checkpoint (step 600). Dark, raspy, close-miked baritone; opens and closes songs with whispered lines when the prompt asks for spoken delivery. | clip 0.5 / model 1.0 |
| ๐ญ | CNZN Teatro | cnzn_teatro.safetensors | The ballad checkpoint (step 650, final). Most vocal drama and dynamics; holds a full ballad at full strength and lands the ending. | clip 1.0 / model 1.0 for ballads, clip 0.5 for up-tempo |
| ๐คซ | CNZN Sussurro | cnzn_sussurro.safetensors | The whisper checkpoint (step 350). Early and light: at full planner strength it follows a whispered / spoken-word prompt most faithfully, close-miked low baritone whispers on the verses. | clip 1.0 / model 1.0 with prompts/whisper_tagged.txt |
| ๐ถ | CNZN Coro | cnzn_coro.safetensors | Step 550. Sweeter, with the backing choir up front; the best of the three for Italo disco. | clip 1.0 for ballads, clip 0.5 for disco |
| ๐ฎ๐น | CNZN Sanremo | cnzn_sanremo.safetensors | First release (FS_Audio trainer). Warm, more generic baritone, very stable, writes long full-structure songs. | clip 1.0 / model 1.0 |
clip is strength_clip (the planner), model is strength_model (the decoder).
Same original Italian lyric, seed 7, 32 steps dpm_2 / sgm_uniform, 360 s cap, no post-processing. Every song below ended on its own.
Notte, modern baritone โ prompts/modern_baritone_spoken.txt, clip 0.5 / model 1.0. Whispered opening and close, dark raspy verses, sung chorus (90 BPM, D minor, 3:44):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_notte__modern_baritone.mp3"></audio>
Teatro, classic ballad โ prompts/classic_ballad.txt, full strength (96 BPM, D major, 4:19):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_teatro__classic_ballad.mp3"></audio>
Coro, classic ballad โ the same prompt and seed one checkpoint earlier: the choir backings move forward (96 BPM, D major, 4:51):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_coro__classic_ballad.mp3"></audio>
Coro, Italo disco โ prompts/italo_disco_falsetto.txt, clip 0.5 / model 1.0. Short spoken-sung verses, falsetto chorus (115 BPM, D major, 4:52):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_coro__italo_disco.mp3"></audio>
Sussurro, whisper-tagged prompt โ prompts/whisper_tagged.txt with the verses tagged [Spoken], full strength. Whispered verses throughout, sung chorus (93 BPM, D minor, 3:34):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sussurro__whisper_tagged.mp3"></audio>
Teatro, whisper-tagged prompt โ prompts/whisper_tagged.txt, clip 0.5 / model 1.0 (93 BPM, D minor, 3:28):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_teatro__whisper_tagged.mp3"></audio>
The second-generation files are not ballad-only. These use the first release's own range prompts, same lyric and seed, so they compare one to one with the range demos further down. Up-tempo styles run at clip 0.5 / model 1.0.
Notte, electro-funk โ prompts/electro_funk_registers.txt, clip 0.5 (125 BPM, D minor, 4:10):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_notte__electro_funk.mp3"></audio>
Coro, new wave โ prompts/new_wave_baritone.txt, clip 0.5. Low baritone verses, tenor chorus, and unlike the first release it ends on its own (115 BPM, D minor, 5:26):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_coro__new_wave.mp3"></audio>
Teatro, Italo pop โ prompts/italo_pop.txt, clip 0.5 (115 BPM, D major, 4:22):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_teatro__italo_pop.mp3"></audio>
Notte, Sanremo ballad โ prompts/sanremo_ballad.txt, the first release's headline prompt, full strength (73 BPM, D major, 5:10):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_notte__sanremo_ballad.mp3"></audio>
All demos use the same original Italian lyric (ten tagged sections), seed 7, baseline recipe, 32 steps dpm_2 / sgm_uniform, no post-processing.
The demo โ prompt prompts/sanremo_ballad.txt, 360 s cap. The planner chose 72 BPM in D major and wrote the whole lyric through: intro, two verse / pre-chorus / chorus rounds, bridge, final chorus, outro (5:56, 84 of 108 vocal bars sung):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sanremo__demo.mp3"></audio>
Classic ballad, prompts/classic_ballad.txt (96 BPM, D major, 360 s cap, 101 of 155 vocal bars sung):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sanremo__classic_ballad.mp3"></audio>
The same prompt and seed with a 240 s cap. The planner wrote the identical score, but the decoder renders the whole song as one piece, so a different cap is a different performance of the same plan (cut in the second chorus):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sanremo__classic_ballad_240.mp3"></audio>
Italo disco, prompts/italo_disco_falsetto.txt: falsetto chorus over baritone spoken-sung verses, arpeggiated synth bass, vocoder harmonies (115 BPM, D major, 4:57):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sanremo__italo_disco.mp3"></audio>
New wave, prompts/new_wave_baritone.txt: low baritone verses rising to a strained tenor chorus, cold pads, sequenced bass, LinnDrum (115 BPM, D minor, hits the 6:00 cap, 153 of 196 vocal bars sung):
<audio controls src="https://huggingface.co/becausereasons/yue2-cnzn-canzone-italiana/resolve/main/demos/cnzn_sanremo__new_wave.mp3"></audio>
They load exactly like the first release (same fused-key layout, text_encoders.* planner and diffusion_model.* decoder, all 224 modules; the LoRA matrices are stored as lora_A / lora_B). Tested through the FS_Audio Lora Loader with the graph in Quick start below.
cnzn_sussurro at clip 1.0 with the whisper phrase in the style sentence and [Spoken] on the sections you want whispered. The whisper lives in the planner at full strength; clip 0.5 dilutes it.An artist-style LoRA that pushes YuE2-3B into classic Italian pop: the Sanremo-era ballad with a warm, raspy male lead, lush analog synth pads, piano, fretless bass, gated-reverb drums and a sweeping singalong chorus. The same weights happily go the other way, into Italo disco, new wave and electro-funk, when the prompt asks for it. Vocals are sung in Italian.
The file patches both halves of YuE2 in one go: the autoregressive planner (writes the score, decides the arrangement and the vocal lines) and the flow-matching decoder (the sound). Trigger word: cnzn.
| LoRA | File | Character | Start here | |
|---|---|---|---|---|
| ๐ฎ๐น | CNZN Sanremo | cnzn_sanremo.safetensors | Warm raspy male baritone, romantic and nostalgic, big melodic chorus. Writes full songs with intro, verses, pre-chorus, chorus, bridge and outro when the lyric has them. | clip 1.0 / model 1.0, cfg 1.0 |
Ready-made workflows: download them here. The core ComfyUI version needs no custom nodes (core LoRA loader + YuE2 nodes, same settings as below); the FS_Audio Suite version is the chain below.
The LoRA is in the fused-key layout that Comfy's YuE2 implementation uses (text_encoders.* for the planner, diffusion_model.* for the decoder). It was trained with, and loads through, the FS_Audio Suite node pack.
yue2_3b_bf16.safetensors from Comfy-Org/YuE2 in models/checkpoints/.cnzn_sanremo.safetensors into models/loras/.๐งฉ FS_Audio Lora Loader โโlorasโโโถ ๐ค FS_Audio Model Loader โโpipeโโโถ ๐ต FS_Audio Sampler โโโถ ๐ฟ FS_Audio Output
lora_name = cnzn_sanremo.safetensors yue2_checkpoint = yue2_3b_bf16 style = <prompt, starts with "cnzn,">
strength_clip = 1.0 (planner) melody_transcriber = none lyrics = <tagged Italian lyric blocks>
strength_model = 1.0 (decoder) score_mode = full
Sampler settings used for every demo:
| widget | value |
|---|---|
| steps / sampler / scheduler | 32 / dpm_2 / sgm_uniform |
| score_mode | full |
| song_length_cap | 360 (the planner writes 5 to 7 minute songs for a ten-section lyric; 240 cuts the second chorus) |
| repetition_penalty | 1.2 |
Two recipes:
| Baseline | Wild | |
|---|---|---|
| strength_clip (planner) | 1.0 | 1.0 |
| strength_model (decoder) | 1.0 (1.5 for a rougher, more present voice) | 1.0 |
| Weirdness (cfg) | 1.0 | 1.4 |
| score_temperature | 0.7 | 0.9 |
| music_temperature | 1.0 | 1.2 |
Headless, the same graph as an API prompt:
prompt = {
"1": {"class_type": "FSAudioLoraLoader", "inputs": {"lora_name": "cnzn_sanremo.safetensors", "strength_model": 1.0, "strength_clip": 1.0}},
"2": {"class_type": "FSAudioModelLoader", "inputs": {"yue2_checkpoint": "yue2_3b_bf16.safetensors", "melody_transcriber": "none", "loras": ["1", 0]}},
"3": {"class_type": "FSAudioSampler", "inputs": {"pipe": ["2", 0], "style": STYLE, "lyrics": LYRICS, "seed": 7,
"song_length_cap": 360, "score_mode": "full", "steps": 32, "sampler": "dpm_2", "scheduler": "sgm_uniform",
"Weirdness (cfg)": 1.0, "score_temperature": 0.7, "music_temperature": 1.0, "repetition_penalty": 1.2}},
"4": {"class_type": "FSAudioOutput", "inputs": {"song": ["3", 0], "score": ["3", 1], "info": ["3", 2], "filename_prefix": "cnzn"}},
}
Start with the trigger, then write one descriptive sentence in this order: language โ genre โ vocal โ instruments โ mood โ production โ BPM. This is the format the planner was trained on and responds to. Bare tag lists produce odd plans.
cnzn, Italian, classic 80s Italian pop ballad in the Sanremo style, warm expressive male baritone lead vocal, lush analog synth pads, acoustic piano, fretless bass, clean electric guitar, gated reverb drums, sweeping melodic singalong chorus, romantic, nostalgic, resilient and cinematic, elegant open-vowel phrasing with strong repetition, emotionally direct, dry intimate vocal mix with minimal echo and reverb, 72 BPM
Ready-made prompts in prompts/:
| file | what it gets you |
|---|---|
sanremo_ballad.txt | the demo prompt: the Sanremo-era ballad, 72 BPM, dry intimate vocal |
classic_ballad.txt | a plainer 96 BPM ballad with choir harmonies and synth strings |
italo_disco_falsetto.txt | Italo disco at 118 BPM written (planner lands at 115), falsetto chorus, vocoder, handclaps |
new_wave_baritone.txt | 80s new wave, baritone verses to tenor chorus, cold pads, LinnDrum, D minor |
electro_funk_registers.txt | electro-funk Italo pop at 124 BPM, register slides, slap synth bass, FM piano (rendered, not in the demos) |
italo_pop.txt | upbeat Italo pop with gated snare and chant backing vocals (written in the same format, not rendered at release) |
Register words work: "falsetto", "baritone", "head voice", "spoken-sung verses" all show up in the render. Synth vocabulary ("arpeggiated synth bass", "vocoder harmonies", "LinnDrum", "gated snare") moves the planner off the ballad grid and up to 115โ125 BPM together with the numeric BPM.
Tagged Italian blocks. Use [Intro], [Verse 1], [Verse 2], [Pre-Chorus], [Chorus], [Bridge], [Outro]; number the verses and write a repeated chorus out again where you want it sung. Standard Italian orthography with accents. Shape that made the demo:
[Intro]
two short lines and the hook phrase
[Verse 1]
two four-line stanzas, roughly eight to ten syllables per line
[Pre-Chorus]
four lines that build
[Chorus]
three four-line stanzas, the hook line repeated at the top of each
[Verse 2]
two more four-line stanzas
[Pre-Chorus]
(repeat)
[Chorus]
(repeat, written out)
[Bridge]
two four-line stanzas
[Chorus]
(repeat, written out)
[Outro]
the hook phrase, twice, trailing off
The planner honours that structure section for section. Open vowels and short words sing cleanest; long dense lines overrun their bars.
Both generations were trained on the same core set of songs, on one RTX 5090, and rendered with the same prompts, lyric and seed, so the differences below come from the trainer.
Old trainer versus new trainer. The first release was trained with the FS_Audio Suite Artist Trainer, the second generation with AI Toolkit. Comparing them on the same songs explained something we had noticed across all our earlier LoRAs: they learned a genre convincingly but never a voice.
cnzn_sanremo writes long, complete, well-structured songs at full strength with no tuning, and why it remains the forgiving choice.What the AI Toolkit trainer does differently. One LoRA network spans both experts and is trained jointly on the Comfy-Org checkpoint (the int8 ConvRot repack here): next-token loss on the planner over each song from its start, flow-matching loss on the decoder over a random 60 s window. Audio is tokenised with the community real-audio tokenizer (Mothersuperior/yue2-mothersuperior-realaudio-tokenizer-v4, a MERT-based head), and every song gets a SheetSage2 lead sheet so the planner also learns the score-first path. A KL term (ar_kl_weight) anchors the planner to the base model.
What it buys. Singer identity. The first-generation file learned the genre; these learned the voices: register, rasp, phrasing, choir textures, spoken and whispered asides. In same-seed A/B listening the difference is not subtle.
What it costs. The planner over-commits easily. Observed over two runs and roughly 130 test renders:
.abc sidecar (bar count, tempo, section list) catches these without listening.Practical notes for anyone training YuE2 with AI Toolkit on Windows with 32 GB
torch.cuda.empty_cache() per training step fixed it outright (32 GB used down to about 18 GB, a steady 4 to 5 s per step). Allocator garbage-collection settings did not help.ar_cuda_graphs: false in the model kwargs or disable sampling, and evaluate in ComfyUI instead.ar_max_tokens: 4000 does.| second generation (Notte / Teatro / Coro) | |
|---|---|
| trainer | Ostris AI Toolkit, YuE2 audio extension (experimental), joint planner + decoder LoRA |
| base weights | Comfy-Org yue2_3b_int8_convrot for training, yue2_3b_bf16 for the demos |
| dataset | 23 songs (Italian pop from the late 1970s to the 2000s, including two AI-generated anchor songs) plus five short spoken / whispered / low-register excerpts, repeated twice |
| steps / checkpoints | 650, saved every 50; published 350, 550, 600, 650 |
| network | rank 32 / alpha 32 on both experts |
| learning rate | 5e-5 decoder, x0.6 on the planner, AdamW 8-bit |
| planner settings | ar_kl_weight 0.2, cot: full, abc_dropout 0.5, ar_max_tokens 4000, 1500-frame decoder window |
| wall time | 46 minutes for 650 steps |
Trained on a single RTX 5090 with the FS_Audio Suite Artist Trainer on Comfy's own YuE2 weights. One run trains the planner LoRA and the decoder LoRA together; the file also carries full vae2llm / llm2vae projection diffs.
| CNZN Sanremo | |
|---|---|
| dataset | 20 songs, 87 minutes: Italian pop from the late 1970s to the 2000s, mostly Sanremo-style ballads and Italo pop with a few synth-pop and funk-pop cuts, plus two AI-generated anchor songs in the target style |
| checkpoint | step 350 (final) |
| planner / decoder steps | 350 / 600 |
| artist (planner) loss | 5.154 โ 4.423 |
| decoder loss | 1.193 โ 1.176, monotone, no upturn |
| wall time | 29 minutes including the dataset build |
Hyper-parameters: rank 64 planner / rank 32 decoder, LR 3e-5 planner / 4e-5 decoder / 2e-5 I/O projections, artist fraction 0.5 vs regularizer pack, KL 0.1, batch 2 songs, 8192 max tokens, 750-frame windows, EMA 0.99, one song held out, score-first 0, no transcription.
The anchor trick. The two AI-generated songs in the set were captioned with the exact prompt published above as sanremo_ballad.txt, not with an automatic description. Doing the same on an earlier reggae LoRA was the single largest quality jump in that series, so this run was restarted to apply it. The planner learns the prompt-to-plan mapping from those captions; the rest of the set teaches the voice and the idiom.
The planner learns from the captions as much as from the audio, so the caption format decides whether your prompts work later. What worked here:
ffmpeg -err_detect ignore_err. One file was an MP3 wrapped in a RIFF header and needed -f mp3 forced.score-first 0 and no automatic transcription.cnzn_notte.safetensors 118 MB second generation, step 600 (planner + decoder LoRA, bf16)
cnzn_teatro.safetensors 118 MB second generation, step 650
cnzn_coro.safetensors 118 MB second generation, step 550
cnzn_sanremo.safetensors 177 MB first release: planner + decoder LoRA (bf16 weights, fp32 projection diffs)
demos/ mp3 renders (192 kbps from the FLAC masters), seed 7 throughout
prompts/ style prompts
These LoRAs are trained on my own GPU and released free. If they're useful to you and you'd like to chip in for compute, there's a Ko-fi: ko-fi.com/becausereasons <3
Weights are released under CC BY-NC 4.0, inherited from the YuE2-3B base model. Non-commercial use only; attribute "CNZN LoRA by becausereasons".