scripts/generation/generate_acestep.py

#!/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()