Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* 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
+samples/1089/mgm_omni_clean.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/moss_ttsd_clean.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/moss_ttsd_safespeech.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/protected_grnoise.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/protected_safespeech.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/reference.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/styletts2_clean.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/styletts2_safespeech.wav filter=lfs diff=lfs merge=lfs -text
+samples/1089/target.wav filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,31 @@
 ---
-title: RVCBench
-emoji: 🌖
-colorFrom: indigo
-colorTo: red
+title: RVCBench — Voice Cloning & Protection Demo
+emoji: 🎙️
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: "4.44.0"
 app_file: app.py
-pinned: false
+pinned: true
+license: cc0-1.0
+short_description: Voice cloning attacks vs. audio protection methods
+tags:
+  - audio
+  - voice-cloning
+  - text-to-speech
+  - speaker-privacy
+  - audio-deepfake
+  - adversarial-audio
+  - benchmark
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RVCBench Demo
+
+Interactive demo for the [RVCBench](https://github.com/Nanboy-Ronan/RVCBench) benchmark.
+
+Explore how modern voice cloning models can replicate a speaker's voice — and how audio
+protection methods disrupt that cloning.
+
+**Paper:** [arXiv:2602.00443](https://arxiv.org/abs/2602.00443)  
+**Dataset:** [Nanboy/RVCBench](https://huggingface.co/datasets/Nanboy/RVCBench)  
+**Code:** [Nanboy-Ronan/RVCBench](https://github.com/Nanboy-Ronan/RVCBench)

app.py

@@ -0,0 +1,399 @@
+"""RVCBench — Interactive HuggingFace Space demo.
+
+Tabs
+────
+1. Voice Cloning Gallery   – hear pre-computed clean vs. protected clones
+2. Protect Your Voice      – upload audio, apply a protection method live, compare
+3. Leaderboard             – sortable benchmark results table
+"""
+
+from __future__ import annotations
+
+import io
+import os
+import time
+
+import gradio as gr
+import numpy as np
+import soundfile as sf
+
+# ── paths ────────────────────────────────────────────────────────────────────
+
+SAMPLES = os.path.join(os.path.dirname(__file__), "samples", "1089")
+
+REF_WAV    = os.path.join(SAMPLES, "reference.wav")
+TARGET_WAV = os.path.join(SAMPLES, "target.wav")
+REF_TEXT   = "But her long fair hair was girlish: and girlish, and touched with the wonder of mortal beauty, her face."
+TARGET_TEXT = "A great fisher of souls!"
+
+MODELS = {
+    "ZipVoice (SIM 0.579)":   ("zipvoice_clean.wav",   "zipvoice_safespeech.wav"),
+    "MOSS-TTSD (SIM 0.492)":  ("moss_ttsd_clean.wav",  "moss_ttsd_safespeech.wav"),
+    "MGM-Omni (SIM 0.539)":   ("mgm_omni_clean.wav",   "mgm_omni_safespeech.wav"),
+    "OZSpeech (SIM 0.388)":   ("ozspeech_clean.wav",   "ozspeech_safespeech.wav"),
+    "StyleTTS 2 (SIM 0.228)": ("styletts2_clean.wav",  "styletts2_safespeech.wav"),
+}
+
+PROTECTION_SAMPLES = {
+    "SafeSpeech": "protected_safespeech.wav",
+    "GR-Noise":   "protected_grnoise.wav",
+}
+
+# ── leaderboard data ──────────────────────────────────────────────────────────
+
+LEADERBOARD = [
+    ["1", "Qwen3-TTS",    "0.614", "0.052", "4.39", "5.79", "2.02",  "0.974", "0.731"],
+    ["2", "IndexTTS",     "0.606", "0.052", "4.06", "6.61", "2.23",  "0.972", "0.693"],
+    ["3", "CosyVoice 2",  "0.602", "0.175", "4.39", "6.17", "4.58",  "0.974", "0.729"],
+    ["4", "ZipVoice",     "0.579", "0.053", "4.13", "7.09", "1.46",  "0.952", "0.675"],
+    ["5", "MaskGCT",      "0.570", "0.088", "3.93", "6.91", "1.36",  "0.939", "0.682"],
+    ["6", "GLM-TTS",      "0.570", "0.087", "4.08", "6.41", "1.74",  "0.951", "0.678"],
+    ["7", "F5-TTS",       "0.559", "0.116", "3.99", "6.96", "0.61",  "0.937", "0.676"],
+    ["8", "Higgs Audio",  "0.559", "0.250", "4.30", "6.06", "1.42",  "0.941", "0.717"],
+    ["9", "MGM-Omni",     "0.539", "0.095", "4.28", "5.82", "0.84",  "0.933", "0.676"],
+    ["10","PlayDiffusion","0.506", "0.055", "4.15", "8.06", "0.73",  "0.936", "0.681"],
+    ["11","MOSS-TTSD",    "0.492", "0.383", "4.10", "7.09", "—",     "0.876", "0.667"],
+    ["12","VibeVoice",    "0.480", "0.228", "3.83", "6.76", "1.86",  "0.852", "0.624"],
+    ["13","FishSpeech",   "0.472", "0.166", "4.37", "6.47", "3.61",  "0.907", "0.682"],
+    ["14","XTTS-v2",      "0.454", "0.073", "3.81", "8.62", "0.62",  "0.908", "0.639"],
+    ["15","SparkTTS",     "0.408", "0.326", "4.06", "5.83", "1.56",  "0.764", "0.672"],
+    ["16","OZSpeech",     "0.388", "0.060", "3.21", "6.87", "8.75",  "0.840", "0.636"],
+    ["17","OpenVoice V2", "0.244", "0.075", "4.30", "7.06", "0.08",  "0.474", "0.601"],
+    ["18","StyleTTS 2",   "0.228", "0.049", "4.30", "6.81", "0.11",  "0.388", "0.589"],
+]
+
+HEADERS = ["#", "Model", "SIM ↑", "WER ↓", "MOS ↑", "MCD ↓", "RTF ↓", "SVA ↑", "Emo ↑"]
+
+# ── protection helpers ────────────────────────────────────────────────────────
+
+def _load(path: str) -> tuple[np.ndarray, int]:
+    audio, sr = sf.read(path, dtype="float32")
+    if audio.ndim > 1:
+        audio = audio.mean(axis=1)
+    return audio, sr
+
+
+def _to_bytes(audio: np.ndarray, sr: int) -> bytes:
+    buf = io.BytesIO()
+    sf.write(buf, audio, sr, format="WAV", subtype="PCM_16")
+    buf.seek(0)
+    return buf.read()
+
+
+def _snr(original: np.ndarray, protected: np.ndarray) -> float:
+    noise = protected - original
+    signal_power = np.mean(original ** 2)
+    noise_power  = np.mean(noise ** 2)
+    if noise_power < 1e-12:
+        return float("inf")
+    return float(10 * np.log10(signal_power / noise_power))
+
+
+def apply_grnoise(audio: np.ndarray, sr: int, snr_db: float = 25.0) -> np.ndarray:
+    signal_power = np.mean(audio ** 2)
+    noise_power  = signal_power / (10 ** (snr_db / 10))
+    noise = np.random.randn(*audio.shape).astype(np.float32) * np.sqrt(noise_power)
+    return np.clip(audio + noise, -1.0, 1.0)
+
+
+def apply_spectral(audio: np.ndarray, sr: int, strength: float = 0.05) -> np.ndarray:
+    """Frequency-domain perturbation: add structured noise in the STFT domain."""
+    from numpy.fft import rfft, irfft
+    n_fft = 1024
+    hop   = n_fft // 4
+    frames = []
+    for start in range(0, len(audio) - n_fft, hop):
+        frame = audio[start:start + n_fft] * np.hanning(n_fft).astype(np.float32)
+        spec  = rfft(frame)
+        mag   = np.abs(spec)
+        perturb = np.random.randn(*mag.shape).astype(np.float32) * strength * mag
+        spec_p  = spec + perturb * np.exp(1j * np.random.uniform(0, 2 * np.pi, mag.shape))
+        frames.append((start, irfft(spec_p)))
+    out = np.zeros_like(audio)
+    cnt = np.zeros_like(audio)
+    for start, f in frames:
+        end = start + n_fft
+        out[start:end] += f[:n_fft].astype(np.float32)
+        cnt[start:end] += 1
+    cnt = np.maximum(cnt, 1)
+    return np.clip(out / cnt, -1.0, 1.0)
+
+
+PROTECT_FN = {
+    "GR-Noise":       apply_grnoise,
+    "Spectral":       apply_spectral,
+}
+
+# ── tab 1: gallery ────────────────────────────────────────────────────────────
+
+def load_gallery(model_label: str, protection: str):
+    clean_file, safe_file = MODELS[model_label]
+    prot_audio_file = PROTECTION_SAMPLES.get(protection)
+
+    ref_audio   = REF_WAV
+    target_audio = TARGET_WAV
+    clean_clone  = os.path.join(SAMPLES, clean_file)
+    prot_ref     = os.path.join(SAMPLES, prot_audio_file) if prot_audio_file else None
+    prot_clone   = os.path.join(SAMPLES, safe_file)
+
+    # Compute SIM drop note
+    clean_sim = float(model_label.split("SIM ")[-1].rstrip(")"))
+    sim_lookup = {
+        "ZipVoice (SIM 0.579)": {"SafeSpeech": 0.287, "GR-Noise": 0.258},
+        "MOSS-TTSD (SIM 0.492)": {"SafeSpeech": 0.242, "GR-Noise": 0.247},
+        "MGM-Omni (SIM 0.539)":  {"SafeSpeech": 0.184, "GR-Noise": 0.229},
+        "OZSpeech (SIM 0.388)":  {"SafeSpeech": 0.156, "GR-Noise": 0.148},
+        "StyleTTS 2 (SIM 0.228)": {"SafeSpeech": 0.089, "GR-Noise": 0.030},
+    }
+    prot_sim = sim_lookup.get(model_label, {}).get(protection, None)
+    drop = clean_sim - prot_sim if prot_sim else None
+
+    note_md = (
+        f"**Clean SIM:** {clean_sim:.3f} &nbsp;→&nbsp; "
+        f"**Protected SIM ({protection}):** {prot_sim:.3f} &nbsp;"
+        f"*(drop: {drop:.3f})*"
+        if drop is not None else ""
+    )
+
+    return (
+        ref_audio,
+        target_audio,
+        clean_clone,
+        prot_ref or gr.update(visible=False),
+        prot_clone,
+        note_md,
+    )
+
+# ── tab 2: live protection ────────────────────────────────────────────────────
+
+def run_protection(audio_input, method: str, strength: float):
+    if audio_input is None:
+        return None, None, "Upload an audio file first."
+
+    sr_in, data = audio_input
+    audio = data.astype(np.float32)
+    if audio.max() > 1.0:
+        audio = audio / 32768.0
+    if audio.ndim > 1:
+        audio = audio.mean(axis=1)
+
+    t0 = time.time()
+    fn = PROTECT_FN[method]
+    if method == "GR-Noise":
+        protected = fn(audio, sr_in, snr_db=strength)
+    else:
+        protected = fn(audio, sr_in, strength=strength / 100.0)
+    elapsed = time.time() - t0
+
+    snr = _snr(audio, protected)
+    protected_int = (protected * 32767).astype(np.int16)
+
+    metrics_md = (
+        f"| Metric | Value |\n|--------|-------|\n"
+        f"| SNR (dB) | {snr:.1f} |\n"
+        f"| Processing time | {elapsed*1000:.0f} ms |\n"
+        f"| Method | {method} |\n"
+    )
+
+    return (sr_in, audio.copy()), (sr_in, protected_int), metrics_md
+
+
+# ── build UI ──────────────────────────────────────────────────────────────────
+
+CSS = """
+#title { text-align: center; }
+.metric-box { font-size: 1.1em; }
+.tab-header { font-weight: bold; }
+footer { display: none !important; }
+"""
+
+INTRO_MD = """
+<div id="title">
+
+# RVCBench — Voice Cloning & Protection Demo
+
+**Can audio protection prevent your voice from being cloned?**
+This demo lets you hear the answer.
+
+[![Paper](https://img.shields.io/badge/arXiv-2602.00443-b31b1b.svg)](https://arxiv.org/abs/2602.00443)
+[![Dataset](https://img.shields.io/badge/HuggingFace-Dataset-ffcc00.svg)](https://huggingface.co/datasets/Nanboy/RVCBench)
+[![GitHub](https://img.shields.io/badge/GitHub-RVCBench-181717.svg)](https://github.com/Nanboy-Ronan/RVCBench)
+
+</div>
+"""
+
+GALLERY_MD = """
+**How it works:** A voice cloning model uses the *Reference Voice* to clone the *Target Speech*
+(what it wants the speaker to say). When protection is applied to the reference first,
+the clone degrades — the speaker sounds wrong or the speech becomes unintelligible.
+"""
+
+PROTECTION_MD = """
+Upload your own audio clip and apply a protection method in real-time.
+The protected audio sounds nearly identical to humans but disrupts voice cloning models.
+
+- **GR-Noise** — Gaussian random noise at a target SNR level. No surrogate model needed.
+- **Spectral** — Structured perturbation in the frequency domain.
+"""
+
+
+def build_demo():
+    with gr.Blocks(css=CSS, title="RVCBench Demo") as demo:
+        gr.Markdown(INTRO_MD)
+
+        with gr.Tabs():
+
+            # ── Tab 1: Gallery ──────────────────────────────────────────────
+            with gr.Tab("🎧  Voice Cloning Gallery"):
+                gr.Markdown(GALLERY_MD)
+
+                with gr.Row():
+                    model_dd = gr.Dropdown(
+                        choices=list(MODELS.keys()),
+                        value=list(MODELS.keys())[0],
+                        label="Voice Cloning Model",
+                        scale=2,
+                    )
+                    prot_dd = gr.Dropdown(
+                        choices=["SafeSpeech", "GR-Noise"],
+                        value="SafeSpeech",
+                        label="Protection Method",
+                        scale=1,
+                    )
+
+                sim_note = gr.Markdown("", elem_classes="metric-box")
+
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 1 · Reference Voice")
+                        gr.Markdown(f"*\"{REF_TEXT}\"*")
+                        ref_out    = gr.Audio(label="Reference (original)", interactive=False)
+                    with gr.Column():
+                        gr.Markdown("### 2 · Target Speech")
+                        gr.Markdown(f"*\"{TARGET_TEXT}\"*")
+                        target_out = gr.Audio(label="Target utterance", interactive=False)
+
+                gr.Markdown("---")
+                gr.Markdown("### Cloning Results")
+
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Without Protection")
+                        clean_out = gr.Audio(label="Clean clone (threat)", interactive=False)
+                    with gr.Column():
+                        gr.Markdown("#### With Protection")
+                        prot_ref_out   = gr.Audio(label="Protected reference", interactive=False)
+                        prot_clone_out = gr.Audio(label="Clone from protected (degraded)", interactive=False)
+
+                load_btn = gr.Button("Load Example", variant="primary")
+
+                load_btn.click(
+                    fn=load_gallery,
+                    inputs=[model_dd, prot_dd],
+                    outputs=[ref_out, target_out, clean_out, prot_ref_out, prot_clone_out, sim_note],
+                )
+                demo.load(
+                    fn=load_gallery,
+                    inputs=[model_dd, prot_dd],
+                    outputs=[ref_out, target_out, clean_out, prot_ref_out, prot_clone_out, sim_note],
+                )
+
+            # ── Tab 2: Live Protection ──────────────────────────────────────
+            with gr.Tab("🔒  Protect Your Voice"):
+                gr.Markdown(PROTECTION_MD)
+
+                with gr.Row():
+                    audio_in = gr.Audio(
+                        label="Upload your audio (wav / mp3, ≤ 30 s)",
+                        type="numpy",
+                        scale=3,
+                    )
+                    with gr.Column(scale=1):
+                        method_dd = gr.Dropdown(
+                            choices=list(PROTECT_FN.keys()),
+                            value="GR-Noise",
+                            label="Protection Method",
+                        )
+                        strength_sl = gr.Slider(
+                            minimum=10, maximum=40, value=25, step=1,
+                            label="Strength (SNR dB for GR-Noise; intensity × 100 for Spectral)",
+                            info="Lower = stronger protection, more audible artifacts.",
+                        )
+                        protect_btn = gr.Button("Apply Protection", variant="primary")
+
+                with gr.Row():
+                    orig_out   = gr.Audio(label="Original", interactive=False)
+                    prot_live  = gr.Audio(label="Protected", interactive=False)
+
+                metrics_out = gr.Markdown("", elem_classes="metric-box")
+
+                protect_btn.click(
+                    fn=run_protection,
+                    inputs=[audio_in, method_dd, strength_sl],
+                    outputs=[orig_out, prot_live, metrics_out],
+                )
+
+                gr.Markdown(
+                    "> **Note:** Live voice cloning inference is not included in this Space due to "
+                    "model size constraints. See the [GitHub repo](https://github.com/Nanboy-Ronan/RVCBench) "
+                    "for the full pipeline with 18+ VC models."
+                )
+
+            # ── Tab 3: Leaderboard ──────────────────────────────────────────
+            with gr.Tab("📊  Leaderboard"):
+                gr.Markdown(
+                    "### Benchmark Results — LibriTTS (clean prompts)\n"
+                    "Sorted by Speaker Similarity (SIM ↑). "
+                    "Full results including protection robustness and cross-dataset generalisation: "
+                    "[GitHub README](https://github.com/Nanboy-Ronan/RVCBench#benchmark-results).\n\n"
+                    "> **Metric guide** · SIM: speaker similarity ↑ · WER: word error rate ↓ · "
+                    "MOS: perceptual score ↑ · MCD: mel cepstral distortion ↓ · "
+                    "RTF: real-time factor ↓ · SVA: speaker verification accuracy ↑ · Emo: emotion match ↑"
+                )
+                gr.DataFrame(
+                    value=LEADERBOARD,
+                    headers=HEADERS,
+                    datatype=["number", "str"] + ["number"] * 7,
+                    interactive=False,
+                    wrap=False,
+                )
+
+            # ── Tab 4: About ────────────────────────────────────────────────
+            with gr.Tab("ℹ️  About"):
+                gr.Markdown("""
+## About RVCBench
+
+**RVCBench** is an open-source benchmark for evaluating the robustness of voice cloning
+against audio protection methods.
+
+### What it measures
+- How well 18+ modern zero-shot TTS/VC models can clone a speaker's voice
+- How effectively 5 audio protection methods (SafeSpeech, Enkidu, Spectral, GR-Noise, AntiFake)
+  prevent cloning across 10 datasets and 7 evaluation metrics
+
+### Resources
+
+| Resource | Link |
+|----------|------|
+| Paper (arXiv) | [arXiv:2602.00443](https://arxiv.org/abs/2602.00443) |
+| Code & full pipeline | [GitHub: Nanboy-Ronan/RVCBench](https://github.com/Nanboy-Ronan/RVCBench) |
+| Dataset | [HuggingFace: Nanboy/RVCBench](https://huggingface.co/datasets/Nanboy/RVCBench) |
+| Contact | ruinanjin@alumni.ubc.ca |
+
+### Citation
+
+```bibtex
+@article{liao2026rvcbench,
+  title   = {RVCBench: Benchmarking the Robustness of Voice Cloning Across Modern Audio Generation Models},
+  author  = {Liao, Xinting and Jin, Ruinan and Yu, Hanlin and Pandya, Deval and Li, Xiaoxiao},
+  journal = {arXiv preprint arXiv:2602.00443},
+  year    = {2026}
+}
+```
+""")
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_demo().launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.44.0
+numpy>=1.24
+soundfile>=0.12

samples/1089/mgm_omni_clean.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c527cdc387b4071be18f5121d87e3aea45b72a8475f817996b5df1e7e3c59cc
+size 115244

samples/1089/moss_ttsd_clean.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7470c164c0dd6947b6ddee1612cc4159b02c465c2f263b4bb5ff7b94c1356ed
+size 317484

samples/1089/moss_ttsd_safespeech.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4a6a04a66d54774348f975604afbf3e91725efd38e29463e952575286452f61
+size 102444

samples/1089/protected_grnoise.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70a00841a37a67a00175d00365283f7615bfff69b31a5cb9db20530ff5c4531e
+size 373966

samples/1089/protected_safespeech.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fd67101b9bf8cecfe9b70d194c7f92fb0f3d83ad4aaba7d71941e898e4d69aa
+size 373966

samples/1089/reference.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac099e671e248169ad2ad974e4d63f9eed3d784151b9ab997fa0d283b9586657
+size 373966

samples/1089/styletts2_clean.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39b7e139196929bb2824e64a75091909ab9f6747ea21f1e42deafc101af83d00
+size 129544

samples/1089/styletts2_safespeech.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca52bdbaeb337d62535020938c9c7256dcfaca610134b5e7c2feff7fff858dcf
+size 157144

samples/1089/target.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68c1fc12528f8b45ce676c5f0277117e195b8a5a4c505c03991086ae852c44ea
+size 103724