#!/usr/bin/env python3 """ ACE-Step v1.5 — Standalone single-file inference. Generates music from text + lyrics. All model code inlined — no project imports, no trust_remote_code. Uses ComfyUI-style architecture for AIO checkpoint compat. Requirements: pip install torch torchaudio transformers safetensors Usage: python simple_inference.py --prompt "indie folk, warm female vocal, 100 bpm" \ --lyrics "[Verse]\\nSunlight through the window pane" --duration 30 """ import argparse import math import os import time import torch import torch.nn.functional as F import torchaudio from safetensors.torch import load_file from torch import nn from transformers import AutoTokenizer import torch.utils.checkpoint as ckpt # ═══════════════════════════════════════════════════════════════════════════════ # Constants # ═══════════════════════════════════════════════════════════════════════════════ MODELS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models") MODEL_PATHS = { "base": os.path.join(MODELS_DIR, "ace_step_1.5_xl_base_aio.safetensors"), "turbo": os.path.join(MODELS_DIR, "ace_step_1.5_turbo_aio.safetensors"), } SAMPLE_RATE = 48000 LATENT_RATE = 25 # 48000 / 1920 SFT_PROMPT = """# Instruction {instruction} # Caption {caption} # Metas {metas}<|endoftext|> """ TURBO_TIMESTEPS = { 1.0: [1.0, 0.875, 0.75, 0.625, 0.5, 0.375, 0.25, 0.125], 2.0: [1.0, 0.933, 0.857, 0.769, 0.667, 0.545, 0.4, 0.222], 3.0: [ 1.0, 0.9545454545454546, 0.9, 0.8333333333333334, 0.75, 0.6428571428571429, 0.5, 0.3, ], } def compute_timesteps(num_steps, shift=3.0): """Compute flow-matching timestep schedule with shifting.""" import numpy as np sigmas = np.linspace(1.0, 0.0, num_steps + 1)[:-1] # exclude final 0 sigmas = shift * sigmas / (1 + (shift - 1) * sigmas) return sigmas.tolist() # ═══════════════════════════════════════════════════════════════════════════════ # Silence latent (hardcoded, from ComfyUI) # ═══════════════════════════════════════════════════════════════════════════════ def get_silence_latent(length, device, dtype=torch.bfloat16): head = torch.tensor( [ [ [ 0.5707, 0.0982, 0.6909, -0.5658, 0.6266, 0.6996, -0.1365, -0.1291, -0.0776, -0.1171, -0.2743, -0.8422, -0.1168, 1.5539, -4.6936, 0.7436, -1.1846, -0.2637, 0.6933, -6.7266, 0.0966, -0.1187, -0.3501, -1.1736, 0.0587, -2.0517, -1.3651, 0.7508, -0.2490, -1.3548, -0.1290, -0.7261, 1.1132, -0.3249, 0.2337, 0.3004, 0.6605, -0.0298, -0.1989, -0.4041, 0.2843, -1.0963, -0.5519, 0.2639, -1.0436, -0.1183, 0.0640, 0.4460, -1.1001, -0.6172, -1.3241, 1.1379, 0.5623, -0.1507, -0.1963, -0.4742, -2.4697, 0.5302, 0.5381, 0.4636, -0.1782, -0.0687, 1.0333, 0.4202, ], [ 0.3040, -0.1367, 0.6200, 0.0665, -0.0642, 0.4655, -0.1187, -0.0440, 0.2941, -0.2753, 0.0173, -0.2421, -0.0147, 1.5603, -2.7025, 0.7907, -0.9736, -0.0682, 0.1294, -5.0707, -0.2167, 0.3302, -0.1513, -0.8100, -0.3894, -0.2884, -0.3149, 0.8660, -0.3817, -1.7061, 0.5824, -0.4840, 0.6938, 0.1859, 0.1753, 0.3081, 0.0195, 0.1403, -0.0754, -0.2091, 0.1251, -0.1578, -0.4968, -0.1052, -0.4554, -0.0320, 0.1284, 0.4974, -1.1889, -0.0344, -0.8313, 0.2953, 0.5445, -0.6249, -0.1595, -0.0682, -3.1412, 0.0484, 0.4153, 0.8260, -0.1526, -0.0625, 0.5366, 0.8473, ], [ 5.3524e-02, -1.7534e-01, 5.4443e-01, -4.3501e-01, -2.1317e-03, 3.7200e-01, -4.0143e-03, -1.5516e-01, -1.2968e-01, -1.5375e-01, -7.7107e-02, -2.0593e-01, -3.2780e-01, 1.5142e00, -2.6101e00, 5.8698e-01, -1.2716e00, -2.4773e-01, -2.7933e-02, -5.0799e00, 1.1601e-01, 4.0987e-01, -2.2030e-02, -6.6495e-01, -2.0995e-01, -6.3474e-01, -1.5893e-01, 8.2745e-01, -2.2992e-01, -1.6816e00, 5.4440e-01, -4.9579e-01, 5.5128e-01, 3.0477e-01, 8.3052e-02, -6.1782e-02, 5.9036e-03, 2.9553e-01, -8.0645e-02, -1.0060e-01, 1.9144e-01, -3.8124e-01, -7.2949e-01, 2.4520e-02, -5.0814e-01, 2.3977e-01, 9.2943e-02, 3.9256e-01, -1.1993e00, -3.2752e-01, -7.2707e-01, 2.9476e-01, 4.3542e-01, -8.8597e-01, -4.1686e-01, -8.5390e-02, -2.9018e00, 6.4988e-02, 5.3945e-01, 9.1988e-01, 5.8762e-02, -7.0098e-02, 6.4772e-01, 8.9118e-01, ], [ -3.2225e-02, -1.3195e-01, 5.6411e-01, -5.4766e-01, -5.2170e-03, 3.1425e-01, -5.4367e-02, -1.9419e-01, -1.3059e-01, -1.3660e-01, -9.0984e-02, -1.9540e-01, -2.5590e-01, 1.5440e00, -2.6349e00, 6.8273e-01, -1.2532e00, -1.9810e-01, -2.2793e-02, -5.0506e00, 1.8818e-01, 5.0109e-01, 7.3546e-03, -6.8771e-01, -3.0676e-01, -7.3257e-01, -1.6687e-01, 9.2232e-01, -1.8987e-01, -1.7267e00, 5.3355e-01, -5.3179e-01, 4.4953e-01, 2.8820e-01, 1.3012e-01, -2.0943e-01, -1.1348e-01, 3.3929e-01, -1.5069e-01, -1.2919e-01, 1.8929e-01, -3.6166e-01, -8.0756e-01, 6.6387e-02, -5.8867e-01, 1.6978e-01, 1.0134e-01, 3.3877e-01, -1.2133e00, -3.2492e-01, -8.1237e-01, 3.8101e-01, 4.3765e-01, -8.0596e-01, -4.4531e-01, -4.7513e-02, -2.9266e00, 1.1741e-03, 4.5123e-01, 9.3075e-01, 5.3688e-02, -1.9621e-01, 6.4530e-01, 9.3870e-01, ], ] ], device=device, ).movedim(-1, 1) body = ( torch.tensor( [ [ [ -1.3672e-01, -1.5820e-01, 5.8594e-01, -5.7422e-01, 3.0273e-02, 2.7930e-01, -2.5940e-03, -2.0703e-01, -1.6113e-01, -1.4746e-01, -2.7710e-02, -1.8066e-01, -2.9688e-01, 1.6016e00, -2.6719e00, 7.7734e-01, -1.3516e00, -1.9434e-01, -7.1289e-02, -5.0938e00, 2.4316e-01, 4.7266e-01, 4.6387e-02, -6.6406e-01, -2.1973e-01, -6.7578e-01, -1.5723e-01, 9.5312e-01, -2.0020e-01, -1.7109e00, 5.8984e-01, -5.7422e-01, 5.1562e-01, 2.8320e-01, 1.4551e-01, -1.8750e-01, -5.9814e-02, 3.6719e-01, -1.0059e-01, -1.5723e-01, 2.0605e-01, -4.3359e-01, -8.2812e-01, 4.5654e-02, -6.6016e-01, 1.4844e-01, 9.4727e-02, 3.8477e-01, -1.2578e00, -3.3203e-01, -8.5547e-01, 4.3359e-01, 4.2383e-01, -8.9453e-01, -5.0391e-01, -5.6152e-02, -2.9219e00, -2.4658e-02, 5.0391e-01, 9.8438e-01, 7.2754e-02, -2.1582e-01, 6.3672e-01, 1.0000e00, ] ] ], device=device, ) .movedim(-1, 1) .repeat(1, 1, length) ) body[:, :, : head.shape[-1]] = head return body.to(dtype) # [1, 64, T] # ═══════════════════════════════════════════════════════════════════════════════ # Helpers # ═══════════════════════════════════════════════════════════════════════════════ class RMSNorm(nn.Module): def __init__(self, dim, eps=1e-6): super().__init__() self.weight = nn.Parameter(torch.ones(dim)) self.eps = eps def forward(self, x): return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight class RotaryEmbedding(nn.Module): def __init__(self, dim, base=1000000.0): super().__init__() inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32) / dim)) self.register_buffer("inv_freq", inv_freq, persistent=False) self._cos = None self._sin = None self._cached_len = 0 def _build_cache(self, seq_len, device, dtype): if ( seq_len <= self._cached_len and self._cos is not None and self._cos.device == device ): return t = torch.arange(seq_len, device=device, dtype=torch.float32) freqs = torch.outer(t, self.inv_freq.to(device)) emb = torch.cat((freqs, freqs), dim=-1) self._cos = emb.cos().to(dtype) self._sin = emb.sin().to(dtype) self._cached_len = seq_len def forward(self, x, seq_len): self._build_cache(seq_len, x.device, x.dtype) return self._cos[:seq_len], self._sin[:seq_len] def rotate_half(x): x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :] return torch.cat((-x2, x1), dim=-1) def apply_rotary(q, k, cos, sin): cos, sin = cos.unsqueeze(0).unsqueeze(0), sin.unsqueeze(0).unsqueeze(0) return (q * cos + rotate_half(q) * sin), (k * cos + rotate_half(k) * sin) class MLP(nn.Module): def __init__(self, hidden, inter): super().__init__() self.gate_proj = nn.Linear(hidden, inter, bias=False) self.up_proj = nn.Linear(hidden, inter, bias=False) self.down_proj = nn.Linear(inter, hidden, bias=False) def forward(self, x): return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x)) def pack_sequences(h1, h2, m1, m2): h = torch.cat([h1, h2], dim=1) if m1 is not None and m2 is not None: m = torch.cat([m1, m2], dim=1) B, L, D = h.shape idx = m.argsort(dim=1, descending=True, stable=True) h = torch.gather(h, 1, idx.unsqueeze(-1).expand(B, L, D)) lengths = m.sum(dim=1) m = torch.arange(L, device=h.device).unsqueeze(0) < lengths.unsqueeze(1) else: m = None return h, m def timestep_embedding(t, dim, scale=1000, max_period=10000): t = t * scale half = dim // 2 freqs = torch.exp( -math.log(max_period) * torch.arange(half, dtype=torch.float32, device=t.device) / half ) args = t[:, None].float() * freqs[None] return torch.cat([torch.cos(args), torch.sin(args)], dim=-1) # ═══════════════════════════════════════════════════════════════════════════════ # DiT model components (ComfyUI-style, matches AIO weight keys) # ═══════════════════════════════════════════════════════════════════════════════ class TimestepEmbed(nn.Module): def __init__(self, hidden): super().__init__() self.linear_1 = nn.Linear(256, hidden) self.act1 = nn.SiLU() self.linear_2 = nn.Linear(hidden, hidden) self.act2 = nn.SiLU() self.time_proj = nn.Linear(hidden, hidden * 6) self.scale = 1000 def forward(self, t, dtype=None): emb = timestep_embedding(t, 256, self.scale) temb = self.act1(self.linear_1(emb.to(dtype=dtype))) temb = self.linear_2(temb) proj = self.time_proj(self.act2(temb)).view(-1, 6, temb.shape[-1]) return temb, proj class Attention(nn.Module): def __init__( self, hidden, num_heads, num_kv, head_dim, eps=1e-6, is_cross=False, sliding_window=None, ): super().__init__() self.num_heads = num_heads self.num_kv = num_kv self.head_dim = head_dim self.is_cross = is_cross self.sliding_window = sliding_window self.q_proj = nn.Linear(hidden, num_heads * head_dim, bias=False) self.k_proj = nn.Linear(hidden, num_kv * head_dim, bias=False) self.v_proj = nn.Linear(hidden, num_kv * head_dim, bias=False) self.o_proj = nn.Linear(num_heads * head_dim, hidden, bias=False) self.q_norm = RMSNorm(head_dim, eps) self.k_norm = RMSNorm(head_dim, eps) def forward(self, x, encoder_hidden_states=None, position_embeddings=None): B, L, _ = x.shape q = self.q_norm( self.q_proj(x).view(B, L, self.num_heads, self.head_dim) ).transpose(1, 2) src = ( encoder_hidden_states if (self.is_cross and encoder_hidden_states is not None) else x ) sL = src.shape[1] k = self.k_norm( self.k_proj(src).view(B, sL, self.num_kv, self.head_dim) ).transpose(1, 2) v = self.v_proj(src).view(B, sL, self.num_kv, self.head_dim).transpose(1, 2) if position_embeddings is not None and not ( self.is_cross and encoder_hidden_states is not None ): q, k = apply_rotary(q, k, *position_embeddings) n_rep = self.num_heads // self.num_kv if n_rep > 1: k = k.repeat_interleave(n_rep, dim=1) v = v.repeat_interleave(n_rep, dim=1) attn_bias = None if self.sliding_window is not None and not self.is_cross: idx = torch.arange(L, device=q.device) in_win = ( torch.abs(idx.unsqueeze(1) - idx.unsqueeze(0)) <= self.sliding_window ) attn_bias = torch.zeros(L, sL, device=q.device, dtype=q.dtype) attn_bias.masked_fill_(~in_win, torch.finfo(q.dtype).min) attn_bias = attn_bias.unsqueeze(0).unsqueeze(0) out = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_bias) return self.o_proj(out.transpose(1, 2).reshape(B, L, -1)) class EncoderLayer(nn.Module): def __init__(self, hidden, heads, kv, head_dim, inter, eps=1e-6): super().__init__() self.self_attn = Attention(hidden, heads, kv, head_dim, eps) self.input_layernorm = RMSNorm(hidden, eps) self.post_attention_layernorm = RMSNorm(hidden, eps) self.mlp = MLP(hidden, inter) def forward(self, x, position_embeddings): x = x + self.self_attn( self.input_layernorm(x), position_embeddings=position_embeddings ) x = x + self.mlp(self.post_attention_layernorm(x)) return x class DiTLayer(nn.Module): def __init__( self, hidden, heads, kv, head_dim, inter, eps=1e-6, sliding_window=None ): super().__init__() self.self_attn_norm = RMSNorm(hidden, eps) self.self_attn = Attention( hidden, heads, kv, head_dim, eps, sliding_window=sliding_window ) self.cross_attn_norm = RMSNorm(hidden, eps) self.cross_attn = Attention(hidden, heads, kv, head_dim, eps, is_cross=True) self.mlp_norm = RMSNorm(hidden, eps) self.mlp = MLP(hidden, inter) self.scale_shift_table = nn.Parameter(torch.empty(1, 6, hidden)) def forward(self, x, temb, enc, position_embeddings): s_msa, sc_msa, g_msa, s_mlp, sc_mlp, g_mlp = ( self.scale_shift_table.to(temb) + temb ).chunk(6, dim=1) x = ( x + self.self_attn( self.self_attn_norm(x) * (1 + sc_msa) + s_msa, position_embeddings=position_embeddings, ) * g_msa ) x = x + self.cross_attn(self.cross_attn_norm(x), encoder_hidden_states=enc) x = x + self.mlp(self.mlp_norm(x) * (1 + sc_mlp) + s_mlp) * g_mlp return x # ── Encoders ── class LyricEncoder(nn.Module): def __init__( self, text_dim, hidden, n_layers, heads, kv, head_dim, inter, eps=1e-6 ): super().__init__() self.embed_tokens = nn.Linear(text_dim, hidden) self.norm = RMSNorm(hidden, eps) self.rotary_emb = RotaryEmbedding(head_dim) self.layers = nn.ModuleList( [ EncoderLayer(hidden, heads, kv, head_dim, inter, eps) for _ in range(n_layers) ] ) def forward(self, embeds): x = self.embed_tokens(embeds) cos, sin = self.rotary_emb(x, x.shape[1]) for layer in self.layers: x = layer(x, (cos, sin)) return self.norm(x) class TimbreEncoder(nn.Module): def __init__( self, timbre_dim, hidden, n_layers, heads, kv, head_dim, inter, eps=1e-6 ): super().__init__() self.embed_tokens = nn.Linear(timbre_dim, hidden) self.norm = RMSNorm(hidden, eps) self.rotary_emb = RotaryEmbedding(head_dim) self.layers = nn.ModuleList( [ EncoderLayer(hidden, heads, kv, head_dim, inter, eps) for _ in range(n_layers) ] ) self.special_token = nn.Parameter(torch.empty(1, 1, hidden)) def forward(self, packed, order_mask): x = self.embed_tokens(packed) cos, sin = self.rotary_emb(x, x.shape[1]) for layer in self.layers: x = layer(x, (cos, sin)) x = self.norm(x) cls = x[:, 0, :] # Unpack to batch N, D = cls.shape B = int(order_mask.max().item() + 1) counts = torch.bincount(order_mask, minlength=B) mc = counts.max().item() result = torch.zeros(B, mc, D, device=cls.device, dtype=cls.dtype) mask = torch.zeros(B, mc, device=cls.device, dtype=torch.long) for i in range(N): b = order_mask[i].item() pos = (order_mask[:i] == b).sum().item() result[b, pos] = cls[i] mask[b, pos] = 1 return result, mask class ConditionEncoder(nn.Module): def __init__( self, text_dim, timbre_dim, hidden, n_lyric, n_timbre, heads, kv, head_dim, inter, eps=1e-6, ): super().__init__() self.text_projector = nn.Linear(text_dim, hidden, bias=False) self.lyric_encoder = LyricEncoder( text_dim, hidden, n_lyric, heads, kv, head_dim, inter, eps ) self.timbre_encoder = TimbreEncoder( timbre_dim, hidden, n_timbre, heads, kv, head_dim, inter, eps ) @property def device(self): return next(self.parameters()).device @property def dtype(self): return next(self.parameters()).dtype def forward(self, text_h, text_m, lyric_h, lyric_m, refer_packed, refer_order): text_proj = self.text_projector(text_h) lyric_enc = self.lyric_encoder(lyric_h) timbre_enc, timbre_mask = self.timbre_encoder(refer_packed, refer_order) merged, merged_m = pack_sequences(lyric_enc, timbre_enc, lyric_m, timbre_mask) final, final_m = pack_sequences(merged, text_proj, merged_m, text_m) return final, final_m # ── DiT ── class DiTModel(nn.Module): def __init__( self, in_ch, hidden, n_layers, heads, kv, head_dim, inter, patch, out_ch, layer_types=None, sliding_window=128, eps=1e-6, cond_dim=None, ): super().__init__() self.patch_size = patch self.rotary_emb = RotaryEmbedding(head_dim) self.proj_in = nn.Sequential( nn.Identity(), nn.Conv1d(in_ch, hidden, kernel_size=patch, stride=patch) ) self.time_embed = TimestepEmbed(hidden) self.time_embed_r = TimestepEmbed(hidden) self.condition_embedder = nn.Linear(cond_dim or hidden, hidden) lt = layer_types or [ "sliding_attention" if i % 2 == 0 else "full_attention" for i in range(n_layers) ] self.layers = nn.ModuleList( [ DiTLayer( hidden, heads, kv, head_dim, inter, eps, sliding_window=sliding_window if lt[i] == "sliding_attention" else None, ) for i in range(n_layers) ] ) self.norm_out = RMSNorm(hidden, eps) self.proj_out = nn.Sequential( nn.Identity(), nn.ConvTranspose1d(hidden, out_ch, kernel_size=patch, stride=patch), ) self.scale_shift_table = nn.Parameter(torch.empty(1, 2, hidden)) self.gradient_checkpointing = False @property def device(self): return next(self.parameters()).device @property def dtype(self): return next(self.parameters()).dtype def forward(self, x, timestep, timestep_r, attention_mask, enc_h, enc_m, context): temb_t, proj_t = self.time_embed(timestep, dtype=x.dtype) temb_r, proj_r = self.time_embed_r(timestep - timestep_r, dtype=x.dtype) temb = temb_t + temb_r tproj = proj_t + proj_r h = torch.cat([context, x], dim=-1) orig_len = h.shape[1] if h.shape[1] % self.patch_size != 0: h = F.pad(h, (0, 0, 0, self.patch_size - h.shape[1] % self.patch_size)) h = self.proj_in(h.transpose(1, 2)).transpose(1, 2) enc = self.condition_embedder(enc_h) cos, sin = self.rotary_emb(h, h.shape[1]) for layer in self.layers: if torch.is_grad_enabled() and self.gradient_checkpointing: h = ckpt.checkpoint( layer, h, tproj, enc, (cos, sin), use_reentrant=False ) else: h = layer(h, tproj, enc, (cos, sin)) shift, scale = (self.scale_shift_table.to(temb) + temb.unsqueeze(1)).chunk( 2, dim=1 ) h = self.norm_out(h) * (1 + scale) + shift h = self.proj_out(h.transpose(1, 2)).transpose(1, 2) return h[:, :orig_len, :] # ── Top-level model ── class AceStep15(nn.Module): def __init__( self, hidden=2048, text_dim=1024, timbre_dim=64, out_ch=64, n_dit=24, n_lyric=8, n_timbre=4, heads=16, kv=8, head_dim=128, inter=6144, patch=2, in_ch=192, sliding_window=128, eps=1e-6, layer_types=None, # Encoder can have different size than decoder (XL models) enc_hidden=None, enc_heads=None, enc_kv=None, enc_inter=None, ): super().__init__() eh = enc_hidden or hidden eheads = enc_heads or heads ekv = enc_kv or kv einter = enc_inter or inter self.decoder = DiTModel( in_ch, hidden, n_dit, heads, kv, head_dim, inter, patch, out_ch, layer_types, sliding_window, eps, cond_dim=eh, ) self.encoder = ConditionEncoder( text_dim, timbre_dim, eh, n_lyric, n_timbre, eheads, ekv, head_dim, einter, eps, ) self.null_condition_emb = nn.Parameter(torch.empty(1, 1, eh)) self._gradient_checkpointing = False @property def device(self): return next(self.parameters()).device @property def dtype(self): return next(self.parameters()).dtype def enable_gradient_checkpointing(self): self.gradient_checkpointing = True @property def gradient_checkpointing(self): return self._gradient_checkpointing @gradient_checkpointing.setter def gradient_checkpointing(self, value): self._gradient_checkpointing = value self.decoder.gradient_checkpointing = value def prepare_condition( self, text_h, text_m, lyric_h, lyric_m, refer_packed, refer_order, src_latents, chunk_masks, ): enc_h, enc_m = self.encoder( text_h, text_m, lyric_h, lyric_m, refer_packed, refer_order ) context = torch.cat([src_latents, chunk_masks.to(src_latents.dtype)], dim=-1) return enc_h, enc_m, context # ═══════════════════════════════════════════════════════════════════════════════ # VAE (ComfyUI Oobleck style — uses parametrizations.weight_norm) # ═══════════════════════════════════════════════════════════════════════════════ def WNConv1d(*args, **kwargs): return torch.nn.utils.parametrizations.weight_norm(nn.Conv1d(*args, **kwargs)) def WNConvT1d(*args, **kwargs): return torch.nn.utils.parametrizations.weight_norm( nn.ConvTranspose1d(*args, **kwargs) ) class SnakeBeta(nn.Module): def __init__(self, channels): super().__init__() self.alpha = nn.Parameter(torch.zeros(channels)) self.beta = nn.Parameter(torch.zeros(channels)) def forward(self, x): a = self.alpha.unsqueeze(0).unsqueeze(-1).exp().to(x.device) b = self.beta.unsqueeze(0).unsqueeze(-1).exp().to(x.device) return x + (1.0 / (b + 1e-9)) * torch.sin(x * a).pow(2) class ResUnit(nn.Module): def __init__(self, ch, dilation): super().__init__() self.layers = nn.Sequential( SnakeBeta(ch), WNConv1d(ch, ch, 7, dilation=dilation, padding=(dilation * 6) // 2), SnakeBeta(ch), WNConv1d(ch, ch, 1), ) def forward(self, x): return x + self.layers(x) class EncBlock(nn.Module): def __init__(self, in_ch, out_ch, stride): super().__init__() self.layers = nn.Sequential( ResUnit(in_ch, 1), ResUnit(in_ch, 3), ResUnit(in_ch, 9), SnakeBeta(in_ch), WNConv1d( in_ch, out_ch, 2 * stride, stride=stride, padding=math.ceil(stride / 2) ), ) def forward(self, x): return self.layers(x) class DecBlock(nn.Module): def __init__(self, in_ch, out_ch, stride): super().__init__() self.layers = nn.Sequential( SnakeBeta(in_ch), WNConvT1d( in_ch, out_ch, 2 * stride, stride=stride, padding=math.ceil(stride / 2) ), ResUnit(out_ch, 1), ResUnit(out_ch, 3), ResUnit(out_ch, 9), ) def forward(self, x): return self.layers(x) class VAEBottleneck(nn.Module): def encode(self, x): mean, scale = x.chunk(2, dim=1) return mean def decode(self, x): return x class _SeqWrap(nn.Module): """Wraps Sequential as .layers so state_dict keys match AIO format.""" def __init__(self, *modules): super().__init__() self.layers = nn.Sequential(*modules) def forward(self, x): return self.layers(x) class OobleckVAE(nn.Module): def __init__( self, in_ch=2, channels=128, latent_dim=64, c_mults=(1, 2, 4, 8, 16), strides=(2, 4, 4, 6, 10), ): super().__init__() cm = [1] + list(c_mults) # Encoder enc = [WNConv1d(in_ch, cm[0] * channels, 7, padding=3)] for i in range(len(cm) - 1): enc.append(EncBlock(cm[i] * channels, cm[i + 1] * channels, strides[i])) enc += [ SnakeBeta(cm[-1] * channels), WNConv1d(cm[-1] * channels, latent_dim * 2, 3, padding=1), ] self.encoder = _SeqWrap(*enc) # Decoder dec = [WNConv1d(latent_dim, cm[-1] * channels, 7, padding=3)] for i in range(len(cm) - 1, 0, -1): dec.append(DecBlock(cm[i] * channels, cm[i - 1] * channels, strides[i - 1])) dec += [ SnakeBeta(cm[0] * channels), WNConv1d(cm[0] * channels, in_ch, 7, padding=3, bias=False), ] self.decoder = _SeqWrap(*dec) self.bottleneck = VAEBottleneck() self.upscale_factor = math.prod(strides) def encode(self, x): return self.bottleneck.encode(self.encoder(x)) def decode(self, x): return self.decoder(self.bottleneck.decode(x)) def tiled_decode(self, x, tile_seconds=10.0, overlap_seconds=1.0): """VRAM-light decode: split the latent into ~tile_seconds tiles with overlap_seconds of overlap, decode each tile independently, and linearly crossfade the overlapping audio regions.""" z = self.bottleneck.decode(x) tile_frames = max(1, round(tile_seconds * LATENT_RATE)) overlap_frames = max(1, round(overlap_seconds * LATENT_RATE)) if overlap_frames >= tile_frames: raise ValueError("overlap_seconds must be smaller than tile_seconds") T = z.shape[-1] if T <= tile_frames: return self.decoder(z) step = tile_frames - overlap_frames fade_len = overlap_frames * self.upscale_factor out_T = T * self.upscale_factor out = None ramp = None write_pos = 0 for i, start in enumerate(range(0, T, step)): end = min(start + tile_frames, T) decoded = self.decoder(z[..., start:end]) if out is None: out = decoded.new_zeros(decoded.shape[0], decoded.shape[1], out_T) ramp = torch.linspace(0, 1, fade_len, device=decoded.device, dtype=decoded.dtype) if i == 0: n = decoded.shape[-1] out[..., :n] = decoded write_pos = n else: blend_start = write_pos - fade_len out[..., blend_start:blend_start + fade_len] = ( out[..., blend_start:blend_start + fade_len] * (1 - ramp) + decoded[..., :fade_len] * ramp ) tail = decoded.shape[-1] - fade_len out[..., write_pos:write_pos + tail] = decoded[..., fade_len:] write_pos += tail if end == T: break return out[..., :write_pos] @property def device(self): return next(self.parameters()).device @property def dtype(self): return next(self.parameters()).dtype # ═══════════════════════════════════════════════════════════════════════════════ # Text encoder (Qwen3-Embedding, just need embed_tokens + model) # ═══════════════════════════════════════════════════════════════════════════════ class TextEncoder(nn.Module): """Wraps Qwen3 weights loaded from AIO. Forward returns last_hidden_state.""" def __init__(self, qwen_model): super().__init__() self.model = qwen_model # the inner model (layers, norm, embed_tokens) def encode_text(self, input_ids): return self.model(input_ids=input_ids).last_hidden_state def encode_lyrics(self, input_ids): return self.model.embed_tokens(input_ids) @property def device(self): return next(self.parameters()).device @property def dtype(self): return next(self.parameters()).dtype # ═══════════════════════════════════════════════════════════════════════════════ # Loading # ═══════════════════════════════════════════════════════════════════════════════ def infer_dit_config(dit_sd): """Infer model config from DiT state dict tensor shapes.""" # hidden_size from decoder norm hidden = dit_sd["decoder.scale_shift_table"].shape[2] # intermediate_size from MLP gate_proj inter = dit_sd["decoder.layers.0.mlp.gate_proj.weight"].shape[0] # num_heads from q_proj: q_proj.weight is [num_heads * head_dim, hidden] q_size = dit_sd["decoder.layers.0.self_attn.q_proj.weight"].shape[0] # head_dim from q_norm head_dim = dit_sd["decoder.layers.0.self_attn.q_norm.weight"].shape[0] heads = q_size // head_dim # num_kv_heads from k_proj k_size = dit_sd["decoder.layers.0.self_attn.k_proj.weight"].shape[0] kv = k_size // head_dim # num_dit_layers: count unique layer indices n_dit = ( max(int(k.split(".")[2]) for k in dit_sd if k.startswith("decoder.layers.")) + 1 ) # encoder hidden (may differ from decoder hidden for XL models) enc_hidden = dit_sd["encoder.text_projector.weight"].shape[0] # encoder layers n_lyric = ( max( int(k.split(".")[3]) for k in dit_sd if k.startswith("encoder.lyric_encoder.layers.") ) + 1 ) n_timbre = ( max( int(k.split(".")[3]) for k in dit_sd if k.startswith("encoder.timbre_encoder.layers.") ) + 1 ) # encoder attention config enc_heads = ( dit_sd["encoder.lyric_encoder.layers.0.self_attn.q_proj.weight"].shape[0] // head_dim ) enc_kv = ( dit_sd["encoder.lyric_encoder.layers.0.self_attn.k_proj.weight"].shape[0] // head_dim ) enc_inter = dit_sd["encoder.lyric_encoder.layers.0.mlp.gate_proj.weight"].shape[0] config = dict( hidden=hidden, inter=inter, heads=heads, kv=kv, head_dim=head_dim, n_dit=n_dit, n_lyric=n_lyric, n_timbre=n_timbre, enc_hidden=enc_hidden, enc_heads=enc_heads, enc_kv=enc_kv, enc_inter=enc_inter, ) print( f" Detected config: hidden={hidden}, inter={inter}, heads={heads}, kv={kv}, " f"n_dit={n_dit}, enc_hidden={enc_hidden}" ) return config def load_models(checkpoint_path, device="cuda", dtype=torch.bfloat16): if not os.path.isfile(checkpoint_path): raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}") print(f"Loading from: {checkpoint_path}") sd = load_file(checkpoint_path) # --- DiT --- print(" Loading DiT...") dit_sd = { k.removeprefix("model.diffusion_model."): v for k, v in sd.items() if k.startswith("model.diffusion_model.") } cfg = infer_dit_config(dit_sd) model = AceStep15( hidden=cfg["hidden"], inter=cfg["inter"], heads=cfg["heads"], kv=cfg["kv"], head_dim=cfg["head_dim"], n_dit=cfg["n_dit"], n_lyric=cfg["n_lyric"], n_timbre=cfg["n_timbre"], enc_hidden=cfg["enc_hidden"], enc_heads=cfg["enc_heads"], enc_kv=cfg["enc_kv"], enc_inter=cfg["enc_inter"], ) missing, unexpected = model.load_state_dict(dit_sd, strict=False) # tokenizer/detokenizer keys are expected to be unused (cover mode only) unexpected = [ k for k in unexpected if not k.startswith(("tokenizer.", "detokenizer.")) ] if missing: print(f" DiT missing: {len(missing)} (first 3: {missing[:3]})") if unexpected: print(f" DiT unexpected: {len(unexpected)} (first 3: {unexpected[:3]})") model = model.to(device).to(dtype).eval() # --- VAE --- print(" Loading VAE...") vae_sd = {k.removeprefix("vae."): v for k, v in sd.items() if k.startswith("vae.")} vae = OobleckVAE() m, u = vae.load_state_dict(vae_sd, strict=False) if m: print(f" VAE missing: {len(m)} (first 3: {m[:3]})") if u: print(f" VAE unexpected: {len(u)}") vae = vae.to(device).to(dtype).eval() # --- Text encoder (Qwen3-Embedding from AIO) --- print(" Loading text encoder...") te_sd = { k.removeprefix("text_encoders.qwen3_06b.transformer.model."): v for k, v in sd.items() if k.startswith("text_encoders.qwen3_06b.transformer.model.") } # Load Qwen3 model structure from transformers, then override weights from transformers import Qwen3Model, Qwen3Config qwen_cfg = Qwen3Config( vocab_size=151669, hidden_size=1024, intermediate_size=3072, num_hidden_layers=28, num_attention_heads=16, num_key_value_heads=8, head_dim=128, max_position_embeddings=32768, rms_norm_eps=1e-6, ) qwen = Qwen3Model(qwen_cfg) m2, u2 = qwen.load_state_dict(te_sd, strict=False) if m2: print(f" TE missing: {len(m2)} (first 3: {m2[:3]})") te = TextEncoder(qwen).to(device).to(dtype).eval() # Tokenizer — download from HF print(" Loading tokenizer...") tok = AutoTokenizer.from_pretrained( "Qwen/Qwen3-Embedding-0.6B", trust_remote_code=False ) del sd # free memory torch.cuda.empty_cache() if torch.cuda.is_available() else None print(" Done.\n") return dict( model=model, vae=vae, text_encoder=te, tokenizer=tok, device=device, dtype=dtype ) # ═══════════════════════════════════════════════════════════════════════════════ # Inference # ═══════════════════════════════════════════════════════════════════════════════ @torch.inference_mode() def get_latent(audio_path, models): """Encode audio file to VAE latent. Returns [1, 64, T] tensor.""" vae, device, dtype = models["vae"], models["device"], models["dtype"] wav, sr = torchaudio.load(audio_path) if sr != SAMPLE_RATE: wav = torchaudio.functional.resample(wav, sr, SAMPLE_RATE) if wav.shape[0] == 1: wav = wav.repeat(2, 1) elif wav.shape[0] > 2: wav = wav[:2] return vae.encode(wav.unsqueeze(0).to(device, dtype)) # [1, 64, T] @torch.inference_mode() def generate( models, prompt, lyrics="", duration=30.0, seed=42, bpm="N/A", key="N/A", time_sig="N/A", language="en", timesteps=None, guidance_scale=1.0, ): model = models["model"] vae = models["vae"] te = models["text_encoder"] tok = models["tokenizer"] device = models["device"] dtype = models["dtype"] t_sched = timesteps latent_len = int(duration * LATENT_RATE) print( f"Duration: {duration}s -> {latent_len} latent frames, {len(t_sched)} steps" + (f", CFG={guidance_scale}" if guidance_scale > 1.0 else "") ) # Silence as source latent [1, 64, T] -> [1, T, 64] for DiT sil = get_silence_latent(latent_len, device, dtype) # [1, 64, T] src = sil.transpose(1, 2) # [1, T, 64] chunk_masks = torch.ones_like(src) # Text encoding metas = f"- bpm: {bpm}\n- timesignature: {time_sig}\n- keyscale: {key}\n- duration: {int(duration)} seconds\n" caption = SFT_PROMPT.format( instruction="Fill the audio semantic mask based on the given conditions:", caption=prompt, metas=metas, ) lyrics_text = f"# Languages\n{language}\n\n# Lyric\n{lyrics}<|endoftext|>" cap_tok = tok(caption, truncation=True, max_length=256, return_tensors="pt") lyr_tok = tok(lyrics_text, truncation=True, max_length=2048, return_tensors="pt") text_h = te.encode_text(cap_tok.input_ids.to(device)).to(dtype) text_m = cap_tok.attention_mask.to(device).bool() lyric_h = te.encode_lyrics(lyr_tok.input_ids.to(device)).to(dtype) lyric_m = lyr_tok.attention_mask.to(device).bool() # Reference audio (silence) ref = sil[:, :, :750].transpose(1, 2) # [1, 750, 64] ref_order = torch.zeros(1, device=device, dtype=torch.long) # Prepare conditions (conditional) print("Preparing conditions...") enc_h, enc_m, ctx = model.prepare_condition( text_h, text_m, lyric_h, lyric_m, ref, ref_order, src, chunk_masks ) # Prepare unconditional conditions for CFG use_cfg = guidance_scale > 1.0 enc_h_uncond = None if use_cfg: enc_h_uncond = model.null_condition_emb.expand_as(enc_h) # Noise gen = torch.Generator(device=device).manual_seed(seed) noise_ch = ctx.shape[-1] // 2 xt = torch.randn(1, latent_len, noise_ch, generator=gen, device=device, dtype=dtype) # Diffusion print("Running diffusion...") t0 = time.time() t_sched_t = torch.tensor(t_sched, device=device, dtype=dtype) attn = torch.ones(1, latent_len, device=device, dtype=dtype) for i in range(len(t_sched_t)): tv = t_sched_t[i].item() tt = torch.full((1,), tv, device=device, dtype=dtype) vt_cond = model.decoder(xt, tt, tt, attn, enc_h, enc_m, ctx) if use_cfg: vt_uncond = model.decoder(xt, tt, tt, attn, enc_h_uncond, enc_m, ctx) vt = vt_uncond + guidance_scale * (vt_cond - vt_uncond) else: vt = vt_cond if i == len(t_sched_t) - 1: xt = xt - vt * tv else: xt = xt - vt * (tv - t_sched_t[i + 1].item()) print(f"Diffusion: {time.time() - t0:.2f}s") # VAE decode print("Decoding audio...") t0 = time.time() wav = vae.decode(xt.transpose(1, 2)) # [1, 2, samples] wav = wav[0, :, : int(duration * SAMPLE_RATE)] print(f"VAE decode: {time.time() - t0:.2f}s") return wav.cpu().float() # ═══════════════════════════════════════════════════════════════════════════════ # CLI # ═══════════════════════════════════════════════════════════════════════════════ def main(): p = argparse.ArgumentParser(description="ACE-Step v1.5 standalone inference") p.add_argument("--prompt", required=True) p.add_argument("--lyrics", default="") p.add_argument("--duration", type=float, default=30.0) p.add_argument("--output", default="output.wav") p.add_argument("--seed", type=int, default=42) p.add_argument( "--model", default="base", choices=["base", "turbo"], help="Model variant (default: base)", ) p.add_argument( "--checkpoint", default=None, help="Override path to AIO .safetensors" ) p.add_argument("--device", default=None) p.add_argument( "--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"] ) p.add_argument("--bpm", default="N/A") p.add_argument("--key", default="N/A") p.add_argument("--time-sig", default="N/A") p.add_argument("--language", default="en") p.add_argument( "--steps", type=int, default=None, help="Diffusion steps (default: 30 for base, 8 for turbo)", ) p.add_argument( "--shift", type=float, default=3.0, help="Timestep shift (default: 3.0)" ) p.add_argument( "--cfg", type=float, default=None, help="CFG guidance scale (default: 3.5 for base, 1.0 for turbo)", ) args = p.parse_args() device = args.device or ( "cuda" if torch.cuda.is_available() else "mps" if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available() else "cpu" ) dtype = { "bfloat16": torch.bfloat16, "float16": torch.float16, "float32": torch.float32, }[args.dtype] if device == "mps": dtype = torch.float32 lyrics = args.lyrics if lyrics.startswith("@") and os.path.isfile(lyrics[1:]): lyrics = open(lyrics[1:]).read() else: lyrics = lyrics.replace("\\n", "\n") # Model-specific defaults is_turbo = args.model == "turbo" ckpt = args.checkpoint or MODEL_PATHS[args.model] steps = args.steps or (8 if is_turbo else 30) cfg = args.cfg if args.cfg is not None else (1.0 if is_turbo else 3.5) # Timestep schedule if is_turbo and steps == 8: ts = TURBO_TIMESTEPS.get(args.shift, TURBO_TIMESTEPS[3.0]) else: ts = compute_timesteps(steps, args.shift) print( f"ACE-Step v1.5 ({args.model}) | {device} ({dtype}) | seed={args.seed} | {args.duration}s | {steps} steps | CFG={cfg}" ) models = load_models(ckpt, device, dtype) wav = generate( models, args.prompt, lyrics, args.duration, args.seed, args.bpm, args.key, args.time_sig, args.language, ts, cfg, ) os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True) torchaudio.save(args.output, wav, SAMPLE_RATE) print(f"Saved: {args.output} ({wav.shape[1] / SAMPLE_RATE:.1f}s stereo)") if __name__ == "__main__": main()