Upload 3 files

README.md

@@ -1,16 +1,33 @@
 ---
-title: image
-emoji: 📈
-colorFrom: pink
-colorTo: yellow
+title: ZeroGPU Strip Bench
+emoji: ⏱️
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.20.0
-python_version: '3.12'
+python_version: "3.10"
 app_file: app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ZeroGPU strip-pass benchmark (throwaway test app)
+
+Standalone benchmark to measure real timing of the vocal-isolation pass — the
+same model the live Voice Remover's Step 1 uses
+(`mel_band_roformer_vocals_becruily`) — on this Space's ZeroGPU hardware.
+
+Not connected to the production site, its password gate, or its backend.
+Purpose is purely to get real load-time / inference-time numbers before
+deciding whether ZeroGPU is worth building into the actual product.
+
+## Use
+
+Upload a song, click "Run strip pass". Reports model-load time, separation
+time, total, the GPU name, and an estimate of how many runs the 2-min/day free
+IP-based quota buys per visitor (excludes any per-region splits on top).
+
+## Deploy
+
+Space hardware must be set to ZeroGPU and SDK to Gradio (already required for
+`spaces.GPU` to work at all — Docker/Static Spaces can't schedule onto
+ZeroGPU). Upload `app.py`, `requirements.txt`, and this `README.md` to the
+Space's file root.

app.py

@@ -1,52 +1,100 @@
+"""ZeroGPU strip-pass benchmark — throwaway test app.
+
+Standalone Gradio app, NOT part of the production site. Runs the exact same
+vocal-isolation model the live Voice Remover's Step 1 uses
+(mel_band_roformer_vocals_becruily) and times it on this Space's ZeroGPU
+hardware, so we can decide with real numbers whether ZeroGPU is viable as a
+backend before touching anything production-facing.
+
+Deploy: create/point a ZeroGPU-hardware Space at this folder (sdk: gradio,
+see README.md). Upload a song, click "Run strip pass".
+"""
 import os
-import gradio as gr
+import time
+import traceback
+from pathlib import Path
+
 import spaces
+import gradio as gr
 import torch
-from diffusers import DiffusionPipeline
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Automatically grab the token you saved in the Space settings
-hf_token = os.getenv("HF_TOKEN")
-
-# Pass the token explicitly into the from_pretrained function
-pipe = DiffusionPipeline.from_pretrained(
-    "black-forest-labs/FLUX.1-schnell", 
-    torch_dtype=torch.bfloat16,
-    token=hf_token
-)
-pipe.to(device)
-
-@spaces.GPU
-def generate_image(prompt):
-    image = pipe(
-        prompt, 
-        num_inference_steps=4, 
-        guidance_scale=0.0,
-        max_sequence_length=256
-    ).images[0]
-    return image
-
-# (Rest of your Gradio interface layout remains exactly the same!)
-with gr.Blocks() as demo:
-    gr.Markdown("# ⚡ ZeroGPU Fast Image Generator")
-    gr.Markdown("Using `FLUX.1-schnell` for ultra-fast, high-quality rendering.")
-    
-    with gr.Row():
-        with gr.Column():
-            prompt_input = gr.Textbox(
-                label="Enter your prompt", 
-                placeholder="A futuristic cybernetic cat sitting on a neon rooftop...",
-                lines=3
-            )
-            generate_btn = gr.Button("Generate", variant="primary")
-        with gr.Column():
-            image_output = gr.Image(label="Resulting Image")
-            
-    generate_btn.click(
-        fn=generate_image,
-        inputs=prompt_input,
-        outputs=image_output
+import torchaudio
+from audio_separator.separator import Separator
+
+MODELS_DIR = Path(os.environ.get("MODELS_DIR", "/tmp/models"))
+MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+# Same model the live site's Step 1 ("Isolate vocals — becruily") uses.
+VOCAL_MODEL = "mel_band_roformer_vocals_becruily.ckpt"
+
+# Fetch the checkpoint once at Space startup — CPU-only, no GPU needed — so the
+# timed run below measures disk->GPU load, not an internet download.
+print(f"[startup] fetching {VOCAL_MODEL} ...", flush=True)
+_warm = Separator(output_dir="/tmp", model_file_dir=str(MODELS_DIR))
+_warm.load_model(model_filename=VOCAL_MODEL)
+del _warm
+print("[startup] model cached on disk.", flush=True)
+
+
+def _normalize(src: str) -> str:
+    """Approximates production's _normalize_for_sep (stereo / 32-bit float /
+    min 30s) so the timed input shape matches what RoFormer sees live."""
+    wf, sr = torchaudio.load(src)
+    if wf.shape[0] == 1:
+        wf = wf.repeat(2, 1)
+    elif wf.shape[0] > 2:
+        wf = wf[:2]
+    min_samples = sr * 30
+    if wf.shape[1] < min_samples:
+        pad = torch.zeros(wf.shape[0], min_samples - wf.shape[1], dtype=wf.dtype)
+        wf = torch.cat([wf, pad], dim=1)
+    out = "/tmp/_bench_input.wav"
+    torchaudio.save(out, wf, sr, encoding="PCM_F", bits_per_sample=32)
+    return out
+
+
+@spaces.GPU(duration=110)
+def run_benchmark(song_path):
+    if song_path is None:
+        return "Upload a song first."
+
+    try:
+        gpu_name = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "no GPU visible"
+
+        t0 = time.perf_counter()
+        sep = Separator(output_dir="/tmp", output_format="WAV", model_file_dir=str(MODELS_DIR))
+        sep.load_model(model_filename=VOCAL_MODEL)
+        t1 = time.perf_counter()
+
+        sep_input = _normalize(song_path)
+        out_names = sep.separate(sep_input)
+        t2 = time.perf_counter()
+
+        load_s, sep_s, total_s = t1 - t0, t2 - t1, t2 - t0
+        runs_per_day = max(1, int(120 // total_s)) if total_s > 0 else "?"
+
+        return (
+            f"GPU: {gpu_name}\n\n"
+            f"Model load + move-to-device: {load_s:.1f}s\n"
+            f"Separation (inference):      {sep_s:.1f}s\n"
+            f"Total:                       {total_s:.1f}s\n\n"
+            f"Output stems: {out_names}\n\n"
+            f"2 min/day free quota ÷ this total ≈ {runs_per_day} run(s)/day per visitor "
+            f"(before counting any region splits on top of this strip pass)."
+        )
+    except Exception:
+        return "Error:\n" + traceback.format_exc()
+
+
+with gr.Blocks(title="ZeroGPU strip-pass benchmark") as demo:
+    gr.Markdown(
+        "### ZeroGPU strip-pass benchmark\n"
+        "Throwaway test app — not the production site. Upload a song and run "
+        "the same vocal-isolation model the live site's Step 1 uses, timed on "
+        "this Space's GPU, to get real numbers on whether ZeroGPU is viable."
     )
+    audio_in = gr.Audio(label="Song", type="filepath")
+    run_btn = gr.Button("Run strip pass", variant="primary")
+    result = gr.Textbox(label="Timing", lines=9)
+    run_btn.click(fn=run_benchmark, inputs=audio_in, outputs=result)
 
-demo.launch()
+demo.launch()

requirements.txt

@@ -1,8 +1,10 @@
-gradio
-spaces
-torch
-transformers
-diffusers
-accelerate
-sentencepiece
-protobuf
+torch==2.5.1
+torchaudio==2.5.1
+numpy>=2.0,<2.1
+numba>=0.60
+audio-separator==0.44.2
+pyyaml==6.0.3
+soundfile==0.13.1
+librosa==0.11.0
+scipy==1.15.3
+certifi