scripts/generation/generate_musicgen.py

#!/usr/bin/env python3

import argparse
from pathlib import Path
from typing import Any
from uuid import uuid4

import numpy as np
import torch
from scipy.io import wavfile
from tqdm import tqdm
from transformers import AutoProcessor, MusicgenForConditionalGeneration

from utils import *


MODEL_MAP = {
    "small": "facebook/musicgen-small",
    "medium": "facebook/musicgen-medium",
    "large": "facebook/musicgen-large",
}


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--variant", choices=["small", "medium", "large"], default="small"
    )
    parser.add_argument("--target", type=int, default=2000)
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=None,
        help="Default: FAKE_DIR/A_opensource/musicgen_{variant}",
    )
    parser.add_argument(
        "--batch-size",
        type=int,
        default=8,
        help="Recommended: 8 (small), 4 (medium), 2 (large) on 24GB VRAM",
    )
    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 main():
    args = parse_args()
    device = "cuda" if args.device == "cuda" and torch.cuda.is_available() else "cpu"

    output_dir = args.output_dir or (
        FAKE_DIR / "A_opensource" / f"musicgen_{args.variant}"
    )
    output_dir.mkdir(parents=True, exist_ok=True)

    if not ensure_disk_space():
        raise RuntimeError("Insufficient disk space before generation start.")

    model_id = MODEL_MAP[args.variant]
    processor: Any = AutoProcessor.from_pretrained(model_id)
    model: Any = MusicgenForConditionalGeneration.from_pretrained(model_id)
    model.to(device)
    sampling_rate = int(model.config.audio_encoder.sampling_rate)

    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)

    progress = tqdm(
        total=args.target, initial=existing, desc=f"MusicGen-{args.variant}"
    )
    generated_this_run = 0

    for batch_start in range(existing, args.target, max(1, args.batch_size)):
        batch_prompts = prompts[
            batch_start : min(args.target, batch_start + max(1, args.batch_size))
        ]
        model_inputs = processor(text=batch_prompts, padding=True, return_tensors="pt")
        model_inputs = {k: v.to(device) for k, v in model_inputs.items()}

        with torch.inference_mode():
            generated = model.generate(**model_inputs, max_new_tokens=1503)

        wav_batch = torch.as_tensor(generated).detach().cpu().numpy()

        for i, prompt in enumerate(batch_prompts):
            waveform = wav_batch[i]
            if waveform.ndim > 1:
                waveform = np.mean(waveform, axis=0)

            track_id = str(uuid4())
            filename = f"{track_id}.wav"
            file_path = output_dir / filename
            wavfile.write(file_path, sampling_rate, to_int16(waveform))

            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"musicgen_{args.variant}",
                source_platform="musicgen",
                source_type="open-source",
                model_name="MusicGen",
                model_version=args.variant,
                collection_method="generate",
                audio_format="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

        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()