#!/usr/bin/env python3 import argparse import shutil import subprocess import tempfile from pathlib import Path from uuid import uuid4 import numpy as np import torch from scipy.io import wavfile from tqdm import tqdm from utils import * MODEL_MAP = { "base": "ACE-Step/acestep-v15-base", "turbo": "ACE-Step/Ace-Step1.5", } def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--variant", choices=["base", "turbo"], default="turbo") parser.add_argument("--target", type=int, default=2000) parser.add_argument( "--output-dir", type=Path, default=None, help="Default: FAKE_DIR/A_opensource/acestep_1.5_{variant}", ) parser.add_argument( "--batch-size", type=int, default=2, help="Recommended 1-2 on 24GB VRAM; use smaller values for base model", ) parser.add_argument("--device", choices=["cuda", "cpu"], default="cuda") return parser.parse_args() def to_int16(audio: np.ndarray): audio = np.nan_to_num(audio.astype(np.float32), nan=0.0, posinf=0.0, neginf=0.0) peak = np.max(np.abs(audio)) if audio.size else 0.0 if peak > 1.0: audio = audio / peak return np.int16(np.clip(audio, -1.0, 1.0) * 32767) def try_build_pipeline(model_id: str, device: str): try: from transformers import pipeline use_cuda = device == "cuda" and torch.cuda.is_available() device_index = 0 if use_cuda else -1 return pipeline("text-to-audio", model=model_id, device=device_index, trust_remote_code=True) except Exception: return None def extract_audio_from_pipeline_output(output): if isinstance(output, list): output = output[0] if isinstance(output, dict): audio = output.get("audio") sr = int(output.get("sampling_rate", 32000)) if audio is None: return None, None return np.array(audio), sr return None, None def ensure_repo(models_dir: Path) -> Path: repo_dir = models_dir / "ACE-Step-1.5" if repo_dir.exists(): return repo_dir models_dir.mkdir(parents=True, exist_ok=True) cmd = ["git", "clone", "https://github.com/ace-step/ACE-Step-1.5", str(repo_dir)] subprocess.run(cmd, check=True) return repo_dir def run_cli_fallback( repo_dir: Path, prompt: str, output_path: Path, model_id: str, device: str ) -> bool: with tempfile.TemporaryDirectory() as tmp_dir: tmp_dir_path = Path(tmp_dir) candidates = [ [ "python", "infer.py", "--prompt", prompt, "--output", str(tmp_dir_path), "--model", model_id, "--device", device, ], [ "python", "inference.py", "--prompt", prompt, "--output_dir", str(tmp_dir_path), "--model_id", model_id, "--device", device, ], ] for cmd in candidates: proc = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True) if proc.returncode != 0: continue generated = sorted( list(tmp_dir_path.rglob("*.wav")) + list(tmp_dir_path.rglob("*.mp3")), key=lambda p: p.stat().st_mtime, ) if generated: shutil.move(str(generated[-1]), str(output_path)) return True return False def main(): args = parse_args() device = "cuda" if args.device == "cuda" and torch.cuda.is_available() else "cpu" model_id = MODEL_MAP[args.variant] output_dir = args.output_dir or ( FAKE_DIR / "A_opensource" / f"acestep_1.5_{args.variant}" ) output_dir.mkdir(parents=True, exist_ok=True) if not ensure_disk_space(): raise RuntimeError("Insufficient disk space before generation start.") meta_mgr = MetadataManager(output_dir) existing = meta_mgr.get_count() if existing >= args.target: print(f"Target already reached: {existing}/{args.target}") return prompts = get_diverse_prompts(args.target) pipe = try_build_pipeline(model_id, device) repo_dir = None if pipe is None: repo_dir = ensure_repo(BASE_DIR / "models") progress = tqdm( total=args.target, initial=existing, desc=f"ACE-Step-{args.variant}" ) generated_this_run = 0 for idx in range(existing, args.target): prompt = prompts[idx] track_id = str(uuid4()) filename = f"{track_id}.wav" file_path = output_dir / filename ok = False if pipe is not None: try: output = pipe(prompt) audio, sr = extract_audio_from_pipeline_output(output) if audio is not None and sr is not None and audio.size > 0: if audio.ndim > 1: audio = np.mean(audio, axis=0) wavfile.write(file_path, int(sr), to_int16(audio)) ok = True except Exception: ok = False if not ok: if repo_dir is None: repo_dir = ensure_repo(BASE_DIR / "models") ok = run_cli_fallback(repo_dir, prompt, file_path, model_id, device) if not ok or not file_path.exists(): continue info = get_audio_info(file_path) if ( not info or info.get("duration_sec", 0.0) <= 0.5 or info.get("file_size_bytes", 0) <= 1024 ): file_path.unlink(missing_ok=True) continue md5_hash = compute_md5(file_path) meta = TrackMetadata( track_id=track_id, filename=filename, category="A_opensource", subcategory=f"acestep_1.5_{args.variant}", source_platform="acestep", source_type="open-source", model_name="ACE-Step", model_version=f"1.5-{args.variant}", collection_method="generate", audio_format=file_path.suffix.lstrip(".") or "wav", prompt=prompt, md5_hash=md5_hash, duration_sec=info.get("duration_sec"), sample_rate=info.get("sample_rate"), channels=info.get("channels"), bitrate_kbps=info.get("bitrate_kbps"), file_size_bytes=info.get("file_size_bytes"), ) meta_mgr.add_track(meta) generated_this_run += 1 progress.update(1) if meta_mgr.get_count() % 50 == 0: if not ensure_disk_space(): meta_mgr.update_summary() raise RuntimeError("Low disk space, stopping generation.") meta_mgr.update_summary() if meta_mgr.get_count() >= args.target: break meta_mgr.update_summary() progress.close() print( f"Generated {generated_this_run} tracks. Total: {meta_mgr.get_count()}/{args.target}" ) if __name__ == "__main__": main()