Upload folder using huggingface_hub

README.md

@@ -1,13 +1,27 @@
 ---
-title: Audio8TTS
-emoji: 📉
-colorFrom: gray
-colorTo: yellow
+title: Audio8 TTS Preview
+emoji: 🗣️
+colorFrom: green
+colorTo: blue
 sdk: gradio
 sdk_version: 6.23.1
-python_version: '3.12'
 app_file: app.py
-pinned: false
+python_version: "3.12"
+short_description: Zero-shot voice cloning TTS gallery for Audio8 0.6B
+startup_duration_timeout: 30m
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Audio8 TTS Preview 0.6B
+
+Demo for [Audio8/Audio8-TTS-Preview-0.6b](https://huggingface.co/Audio8/Audio8-TTS-Preview-0.6b),
+a 0.6B-parameter DualAR multilingual TTS model with zero-shot voice cloning,
+running on ZeroGPU.
+
+Browse thousands of reference voices (sourced from
+[Daankular/DramaboxTTS](https://huggingface.co/spaces/Daankular/DramaboxTTS)'s
+`voices.json`), pick one to clone, or upload/record your own reference clip.
+A CPU-side Whisper pass auto-transcribes the reference clip since Audio8 TTS
+requires a matching transcript to condition cloning.
+
+Supported generation languages: Cantonese, Chinese, Dutch, English, French,
+German, Italian, Japanese, Korean, Polish, Spanish.

app.py

@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+"""Audio8 TTS Preview 0.6B voice gallery for Hugging Face ZeroGPU."""
+
+import json
+import logging
+import os
+import sys
+import tempfile
+
+import gradio as gr
+import requests
+import soundfile as sf
+import spaces
+
+_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(_DIR, "src"))
+import audio8_backend  # noqa: E402
+import asr_backend  # noqa: E402
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+SUPPORTED_LANGUAGES = (
+    "Cantonese, Chinese, Dutch, English, French, German, Italian, "
+    "Japanese, Korean, Polish, Spanish"
+)
+
+# ── Voices ───────────────────────────────────────────────────────────────────
+with open(os.path.join(_DIR, "voices.json"), encoding="utf-8") as _f:
+    VOICES = json.load(_f)
+
+LANGUAGES = ["All"] + sorted({v.get("language", "") for v in VOICES if v.get("language")})
+GENDERS = ["All", "female", "male", "neutral"]
+PER_PAGE = 20
+
+logging.info(f"Loaded {len(VOICES):,} reference voices")
+
+
+def _filter(search, lang, gender, accent):
+    s = (search or "").lower()
+    return [
+        v for v in VOICES
+        if (lang == "All" or v.get("language") == lang)
+        and (gender == "All" or v.get("gender") == gender)
+        and (accent == "All" or v.get("accent") == accent)
+        and (not s or s in v.get("name", "").lower()
+             or s in (v.get("description") or "").lower())
+    ]
+
+
+def _accents_for(lang):
+    pool = VOICES if lang == "All" else [v for v in VOICES if v.get("language") == lang]
+    return ["All"] + sorted({v.get("accent", "") for v in pool if v.get("accent")})
+
+
+# ── Models ───────────────────────────────────────────────────────────────────
+audio8_backend.load()
+asr_backend.load()
+
+
+@spaces.GPU(duration=60, size="large")
+def on_generate(prompt, ref_audio_path, ref_text, temperature, top_p, top_k,
+                 max_new_tok, seed, progress=gr.Progress()):
+    """Synthesize speech from text, optionally cloning the reference voice."""
+    if not (prompt or "").strip():
+        raise gr.Error("Prompt is empty.")
+
+    try:
+        progress(0.5, desc="Generating with Audio8 TTS…")
+        waveform, sr = audio8_backend.generate(
+            prompt.strip(), voice_ref=ref_audio_path, reference_text=ref_text,
+            temperature=float(temperature), top_p=float(top_p),
+            top_k=int(top_k), max_new_tokens=int(max_new_tok), seed=int(seed),
+        )
+    except ValueError as e:
+        raise gr.Error(str(e))
+
+    out = tempfile.mktemp(suffix=".wav", prefix="audio8_", dir="/tmp")
+    sf.write(out, waveform, sr)
+    return out
+
+
+# ── CSS ──────────────────────────────────────────────────────────────────────
+CSS = """
+/* card grid */
+.card-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; }
+@media (max-width: 1200px) { .card-grid { grid-template-columns: repeat(3, 1fr); } }
+@media (max-width: 800px)  { .card-grid { grid-template-columns: repeat(2, 1fr); } }
+
+/* individual card — scoped inside the Gradio column */
+.voice-card { background: #14181f !important; border: 1px solid #26303f !important;
+              border-radius: 10px !important; padding: 14px !important; height: 100% !important; }
+.voice-card:hover { border-color: #2dd4bf !important; }
+
+/* card header line */
+.card-header { display: flex; align-items: flex-start; gap: 8px; margin-bottom: 6px; }
+.badge-f { background: #3d0e2a; color: #e080b0; font-size: 11px; font-weight: 700;
+           padding: 2px 7px; border-radius: 4px; white-space: nowrap; }
+.badge-m { background: #0e2a3d; color: #80c0e0; font-size: 11px; font-weight: 700;
+           padding: 2px 7px; border-radius: 4px; white-space: nowrap; }
+.badge-n { background: #1e2a1e; color: #a0c8a0; font-size: 11px; font-weight: 700;
+           padding: 2px 7px; border-radius: 4px; white-space: nowrap; }
+.card-name { font-size: 13px; font-weight: 600; color: #dde5f0; line-height: 1.35; }
+
+/* tags row */
+.card-tags { display: flex; flex-wrap: wrap; gap: 4px; margin-bottom: 4px; }
+.card-tags span { font-size: 10px; padding: 2px 6px; border-radius: 3px; }
+.t-lang { background: #123a2e; color: #6fd7b5; }
+.t-acc  { background: #16283a; color: #7fb0d9; }
+.t-age  { background: #2a1e2a; color: #b08cc0; }
+
+/* description */
+.card-desc { font-size: 11px; color: #6a7590; line-height: 1.4; margin-bottom: 4px; }
+
+/* "Use this voice" button override */
+.use-btn { background: #2dd4bf !important; color: #04231f !important; border: none !important;
+           font-weight: 700 !important; }
+.use-btn:hover { background: #5fe4d3 !important; }
+
+/* selected voice banner */
+.sel-banner { background: #0d1a17; border: 1px solid #204a3f; border-radius: 8px;
+              padding: 10px 14px; margin: 6px 0; }
+
+/* pagination */
+.pager-row { display: flex; align-items: center; gap: 12px; padding: 8px 0; }
+"""
+
+# ── UI ───────────────────────────────────────────────────────────────────────
+with gr.Blocks(title="Audio8 TTS Preview", analytics_enabled=False) as app:
+
+    gr.Markdown(
+        "# 🗣️ Audio8 TTS Preview 0.6B\n"
+        "A 0.6B-parameter multilingual TTS model with zero-shot voice cloning "
+        "([model card](https://huggingface.co/Audio8/Audio8-TTS-Preview-0.6b)). "
+        f"Browse **{len(VOICES):,} reference voices**, hit ▶ to preview, then "
+        "**Use this voice** to clone it — or upload/record your own reference clip.\n\n"
+        f"⚠️ Generated text should be one of the model's supported languages: "
+        f"**{SUPPORTED_LANGUAGES}**. Reference clips in other languages still work "
+        "as voice-timbre references, but transcription/cloning quality is best "
+        "within these 11."
+    )
+
+    # Filters
+    with gr.Row():
+        search_in = gr.Textbox(placeholder="Search by name or description…", label="Search", scale=3)
+        lang_in = gr.Dropdown(LANGUAGES, value="All", label="Language", scale=2)
+        gender_in = gr.Radio(GENDERS, value="All", label="Gender", scale=2)
+        accent_in = gr.Dropdown(["All"], value="All", label="Accent", scale=2)
+
+    result_md = gr.Markdown("")
+
+    # ── Fixed card grid (PER_PAGE slots) ─────────────────────────────────────
+    card_rows = []   # gr.Column slots (show/hide)
+    card_html = []   # gr.HTML — full card content incl. <audio> tag
+    card_btns = []   # gr.Button — "Use this voice"
+
+    page_voices = gr.State([])   # voice dicts on the current page
+
+    COLS = 4
+    for r_idx in range((PER_PAGE + COLS - 1) // COLS):
+        with gr.Row():
+            for c_idx in range(COLS):
+                slot = r_idx * COLS + c_idx
+                if slot >= PER_PAGE:
+                    break
+                with gr.Column(elem_classes=["voice-card"]) as col:
+                    html = gr.HTML("")
+                    btn = gr.Button("✅ Use this voice", size="sm", elem_classes=["use-btn"])
+                card_html.append(html)
+                card_btns.append(btn)
+                card_rows.append(col)
+
+    # Pagination
+    with gr.Row(elem_classes=["pager-row"]):
+        prev_btn = gr.Button("← Prev", size="sm", interactive=False)
+        page_info = gr.Markdown("", elem_classes=["pager-info"])
+        next_btn = gr.Button("Next →", size="sm", interactive=False)
+
+    # Selected voice banner
+    with gr.Row(visible=False, elem_classes=["sel-banner"]) as sel_row:
+        with gr.Column(scale=2):
+            sel_md = gr.Markdown("**No voice selected**")
+        with gr.Column(scale=3):
+            sel_audio = gr.Audio(
+                label="Reference audio (auto-filled from gallery pick — or upload/record your own)",
+                sources=["upload", "microphone"], type="filepath", interactive=True,
+            )
+
+    # Generation
+    gr.Markdown("---\n## Write text to synthesize")
+    with gr.Row():
+        with gr.Column(scale=3):
+            prompt_box = gr.Textbox(
+                label="Text", lines=5,
+                placeholder="Type what you want the selected voice to say.",
+            )
+            gr.Examples(
+                examples=[
+                    ["Welcome to Audio8 TTS, a compact model with zero-shot voice cloning."],
+                    ["La qualité de la voix clonée dépend beaucoup de la clarté de l'échantillon de référence."],
+                    ["Dieses Modell erzeugt Sprache in elf Sprachen bei nur 0,6 Milliarden Parametern."],
+                    ["この音声合成モデルは、わずかな参照音声からも声質を再現できます。"],
+                ],
+                inputs=[prompt_box],
+                label="Example prompts",
+            )
+            gen_btn = gr.Button("Generate", variant="primary", size="lg")
+        with gr.Column(scale=2):
+            with gr.Accordion("Settings", open=False):
+                ref_text_in = gr.Textbox(
+                    label="Reference transcript (auto-filled on selection, required for cloning)",
+                    lines=2,
+                    placeholder="Auto-transcribed from the reference audio. Must match it exactly.",
+                )
+                temperature_s = gr.Slider(0., 1.5, .8, step=.05, label="Temperature")
+                top_p_s = gr.Slider(.1, 1., .95, step=.01, label="Top-p")
+                top_k_s = gr.Slider(0, 200, 50, step=1, label="Top-k")
+                max_tok_s = gr.Slider(64, 2048, 1024, step=64, label="Max new tokens")
+                seed_n = gr.Number(-1, precision=0, label="Seed (-1 = random)")
+    audio_out = gr.Audio(label="Generated audio", type="filepath")
+
+    # ── Page state ────────────────────────────────────────────────────────────
+    page_state = gr.State(1)
+
+    # ── Helper: build all card + pagination outputs from a voice list + page ──
+    def _all_updates(filtered, page):
+        total = len(filtered)
+        total_pages = max(1, (total + PER_PAGE - 1) // PER_PAGE)
+        page = max(1, min(page, total_pages))
+        chunk = filtered[(page - 1) * PER_PAGE: page * PER_PAGE]
+
+        html_updates, vis_updates = [], []
+        for i in range(PER_PAGE):
+            if i < len(chunk):
+                v = chunk[i]
+                g = v.get("gender", "")
+                badge_cls = {"female": "badge-f", "male": "badge-m"}.get(g, "badge-n")
+                badge_sym = {"female": "♀", "male": "♂"}.get(g, "•")
+                badge = f'<span class="{badge_cls}">{badge_sym}</span>'
+                name = v.get("name", "Unknown")
+                lt, at, ag = v.get("language", "?"), v.get("accent", "?"), v.get("age", "?")
+                desc = (v.get("description") or "")[:100]
+                src = v.get("preview_url", "")
+                html = (
+                    f'<div class="card-header">{badge}'
+                    f'<span class="card-name">{name}</span></div>'
+                    f'<div class="card-tags">'
+                    f'<span class="t-lang">{lt}</span>'
+                    f'<span class="t-acc">{at}</span>'
+                    f'<span class="t-age">{ag}</span></div>'
+                    + (f'<p class="card-desc">{desc}</p>' if desc else "")
+                    + f'<audio controls preload="none" src="{src}" style="width:100%;height:32px;margin-top:4px"></audio>'
+                )
+                html_updates.append(gr.update(value=html))
+                vis_updates.append(gr.update(visible=True))
+            else:
+                html_updates.append(gr.update(value=""))
+                vis_updates.append(gr.update(visible=False))
+
+        return (
+            html_updates + vis_updates +
+            [gr.update(value=f"**{total:,}** voices found"),
+             gr.update(value=f"Page **{page}** / {total_pages}"),
+             gr.update(interactive=page > 1),
+             gr.update(interactive=page < total_pages),
+             chunk, page]
+        )
+
+    _gallery_outputs = (
+        card_html + card_rows +
+        [result_md, page_info, prev_btn, next_btn, page_voices, page_state]
+    )
+
+    # ── Filter change → reset to page 1 ──────────────────────────────────────
+    def on_filter(s, l, g, a):
+        filtered = _filter(s, l, g, a)
+        return _all_updates(filtered, 1)
+
+    def on_lang(l):
+        return gr.Dropdown(choices=_accents_for(l), value="All")
+
+    lang_in.change(on_lang, lang_in, accent_in)
+
+    for inp in [search_in, lang_in, gender_in, accent_in]:
+        inp.change(on_filter, [search_in, lang_in, gender_in, accent_in], _gallery_outputs)
+
+    # ── Pagination ────────────────────────────────────────────────────────────
+    def on_prev(s, l, g, a, pg):
+        return _all_updates(_filter(s, l, g, a), int(pg) - 1)
+
+    def on_next(s, l, g, a, pg):
+        return _all_updates(_filter(s, l, g, a), int(pg) + 1)
+
+    prev_btn.click(on_prev, [search_in, lang_in, gender_in, accent_in, page_state], _gallery_outputs)
+    next_btn.click(on_next, [search_in, lang_in, gender_in, accent_in, page_state], _gallery_outputs)
+
+    # ── "Use this voice" buttons ──────────────────────────────────────────────
+    def _make_use_handler(slot_idx):
+        def handler(voices):
+            if slot_idx >= len(voices):
+                return gr.update(), gr.update(), gr.update(visible=False)
+            v = voices[slot_idx]
+            name = v.get("name", "Unknown")
+            preview = v.get("preview_url", "")
+            tmp = None
+            if preview:
+                try:
+                    r = requests.get(preview, timeout=15)
+                    r.raise_for_status()
+                    f = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+                    f.write(r.content)
+                    f.close()
+                    tmp = f.name
+                except Exception as e:
+                    logging.warning(f"Preview download failed: {e}")
+            return (
+                gr.update(value=f"**Selected:** {name}"),
+                gr.update(value=tmp),
+                gr.update(visible=True),
+            )
+        return handler
+
+    for i, btn in enumerate(card_btns):
+        btn.click(_make_use_handler(i), inputs=[page_voices], outputs=[sel_md, sel_audio, sel_row])
+
+    # Auto-transcribe the reference clip on CPU (Whisper) so "Reference
+    # transcript" is pre-filled — Audio8 TTS requires a transcript whenever a
+    # reference clip is provided, so this fires whether the clip came from
+    # the gallery or a direct upload/recording. User can still edit it.
+    sel_audio.change(asr_backend.transcribe, inputs=[sel_audio], outputs=[ref_text_in])
+
+    # ── Generate ──────────────────────────────────────────────────────────────
+    gen_btn.click(
+        on_generate,
+        [prompt_box, sel_audio, ref_text_in, temperature_s, top_p_s, top_k_s, max_tok_s, seed_n],
+        [audio_out],
+    )
+
+    # ── Initial load ──────────────────────────────────────────────────────────
+    app.load(lambda: _all_updates(VOICES, 1), outputs=_gallery_outputs)
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("GRADIO_SERVER_PORT", "7860"))
+    app.queue(max_size=10).launch(
+        server_name="0.0.0.0", server_port=port,
+        share=os.environ.get("GRADIO_SHARE", "1") == "1",
+        css=CSS,
+        ssr_mode=False,
+        mcp_server=True,
+    )

requirements.txt

@@ -0,0 +1,7 @@
+transformers>=4.57.0,<5
+torch>=2.5.0
+torchaudio>=2.5.0
+accelerate>=0.25.0
+soundfile>=0.12
+safetensors>=0.4
+requests>=2.31.0

src/asr_backend.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""CPU-only Whisper ASR for auto-transcribing voice reference clips.
+
+Runs on CPU and is never wrapped in @spaces.GPU — keeps it off the ZeroGPU
+quota entirely and lets it run any time, independent of whichever TTS
+request currently holds the GPU. Audio8 TTS *requires* a reference
+transcript whenever a reference clip is used, so this auto-fills
+"Reference transcript" the moment a voice is picked from the gallery (or a
+clip is uploaded), and the user can still edit it before generating.
+
+Multilingual `whisper-base` (not the `.en` variant) since the voice gallery
+spans many languages.
+"""
+import logging
+
+import torch
+
+ASR_REPO = "openai/whisper-base"
+ASR_SAMPLE_RATE = 16000
+
+_processor = None
+_model = None
+
+
+def load():
+    """Load the Whisper processor + model onto CPU. Idempotent."""
+    global _processor, _model
+    if _model is not None:
+        return
+
+    from transformers import AutoProcessor, WhisperForConditionalGeneration
+
+    logging.info(f"Loading Whisper ASR ({ASR_REPO}) on CPU…")
+    _processor = AutoProcessor.from_pretrained(ASR_REPO)
+    _model = WhisperForConditionalGeneration.from_pretrained(ASR_REPO).eval()
+    logging.info("Whisper ASR ready.")
+
+
+def transcribe(audio_path):
+    """Best-effort CPU transcription of a reference clip.
+
+    Returns the stripped transcript, or "" if there's no clip or
+    transcription fails — callers treat "" as "leave the field as-is /
+    let the user fill it in manually".
+    """
+    if not audio_path or _model is None:
+        return ""
+
+    import soundfile as sf
+    import torchaudio
+
+    try:
+        data, sr = sf.read(audio_path, dtype="float32", always_2d=True)  # [L, C]
+        wav = torch.from_numpy(data).mean(dim=1)  # mono [L]
+        if sr != ASR_SAMPLE_RATE:
+            wav = torchaudio.functional.resample(wav, orig_freq=sr, new_freq=ASR_SAMPLE_RATE)
+        inputs = _processor(wav.numpy(), sampling_rate=ASR_SAMPLE_RATE, return_tensors="pt")
+        with torch.no_grad():
+            tokens = _model.generate(**inputs)
+        return _processor.batch_decode(tokens, skip_special_tokens=True)[0].strip()
+    except Exception as e:
+        logging.warning(f"Reference transcription failed: {e}")
+        return ""

src/audio8_backend.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Audio8 TTS Preview 0.6B backend for ZeroGPU.
+
+DualAR (Fish-Audio-S2-Pro-style) 0.6B multilingual TTS with zero-shot voice
+cloning: https://huggingface.co/Audio8/Audio8-TTS-Preview-0.6b. Requires
+trust_remote_code=True (custom `arktts` modeling/processing code shipped in
+the model repo).
+
+``load()`` runs once at app startup and moves the model to "cuda" eagerly —
+ZeroGPU's CUDA emulation packs the tensors to disk and streams them into VRAM
+on the first real request, so lazy loading inside the decorated handler would
+cost every user instead of only the first.
+"""
+import logging
+import os
+
+import torch
+
+MODEL_REPO = "Audio8/Audio8-TTS-Preview-0.6b"
+
+_processor = None
+_model = None
+
+
+def load():
+    """Load the processor + model onto cuda. Idempotent."""
+    global _processor, _model
+    if _model is not None:
+        return
+
+    from transformers import AutoModel, AutoProcessor
+
+    logging.info(f"Loading Audio8 TTS ({MODEL_REPO})…")
+    token = os.environ.get("HF_TOKEN")
+    _processor = AutoProcessor.from_pretrained(
+        MODEL_REPO, token=token, trust_remote_code=True
+    )
+    _model = (
+        AutoModel.from_pretrained(
+            MODEL_REPO, token=token, trust_remote_code=True, dtype=torch.bfloat16
+        )
+        .eval()
+        .to("cuda")
+    )
+    logging.info("Audio8 TTS ready.")
+
+
+def generate(text, voice_ref=None, reference_text=None, temperature=0.8,
+             top_p=0.95, top_k=50, max_new_tokens=1024, seed=-1):
+    """Generate speech with Audio8 TTS Preview.
+
+    voice_ref: optional path to a reference clip for zero-shot cloning.
+    reference_text: transcript of voice_ref. The processor *requires* a
+        non-empty reference_text whenever voice_ref is given — the model
+        conditions generation on the text/audio alignment, not just the
+        audio. Raises ValueError if missing.
+
+    Returns (waveform: 1-D numpy array, sample_rate: int).
+    """
+    if _model is None:
+        raise RuntimeError("Audio8 TTS is not loaded — call audio8_backend.load() at startup.")
+
+    if seed is not None and int(seed) >= 0:
+        torch.manual_seed(int(seed))
+
+    call_kwargs = {}
+    if voice_ref:
+        if not reference_text or not reference_text.strip():
+            raise ValueError(
+                "This model needs a transcript of the reference clip to clone it. "
+                "Fill in \"Reference transcript\" (auto-transcription may have failed) "
+                "or clear the reference audio to generate without cloning."
+            )
+        call_kwargs["reference_audio"] = [voice_ref]
+        call_kwargs["reference_text"] = [reference_text.strip()]
+
+    inputs = _processor(text=[text], return_tensors="pt", **call_kwargs)
+    inputs = {k: v.to("cuda") for k, v in inputs.items()}
+
+    with torch.inference_mode():
+        output = _model.generate(
+            **inputs,
+            max_new_tokens=int(max_new_tokens),
+            temperature=float(temperature),
+            top_p=float(top_p),
+            top_k=int(top_k),
+            do_sample=True,
+            return_dict_in_generate=True,
+        )
+        waveforms, waveform_lengths = _model.decode_audio(output.codes)
+
+    audio = waveforms[0, : int(waveform_lengths[0])].float().cpu().numpy()
+    if audio.size == 0:
+        raise RuntimeError("Audio8 TTS produced no audio — try again or adjust the text.")
+    return audio, _model.config.codec_sample_rate