Fix HF Space build: drop audiocraft, transformers-native MusicGen, fix launch() args

.gitignore

@@ -19,3 +19,8 @@ flagged/
 *.safetensors
 .DS_Store
 Thumbs.db
+
+# business files that do NOT belong in a public hackathon Space
+*.pdf
+umbra-ai-architecture.md
+memory-audit-*.md

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: yellow
 sdk: gradio
 sdk_version: 6.16.0
-python_version: '3.12'
+python_version: '3.10'
 app_file: app.py
 pinned: false
 license: mit

app.py

@@ -1,6 +1,8 @@
 import gradio as gr
 import os
 import tempfile
+import numpy as np
+import soundfile as sf
 from analyze import fingerprint, find_key, get_tempo, get_duration
 
 try:
@@ -157,6 +159,7 @@ def analyze_track(audio):
             make_stat_html("tempo", "---"),
             make_stat_html("duration", "---"),
             gr.update(visible=False),
+            None,
             None
         )
 
@@ -165,14 +168,36 @@ def analyze_track(audio):
         key_html = make_stat_html("key", info["key"])
         bpm_html = make_stat_html("tempo", str(info["bpm"]) + " bpm")
         dur_html = make_stat_html("duration", str(info["duration"]) + "s")
-        return (key_html, bpm_html, dur_html, gr.update(visible=True), audio)
+        return (key_html, bpm_html, dur_html, gr.update(visible=True), audio, info)
     except Exception as e:
         err = make_stat_html("error", str(e)[:50])
-        return (err, make_stat_html("tempo", "---"), make_stat_html("duration", "---"), gr.update(visible=False), None)
+        return (err, make_stat_html("tempo", "---"), make_stat_html("duration", "---"), gr.update(visible=False), None, None)
 
 
-def placeholder_continue(audio_path):
-    return "continuation coming soon. MusicGen pipeline lands on Day 2."
+@spaces.GPU(duration=180)
+def run_continuation(audio_path, info):
+    if not audio_path:
+        return None, "upload a track first."
+
+    try:
+        # lazy import so the UI boots fast and torch only loads on demand
+        import librosa
+        from continue_music import continue_track, stitch_with_crossfade
+
+        key = info.get("key") if info else None
+        bpm = info.get("bpm") if info else None
+
+        continuation, sr = continue_track(audio_path, key=key, bpm=bpm)
+        original, _ = librosa.load(audio_path, sr=sr, mono=True)
+        full = stitch_with_crossfade(original, continuation, sr)
+
+        out_path = os.path.join(tempfile.mkdtemp(), "coda_continuation.wav")
+        sf.write(out_path, full, sr)
+
+        added = len(continuation) / sr
+        return out_path, f"added {added:.1f}s. seam crossfaded at {len(original)/sr:.1f}s."
+    except Exception as e:
+        return None, f"continuation failed: {str(e)[:200]}"
 
 
 HEADER_HTML = (
@@ -191,9 +216,10 @@ FOOTER_HTML = (
 )
 
 
-with gr.Blocks(title="CODA") as app:
+with gr.Blocks(title="CODA", css=CUSTOM_CSS, theme=gr.themes.Base()) as app:
 
     current_track = gr.State(None)
+    track_info = gr.State(None)
 
     gr.HTML(HEADER_HTML)
 
@@ -214,22 +240,24 @@ with gr.Blocks(title="CODA") as app:
     with gr.Group(elem_classes="continue-panel", visible=False) as continue_section:
         gr.HTML('<div class="tape-deco" style="margin-bottom:12px;">continue</div>')
         continue_btn = gr.Button("continue this track", variant="primary")
+        result_audio = gr.Audio(label="finished track", type="filepath", interactive=False)
         continue_output = gr.Textbox(label="status", interactive=False, lines=2)
 
     audio_input.change(
         fn=analyze_track,
         inputs=[audio_input],
-        outputs=[key_display, bpm_display, dur_display, continue_section, current_track]
+        outputs=[key_display, bpm_display, dur_display, continue_section, current_track, track_info]
     )
 
     continue_btn.click(
-        fn=placeholder_continue,
-        inputs=[current_track],
-        outputs=[continue_output]
+        fn=run_continuation,
+        inputs=[current_track, track_info],
+        outputs=[result_audio, continue_output]
     )
 
     gr.HTML(FOOTER_HTML)
 
 
 if __name__ == "__main__":
-    app.launch(css=CUSTOM_CSS, theme=gr.themes.Base())
+    app.launch()
+

continue_music.py

@@ -1,56 +1,119 @@
+import numpy as np
 import torch
 import torchaudio
-from audiocraft.models import MusicGen
+from transformers import AutoProcessor, MusicgenForConditionalGeneration
 
 
+# transformers-native MusicGen. the audiocraft package is abandoned and
+# hard-pins torch==2.1.0 / xformers<0.0.23, which breaks the HF Space build
+# against gradio 6.x. transformers supports audio-prompted continuation
+# directly, so we don't need audiocraft at all.
+
+MODEL_ID = "facebook/musicgen-large"
+MUSICGEN_SR = 32000
+FRAME_RATE = 50  # musicgen decoder tokens per second
+
 _model = None
+_processor = None
 
 
 def _load_model():
-    global _model
+    global _model, _processor
     if _model is None:
-        _model = MusicGen.get_pretrained('facebook/musicgen-large')
-    return _model
-
+        _processor = AutoProcessor.from_pretrained(MODEL_ID)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        dtype = torch.float16 if device == "cuda" else torch.float32
+        _model = MusicgenForConditionalGeneration.from_pretrained(
+            MODEL_ID, torch_dtype=dtype
+        ).to(device)
+        _model.eval()
+    return _model, _processor
 
-def continue_track(path, prompt_duration=10, gen_duration=15, key=None, bpm=None):
-    """
-    takes the last `prompt_duration` seconds of the input track
-    and generates `gen_duration` seconds of continuation.
-    key and bpm are hints for the text prompt.
-    """
-    model = _load_model()
-    model.set_generation_params(duration=gen_duration)
 
+def _load_tail(path, prompt_duration):
+    """load audio, return mono 32kHz numpy tail of `prompt_duration` seconds."""
     track, sr = torchaudio.load(path)
 
-    # grab the tail end as context
-    tail_samples = int(prompt_duration * sr)
+    if sr != MUSICGEN_SR:
+        track = torchaudio.transforms.Resample(sr, MUSICGEN_SR)(track)
+
+    if track.shape[0] > 1:
+        track = track.mean(dim=0, keepdim=True)
+
+    tail_samples = int(prompt_duration * MUSICGEN_SR)
     if track.shape[1] > tail_samples:
-        tail = track[:, -tail_samples:]
-    else:
-        tail = track
+        track = track[:, -tail_samples:]
+
+    return track.squeeze(0).numpy()
 
-    # resample to 32kHz if needed (musicgen expects this)
-    if sr != 32000:
-        resampler = torchaudio.transforms.Resample(sr, 32000)
-        tail = resampler(tail)
 
-    # mono
-    if tail.shape[0] > 1:
-        tail = tail.mean(dim=0, keepdim=True)
+def continue_track(path, prompt_duration=10, gen_duration=15, key=None, bpm=None):
+    """
+    takes the last `prompt_duration` seconds of the input track and
+    generates `gen_duration` seconds of continuation.
+    returns (continuation_only as 1-D float32 numpy, sample_rate).
+    """
+    model, processor = _load_model()
 
-    tail = tail.unsqueeze(0)  # batch dim
+    tail = _load_tail(path, prompt_duration)
 
-    # build a natural description
     desc = "continue this song"
     if key and bpm:
-        desc = f"continue this song in {key} at {bpm} bpm"
+        desc = f"continue this song in {key} at {round(bpm)} bpm"
     elif key:
         desc = f"continue this song in {key}"
 
+    inputs = processor(
+        audio=tail,
+        sampling_rate=MUSICGEN_SR,
+        text=[desc],
+        padding=True,
+        return_tensors="pt",
+    ).to(model.device)
+
+    # cast audio prompt to model dtype (fp16 on gpu)
+    if "input_values" in inputs:
+        inputs["input_values"] = inputs["input_values"].to(model.dtype)
+
     with torch.no_grad():
-        output = model.generate_continuation(tail, 32000, [desc])
+        output = model.generate(
+            **inputs,
+            do_sample=True,
+            guidance_scale=3.0,
+            max_new_tokens=int(gen_duration * FRAME_RATE),
+        )
+
+    audio = output[0, 0].float().cpu().numpy()
+
+    # generate_continuation-style output contains the prompt audio at the
+    # start; trim it so we return only the new material.
+    if audio.shape[0] > tail.shape[0]:
+        audio = audio[tail.shape[0]:]
+
+    return audio, MUSICGEN_SR
+
+
+def stitch_with_crossfade(original, continuation, sr, fade_seconds=0.5):
+    """
+    join original track and continuation with an equal-power crossfade
+    so the seam doesn't click. both inputs 1-D numpy at the same sr.
+    """
+    fade = int(fade_seconds * sr)
+    fade = min(fade, len(original), len(continuation))
+    if fade <= 0:
+        return np.concatenate([original, continuation])
+
+    t = np.linspace(0.0, np.pi / 2, fade, dtype=np.float32)
+    fade_out = np.cos(t)
+    fade_in = np.sin(t)
+
+    head = original[:-fade]
+    seam = original[-fade:] * fade_out + continuation[:fade] * fade_in
+    rest = continuation[fade:]
+
+    out = np.concatenate([head, seam, rest]).astype(np.float32)
+    peak = np.abs(out).max()
+    if peak > 1.0:
+        out = out / peak
+    return out
 
-    result = output[0].cpu()
-    return result, 32000

packages.txt

@@ -1,8 +1 @@
 ffmpeg
-libavformat-dev
-libavcodec-dev
-libavdevice-dev
-libavutil-dev
-libavfilter-dev
-libswscale-dev
-libswresample-dev

requirements.txt

@@ -1,13 +1,11 @@
-gradio>=5.0.0
-torch>=2.1.0
-torchaudio>=2.1.0
+torch>=2.4.0
+torchaudio>=2.4.0
+transformers>=4.51.0,<5
+accelerate>=0.26.0
+sentencepiece
 librosa>=0.10.2
-numpy>=1.24.0
+numpy>=1.24.0,<2.0
 soundfile>=0.12.1
 Pillow>=10.0.0
-transformers>=4.51.0
-accelerate>=0.26.0
+demucs>=4.0.1
 spaces
-av
-audiocraft
-demucs