Deploy Stable Audio 3 editing endpoint

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+.DS_Store
+.ruff_cache/
+.venv/

README.md

@@ -0,0 +1,24 @@
+---
+title: Stable Audio 3
+emoji: 🎛️
+colorFrom: indigo
+colorTo: gray
+sdk: gradio
+sdk_version: 5.28.0
+python_version: '3.10'
+app_file: app.py
+pinned: false
+license: other
+short_description: Edit, inpaint, and continue music audio from text prompts
+startup_duration_timeout: 1h
+models:
+- stabilityai/stable-audio-3-small-music
+---
+
+HARP endpoint for editing music with Stable Audio 3 Small-Music. The endpoint
+supports prompt-guided restyling, region inpainting, and continuation of an
+uploaded music clip.
+
+Model access is governed by the Stability AI Community License and the Gemma
+Terms of Use. Source and license details are recorded in `SOURCES.md` and
+`THIRD_PARTY_NOTICES.md`.

SOURCES.md

@@ -0,0 +1,22 @@
+# Sources
+
+## Stable Audio 3
+
+- Source: https://github.com/Stability-AI/stable-audio-3
+- Source revision: `124e8a799f57a1f665495ecb72e547d0a62867f1`
+- Source license: MIT
+- Model: https://huggingface.co/stabilityai/stable-audio-3-small-music
+- Model revision: `0fef1392cd842149a2b6d445e181c97608faac06`
+- Model license: Stability AI Community License
+- Paper: https://arxiv.org/abs/2605.17991
+
+## Runtime
+
+- Source: https://github.com/Stability-AI/stable-audio-tools
+- Source revision: `3241adba4fc2a85cf5b29d9eb68d42f40a28e820`
+- Source license: MIT
+
+The Space installs the runtime source without dependencies because its package
+metadata fixes an older Torch version. Runtime dependencies are declared
+separately in `requirements.txt` to remain compatible with Hugging Face
+ZeroGPU and pyHARP.

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,34 @@
+# Third-Party Notices
+
+## Stable Audio 3 Source Code
+
+The Stable Audio 3 source code is provided by Stability AI under the MIT
+License:
+
+https://github.com/Stability-AI/stable-audio-3
+
+## Stable Audio Tools
+
+The Stable Audio Tools runtime is provided by Stability AI under the MIT
+License:
+
+https://github.com/Stability-AI/stable-audio-tools
+
+## Stable Audio 3 Small-Music Weights
+
+The model weights are governed by the Stability AI Community License:
+
+https://huggingface.co/stabilityai/stable-audio-3-small-music
+
+https://stability.ai/license
+
+Access to the model repository requires accepting its terms on Hugging Face.
+
+## T5Gemma
+
+Stable Audio 3 Small-Music includes a T5Gemma text-conditioning component
+redistributed under the Gemma Terms of Use:
+
+https://huggingface.co/google/t5gemma-b-b-ul2
+
+https://ai.google.dev/gemma/terms

app.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import gradio as gr
+import soundfile as sf
+
+try:
+    import spaces
+except ImportError:
+    class spaces:
+        class GPU:
+            def __init__(self, func=None, duration=180):
+                self.func = func
+
+            def __call__(self, *args, **kwargs):
+                if self.func is not None:
+                    return self.func(*args, **kwargs)
+                return args[0]
+
+from pyharp import ModelCard, build_endpoint
+
+from stable_audio_runtime import edit_audio
+
+MIN_AUDIO_SECONDS = 5
+MAX_AUDIO_SECONDS = 30
+
+model_card = ModelCard(
+    name="Stable Audio 3",
+    description=(
+        "Restyle, inpaint, or continue music audio using a text prompt."
+    ),
+    author="Stability AI",
+    tags=[
+        "audio-generation",
+        "music-editing",
+        "audio-inpainting",
+        "audio-continuation",
+    ],
+)
+
+
+def _audio_duration(path: str | None) -> float:
+    if not path:
+        raise gr.Error("Please upload a music clip.")
+    try:
+        duration = float(sf.info(path).duration)
+    except Exception as exc:
+        raise gr.Error(f"Could not read the audio file: {exc}") from exc
+    if duration < MIN_AUDIO_SECONDS:
+        raise gr.Error(f"Audio must be at least {MIN_AUDIO_SECONDS} seconds.")
+    if duration > MAX_AUDIO_SECONDS:
+        raise gr.Error(f"Audio must be no longer than {MAX_AUDIO_SECONDS} seconds.")
+    return duration
+
+
+@spaces.GPU(duration=180)
+def process_fn(
+    audio_path: str | None,
+    prompt: str,
+    mode: str,
+    edit_start: float,
+    edit_end: float,
+    continuation_length: float,
+    strength: float,
+    seed: int,
+) -> str:
+    duration = _audio_duration(audio_path)
+    prompt = (prompt or "").strip()
+    if not prompt:
+        raise gr.Error("Please enter an editing prompt.")
+
+    if mode == "Inpaint" and (
+        edit_start < 0 or edit_end > duration or edit_end <= edit_start
+    ):
+        raise gr.Error(
+            "The inpaint region must be inside the uploaded clip, "
+            "with the end after the start."
+        )
+
+    try:
+        return edit_audio(
+            audio_path=audio_path,
+            prompt=prompt,
+            mode=mode,
+            edit_start=float(edit_start),
+            edit_end=float(edit_end),
+            continuation_length=float(continuation_length),
+            strength=float(strength),
+            seed=int(seed),
+        )
+    except gr.Error:
+        raise
+    except Exception as exc:
+        raise gr.Error(f"Stable Audio 3 inference failed: {exc}") from exc
+
+
+with gr.Blocks(title="Stable Audio 3") as demo:
+    input_components = [
+        gr.Audio(type="filepath", label="Music Audio")
+        .harp_required(True)
+        .set_info("Music clip between 5 and 30 seconds."),
+        gr.Textbox(
+            label="Prompt",
+            placeholder="A warm synthwave groove with punchy drums",
+        ).harp_required(True),
+        gr.Dropdown(
+            choices=["Restyle", "Inpaint", "Continue"],
+            value="Restyle",
+            label="Edit Mode",
+        ),
+        gr.Slider(
+            minimum=0,
+            maximum=30,
+            value=4,
+            step=0.1,
+            label="Edit Start (seconds)",
+        ).set_info("Used by Inpaint mode."),
+        gr.Slider(
+            minimum=0,
+            maximum=30,
+            value=8,
+            step=0.1,
+            label="Edit End (seconds)",
+        ).set_info("Used by Inpaint mode."),
+        gr.Slider(
+            minimum=1,
+            maximum=15,
+            value=8,
+            step=1,
+            label="Continuation Length (seconds)",
+        ).set_info("Used by Continue mode."),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.75,
+            step=0.05,
+            label="Transformation Strength",
+        ).set_info("Used by Restyle mode."),
+        gr.Slider(
+            minimum=0,
+            maximum=99999,
+            value=0,
+            step=1,
+            label="Seed",
+        ).set_info("Use 0 for a random seed."),
+    ]
+    output_components = [
+        gr.Audio(type="filepath", label="Edited Audio"),
+    ]
+    build_endpoint(
+        model_card=model_card,
+        input_components=input_components,
+        output_components=output_components,
+        process_fn=process_fn,
+    )
+
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=1).launch(
+        show_error=True,
+        pwa=True,
+        ssr_mode=False,
+    )

model.json

@@ -0,0 +1,30 @@
+{
+  "name": "Stable Audio 3 Small-Music",
+  "task": [
+    "audio-to-audio editing",
+    "audio inpainting",
+    "audio continuation"
+  ],
+  "source": {
+    "repo": "Stability-AI/stable-audio-3",
+    "revision": "124e8a799f57a1f665495ecb72e547d0a62867f1",
+    "license": "MIT"
+  },
+  "runtime": {
+    "repo": "Stability-AI/stable-audio-tools",
+    "revision": "3241adba4fc2a85cf5b29d9eb68d42f40a28e820",
+    "license": "MIT"
+  },
+  "model": {
+    "repo": "stabilityai/stable-audio-3-small-music",
+    "revision": "0fef1392cd842149a2b6d445e181c97608faac06",
+    "license": "Stability AI Community License"
+  },
+  "limits": {
+    "input_seconds": {
+      "minimum": 5,
+      "maximum": 30
+    },
+    "maximum_continuation_seconds": 15
+  }
+}

requirements.txt

@@ -0,0 +1,26 @@
+gradio==5.28.0
+torch==2.8.0
+torchaudio==2.8.0
+numpy<2
+soundfile>=0.13.1
+einops>=0.8.2
+einops-exts>=0.0.4
+alias-free-torch==0.0.6
+dill>=0.4
+huggingface-hub>=1.7.1,<2
+importlib-resources>=5.12
+k-diffusion==0.1.1
+nnAudio
+PyWavelets>=1.6,<2
+pytorch-lightning==2.5.5
+safetensors>=0.7.0
+scipy
+sentencepiece>=0.2,<1
+setuptools<81
+soxr
+torchsde
+tqdm
+transformers>=5.8.0,<6
+v-diffusion-pytorch==0.0.2
+vector-quantize-pytorch==1.14.41
+git+https://github.com/TEAMuP-dev/pyharp.git@d65c4f7d0264dcdb3024a6c5466cddd7b2defdca

stable_audio_runtime.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+from pathlib import Path
+
+MODEL_REPO = "stabilityai/stable-audio-3-small-music"
+MODEL_REVISION = "0fef1392cd842149a2b6d445e181c97608faac06"
+STABLE_AUDIO_TOOLS_REVISION = "3241adba4fc2a85cf5b29d9eb68d42f40a28e820"
+OUTPUT_ROOT = Path(tempfile.gettempdir()) / "stable_audio_3_outputs"
+
+_MODEL = None
+_MODEL_CONFIG = None
+_MODEL_LOCK = threading.Lock()
+
+
+def _ensure_stable_audio_tools() -> None:
+    try:
+        import stable_audio_tools  # noqa: F401
+
+        return
+    except ImportError:
+        pass
+
+    subprocess.check_call(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--quiet",
+            "--no-deps",
+            (
+                "git+https://github.com/Stability-AI/stable-audio-tools.git@"
+                f"{STABLE_AUDIO_TOOLS_REVISION}"
+            ),
+        ]
+    )
+
+
+def _load_model():
+    global _MODEL, _MODEL_CONFIG
+    if _MODEL is not None:
+        return _MODEL, _MODEL_CONFIG
+
+    with _MODEL_LOCK:
+        if _MODEL is not None:
+            return _MODEL, _MODEL_CONFIG
+
+        _ensure_stable_audio_tools()
+        token = os.environ.get("HF_TOKEN")
+        if not token:
+            raise RuntimeError("The HF_TOKEN Space secret is not configured.")
+
+        import torch
+        from stable_audio_tools.models import pretrained
+
+        original_download = pretrained.hf_hub_download
+
+        def pinned_download(repo_id, *args, **kwargs):
+            if repo_id == MODEL_REPO:
+                kwargs.setdefault("revision", MODEL_REVISION)
+                kwargs.setdefault("token", token)
+            return original_download(repo_id, *args, **kwargs)
+
+        pretrained.hf_hub_download = pinned_download
+        try:
+            model, config = pretrained.get_pretrained_model(MODEL_REPO)
+        finally:
+            pretrained.hf_hub_download = original_download
+
+        model = model.to("cuda").to(torch.float16)
+        model.eval().requires_grad_(False)
+        _MODEL = model
+        _MODEL_CONFIG = config
+        return _MODEL, _MODEL_CONFIG
+
+
+def _load_audio(path: str):
+    import torch
+    import torchaudio
+
+    audio, sample_rate = torchaudio.load(path)
+    if audio.shape[0] > 2:
+        audio = audio[:2]
+    return int(sample_rate), audio.to(torch.float32)
+
+
+def _save_audio(output, sample_rate: int) -> str:
+    import soundfile as sf
+    import torch
+
+    output = output.permute(1, 0, 2).reshape(output.shape[1], -1)
+    output = output.to(torch.float32)
+    peak = output.abs().max().clamp(min=1e-9)
+    output = output.div(peak).clamp(-1, 1).cpu().numpy().T
+
+    OUTPUT_ROOT.mkdir(parents=True, exist_ok=True)
+    output_dir = Path(tempfile.mkdtemp(dir=OUTPUT_ROOT))
+    output_path = output_dir / "stable_audio_3_edit.wav"
+    sf.write(output_path, output, sample_rate, subtype="PCM_16")
+    return str(output_path)
+
+
+def edit_audio(
+    audio_path: str,
+    prompt: str,
+    mode: str,
+    edit_start: float,
+    edit_end: float,
+    continuation_length: float,
+    strength: float,
+    seed: int,
+) -> str:
+    import torch
+    import torchaudio
+
+    model, config = _load_model()
+    from stable_audio_tools.inference.generation import (
+        generate_diffusion_cond_inpaint,
+    )
+    sample_rate = int(config["sample_rate"])
+    sample_size = int(config["sample_size"])
+    source_rate, source = _load_audio(audio_path)
+    source_duration = source.shape[-1] / source_rate
+
+    if source_rate != sample_rate:
+        source = torchaudio.functional.resample(source, source_rate, sample_rate)
+    model_dtype = next(model.parameters()).dtype
+    source_tuple = (sample_rate, source.to(model_dtype))
+
+    if mode == "Continue":
+        output_duration = source_duration + continuation_length
+    else:
+        output_duration = source_duration
+
+    conditioning = [{"prompt": prompt, "seconds_total": output_duration}]
+    kwargs = {
+        "steps": 8,
+        "cfg_scale": 1.0,
+        "conditioning": conditioning,
+        "sample_size": sample_size,
+        "sampler_type": "pingpong",
+        "seed": int(seed) if seed > 0 else -1,
+        "device": "cuda",
+        "sigma_max": 1.0,
+        "apg_scale": 1.0,
+        "duration_padding_sec": 6.0,
+    }
+
+    if mode == "Restyle":
+        kwargs["init_audio"] = source_tuple
+        kwargs["init_noise_level"] = float(strength)
+    elif mode == "Inpaint":
+        kwargs["inpaint_audio"] = source_tuple
+        kwargs["inpaint_mask_start_seconds"] = float(edit_start)
+        kwargs["inpaint_mask_end_seconds"] = float(edit_end)
+    elif mode == "Continue":
+        kwargs["inpaint_audio"] = source_tuple
+        kwargs["inpaint_mask_start_seconds"] = float(source_duration)
+        kwargs["inpaint_mask_end_seconds"] = float(output_duration)
+    else:
+        raise ValueError(f"Unknown edit mode: {mode}")
+
+    with torch.inference_mode():
+        output = generate_diffusion_cond_inpaint(model, **kwargs)
+
+    output = output[..., : int(output_duration * sample_rate)]
+    return _save_audio(output, sample_rate)