testing org anyaccomp implementation

README.md

@@ -4,8 +4,8 @@ emoji: 🎵
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 5.28.0
-python_version: '3.13'
+sdk_version: 4.44.1
+python_version: '3.11'
 app_file: app.py
 pinned: false
 license: mit

app.py

@@ -1,105 +1,169 @@
+import spaces
+import torch
 import os
-import tempfile
-
+import random
 import librosa
 import numpy as np
 import soundfile as sf
-import torch
 import gradio as gr
-
+import time
 from huggingface_hub import snapshot_download
-from pyharp import ModelCard, build_endpoint
 
 from anyaccomp.inference_utils import Sing2SongInferencePipeline
 
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-SAMPLE_RATE = 24000
+repo_id = "amphion/anyaccomp"
+base_dir = os.path.dirname(os.path.abspath(__file__))
+
+print(f"Downloading model files from {repo_id}...")
+model_dir = snapshot_download(repo_id=repo_id, local_dir=base_dir)
+print(f"Model files downloaded to: {model_dir}")
+
+CFG_PATH = os.path.join(base_dir, "config/flow_matching.json")
+VOCODER_CFG_PATH = os.path.join(base_dir, "config/vocoder.json")
+CHECKPOINT_PATH = os.path.join(model_dir, "pretrained/flow_matching")
+VOCODER_CHECKPOINT_PATH = os.path.join(model_dir, "pretrained/vocoder")
+
+INFER_DST = os.path.join(base_dir, "output_gradio")
+os.makedirs(INFER_DST, exist_ok=True)
+acc_dst = os.path.join(INFER_DST, "accompaniment")
+mixture_dst = os.path.join(INFER_DST, "mixture")
+os.makedirs(acc_dst, exist_ok=True)
+os.makedirs(mixture_dst, exist_ok=True)
+
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Download the pretrained checkpoints the first time this Space starts up.
-# The repo lays them out under pretrained/, which matches what the config files expect.
-if not os.path.exists(os.path.join(BASE_DIR, "pretrained", "flow_matching")):
-    snapshot_download(
-        repo_id="amphion/anyaccomp",
-        local_dir=BASE_DIR,
-        repo_type="model",
-        ignore_patterns=["README.md", "*.txt", ".gitattributes"],
+print("Initializing AnyAccomp InferencePipeline...")
+try:
+    inference_pipeline = Sing2SongInferencePipeline(
+        CHECKPOINT_PATH,
+        CFG_PATH,
+        VOCODER_CHECKPOINT_PATH,
+        VOCODER_CFG_PATH,
+        device=DEVICE,
     )
+    inference_pipeline.sample_rate = 24000
+    print("Model loaded successfully.")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    inference_pipeline = None
+
+
+@spaces.GPU
+def sing2song_inference(vocal_filepath, n_timesteps, cfg_scale, seed):
+    if inference_pipeline is None:
+        raise gr.Error("Model could not be loaded. Please check paths and environment configuration.")
+
+    if vocal_filepath is None:
+        raise gr.Error("Please upload a vocal audio file.")
+
+    if seed == -1 or seed is None:
+        seed = random.randint(0, 2**32 - 1)
+
+    seed = int(seed)
+    print(f"Using seed: {seed}")
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+
+    try:
+        duration = librosa.get_duration(path=vocal_filepath)
+        if not (3 <= duration <= 30):
+            raise gr.Error("Audio duration must be between 3 and 30 seconds.")
+    except Exception as e:
+        raise gr.Error(f"Cannot read audio file or get duration: {e}")
 
-# Load all three model components once at startup so they're warm for every request.
-pipeline = Sing2SongInferencePipeline(
-    checkpoint_path=os.path.join(BASE_DIR, "pretrained", "flow_matching"),
-    cfg_path=os.path.join(BASE_DIR, "config", "flow_matching.json"),
-    vocoder_checkpoint_path=os.path.join(BASE_DIR, "pretrained", "vocoder"),
-    vocoder_cfg_path=os.path.join(BASE_DIR, "config", "vocoder.json"),
-    device=DEVICE,
-)
-
-
-@torch.inference_mode()
-def process_fn(audio_path, n_timesteps, cfg_scale):
-    # Validate length before doing anything expensive.
-    duration = librosa.get_duration(path=audio_path)
-    if not (3 <= duration <= 30):
-        raise gr.Error("Audio must be between 3 and 30 seconds long.")
-
-    # Load the vocal and encode it into discrete chromagram tokens.
-    vocal_audio, _ = librosa.load(audio_path, sr=SAMPLE_RATE, mono=True)
-    vocal_tensor = torch.tensor(vocal_audio).unsqueeze(0).to(DEVICE)
-    vocal_mel = pipeline.encode_vocal(vocal_tensor)
-
-    # Run the flow-matching diffusion to generate the accompaniment mel spectrogram.
-    with torch.amp.autocast("cuda", dtype=torch.bfloat16):
-        mel = pipeline.model.reverse_diffusion(
-            vocal_mel=vocal_mel,
-            n_timesteps=int(n_timesteps),
-            cfg=cfg_scale,
-        )
-
-    # Decode mel → waveform, then trim/pad so it lines up with the input.
-    wav = pipeline._generate_audio(mel.float())
-    wav = wav.squeeze().detach().cpu().numpy()
-    wav = librosa.util.fix_length(data=wav, size=len(vocal_audio))
-
-    # Write to a temp file; Gradio expects a file path back.
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-        out_path = f.name
-    sf.write(out_path, wav, SAMPLE_RATE)
-    return out_path
-
-
-model_card = ModelCard(
-    name="AnyAccomp",
-    description="Generates musical accompaniment from a 3-30 second vocal or instrument track.",
-    author="Amphion Team",
-    tags=["accompaniment generation", "music generation"],
-)
-
-with gr.Blocks() as demo:
-    audio_input = gr.Audio(
-        type="filepath",
-        label="Input Vocal or Instrument Audio (3-30 seconds)",
-    ).harp_required(True)
-
-    n_timesteps_slider = gr.Slider(
-        minimum=10, maximum=100, value=50, step=1,
-        label="Inference Steps",
+    try:
+        vocal_audio, _ = librosa.load(vocal_filepath, sr=24000, mono=True)
+        vocal_tensor = torch.tensor(vocal_audio).unsqueeze(0).to(DEVICE)
+
+        vocal_mel = inference_pipeline.encode_vocal(vocal_tensor)
+
+        with torch.cuda.amp.autocast(dtype=torch.bfloat16):
+            mel = inference_pipeline.model.reverse_diffusion(
+                vocal_mel=vocal_mel,
+                n_timesteps=int(n_timesteps),
+                cfg=cfg_scale,
+            )
+
+        mel = mel.float()
+        wav = inference_pipeline._generate_audio(mel)
+        wav = wav.squeeze().detach().cpu().numpy()
+
+        wav = librosa.util.fix_length(data=wav, size=len(vocal_audio))
+        mixture_wav = wav + vocal_audio
+
+        timestamp = int(time.time())
+        original_filename = os.path.basename(vocal_filepath)
+        base_filename = f"{os.path.splitext(original_filename)[0]}_{timestamp}.wav"
+
+        accompaniment_path = os.path.join(acc_dst, base_filename)
+        mixture_path = os.path.join(mixture_dst, base_filename)
+
+        sf.write(accompaniment_path, wav, 24000)
+        sf.write(mixture_path, mixture_wav, 24000)
+
+        return accompaniment_path, mixture_path, "Status: Complete!"
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise gr.Error(f"An error occurred during processing: {e}")
+
+
+def randomize_seed():
+    return random.randint(0, 2**32 - 1)
+
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # AnyAccomp: GENERALIZABLE ACCOMPANIMENT GENERATION
+        Upload a 3-30 second vocal or instrument track (.wav or .mp3) and the model will generate an accompaniment for it.
+        """
     )
-    cfg_slider = gr.Slider(
-        minimum=1.0, maximum=10.0, value=3.0, step=0.1,
-        label="CFG Scale",
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Upload Audio")
+            vocal_input = gr.Audio(
+                type="filepath",
+                label="Upload Vocal or Instrument Audio",
+                sources=["upload", "microphone"],
+            )
+
+            gr.Markdown("### 2. Adjust Parameters (Optional)")
+            with gr.Accordion("Advanced Settings", open=True):
+                n_timesteps_slider = gr.Slider(
+                    minimum=10, maximum=100, value=50, step=1,
+                    label="Inference Steps (n_timesteps)",
+                )
+                cfg_slider = gr.Slider(
+                    minimum=1.0, maximum=10.0, value=3.0, step=0.1,
+                    label="CFG Scale",
+                )
+                with gr.Row():
+                    seed_input = gr.Number(value=-1, label="Seed (-1 for random)", precision=0)
+                    random_seed_btn = gr.Button("🎲")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Generate and Listen")
+            status_text = gr.Markdown("Status: Ready")
+            accompaniment_output = gr.Audio(label="Generated Accompaniment", type="filepath")
+            mixture_output = gr.Audio(label="Mixture (Vocal + Accompaniment)", type="filepath")
+            submit_btn = gr.Button("Generate Accompaniment", variant="primary")
+
+    submit_btn.click(
+        fn=sing2song_inference,
+        inputs=[vocal_input, n_timesteps_slider, cfg_slider, seed_input],
+        outputs=[accompaniment_output, mixture_output, status_text],
     )
 
-    accompaniment_output = gr.Audio(
-        type="filepath",
-        label="Generated Accompaniment",
-    ).set_info("Generated accompaniment track for the input audio.")
+    random_seed_btn.click(fn=randomize_seed, inputs=None, outputs=seed_input)
 
-    build_endpoint(
-        model_card=model_card,
-        input_components=[audio_input, n_timesteps_slider, cfg_slider],
-        output_components=[accompaniment_output],
-        process_fn=process_fn,
-    )
 
-demo.queue().launch(show_error=True, pwa=True, ssr_mode=False)
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -1,12 +1,11 @@
-git+https://github.com/TEAMuP-dev/pyharp.git#egg=pyharp
+spaces
 torch==2.11.0
 torchaudio==2.11.0
-numpy<2.0
+numpy==1.26.4
 huggingface_hub
 librosa
 soundfile
-accelerate
+accelerate==1.6.0
 json5
 einops
-transformers
-# do not include gradio — pyharp pins it to 5.28.0
+transformers==4.47.1