Upload folder using huggingface_hub

README.md

@@ -1,13 +1,37 @@
 ---
-title: Moss Tts Pny
-emoji: ⚡
-colorFrom: yellow
-colorTo: pink
+title: MOSS-TTS-PNY
+emoji: 🎙️
+colorFrom: gray
+colorTo: yellow
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.12'
+sdk_version: 6.15.1
 app_file: app.py
-pinned: false
+short_description: Speaker-conditioned TTS with emotion & energy control
+python_version: "3.12"
+startup_duration_timeout: 1h
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MOSS-TTS-PNY
+
+Speaker-conditioned text-to-speech demo using the [ZDisket/MOSS-TTS-PNY](https://huggingface.co/ZDisket/MOSS-TTS-PNY) model — a fine-tuned MOSS-TTS checkpoint with character voice clones from My Little Pony: Friendship is Magic and Team Fortress 2.
+
+## Features
+
+- **43 speakers** — MLP:FiM characters (Twilight, Pinkie, Rainbow, etc.) and TF2 characters (Heavy, Scout, Soldier, etc.)
+- **12 emotions** — Neutral, Happy, Sad, Angry, Annoyed, Fearful, Surprised, Calm, Disgusted, Whispering, Nonverbal, Shouting
+- **Continuous energy control** — adjust the energy/intensity of the generated speech (0.0 – 1.0)
+- **48 kHz output** via iSTFTNet2 TorchScript CUDA vocoder
+
+## How it works
+
+1. Enter the text you want to synthesize.
+2. Pick a speaker from the dropdown.
+3. Choose an emotion and set the energy level.
+4. Click **Generate** to produce audio.
+
+## Notes
+
+- Uses `trust_remote_code=True` to load the custom MOSS-TTS model code.
+- `transformers==4.55.0` is pinned to prevent gibberish outputs.
+- The model downloads ~12 GB of weights at startup.
+- Max 30 seconds of audio per generation.

app.py

@@ -0,0 +1,484 @@
+"""Gradio demo for ZDisket/MOSS-TTS-PNY — a speaker-conditioned TTS model.
+
+This Space loads the MOSS-TTS-PNY checkpoint (fine-tuned on MLP:FiM and TF2
+voices) and provides a Gradio interface for text-to-speech synthesis with
+speaker selection, emotion control, and energy adjustment.
+
+Model: https://huggingface.co/ZDisket/MOSS-TTS-PNY
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import math
+import os
+import random
+import tempfile
+import time
+import unicodedata
+import uuid
+from pathlib import Path
+from typing import Any
+
+# ── ZeroGPU: import spaces before any CUDA-touching import ──────────────
+import spaces  # noqa: E402
+
+import torch  # noqa: E402
+import gradio as gr  # noqa: E402
+from huggingface_hub import snapshot_download  # noqa: E402
+
+# ── Path setup ───────────────────────────────────────────────────────────
+BUILD_ROOT = Path(__file__).resolve().parent
+MODEL_REPO = "ZDisket/MOSS-TTS-PNY"
+
+# Skip the os.execv re-exec inside portable_tts_runtime
+os.environ.setdefault("MOSS_TTS_NVIDIA_LD_LIBRARY_PATH_READY", "1")
+os.environ.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
+
+# ── Download model weights at startup ─────────────────────────────────────
+print("Downloading model weights from ZDisket/MOSS-TTS-PNY …", flush=True)
+_download_start = time.perf_counter()
+_model_root = snapshot_download(
+    repo_id=MODEL_REPO,
+    repo_type="model",
+    allow_patterns=[
+        "moss_tts_local_clipper_checkpoint/**",
+        "moss_audio_tokenizer/**",
+        "istftnet2_decoder4_50hz/**",
+    ],
+)
+_download_elapsed = time.perf_counter() - _download_start
+print(f"Model weights downloaded in {_download_elapsed:.1f}s -> {_model_root}", flush=True)
+
+CHECKPOINT_PATH = str(Path(_model_root) / "moss_tts_local_clipper_checkpoint")
+CODEC_PATH = str(Path(_model_root) / "moss_audio_tokenizer")
+DECODER_DIR = str(Path(_model_root) / "istftnet2_decoder4_50hz")
+
+# ── Constants ─────────────────────────────────────────────────────────────
+CODEC_FRAMES_PER_SECOND = 12.5
+MAX_OUTPUT_SECONDS = 30
+MAX_OUTPUT_FRAMES = int(CODEC_FRAMES_PER_SECOND * MAX_OUTPUT_SECONDS)
+MAX_TEXT_LINES = 12
+MAX_LANGUAGE_CHARS = 16
+MAX_TEXT_CHARS = 500
+
+EMOTION_CHOICES = [
+    ("Neutral", 0),
+    ("Happy", 1),
+    ("Sad", 2),
+    ("Angry", 3),
+    ("Annoyed", 4),
+    ("Fearful", 5),
+    ("Surprised", 6),
+    ("Calm", 7),
+    ("Disgusted", 8),
+    ("Whispering", 9),
+    ("Nonverbal", 10),
+    ("Shouting", 11),
+]
+
+RANDOM_TEXTS = [
+    "I know this sounds sudden, but I really missed hearing your voice today.",
+    "Wait, you actually finished the whole thing already?",
+    "I'm trying to stay calm, but that was way closer than I expected.",
+    "Honestly, I'm proud of us for getting through that without giving up.",
+    "No, no, it's fine. I'm only a little dramatically offended.",
+    "I cannot believe you kept that surprise hidden for so long.",
+    "Please tell me you saw that too, because I am not ready to explain it.",
+    "That was kind of beautiful, in a messy and completely unexpected way.",
+    "I'm sorry, I should have listened before jumping to conclusions.",
+    "Okay, deep breath. We can fix this if we take it one step at a time.",
+    "You have no idea how happy that made me.",
+    "I was nervous at first, but now I'm actually excited to try again.",
+]
+
+# ── Load speaker map & tiers ──────────────────────────────────────────────
+
+
+def load_speaker_tiers(csv_path: str) -> dict[int, int]:
+    path = Path(csv_path)
+    if not path.exists():
+        return {}
+    tiers: dict[int, int] = {}
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            tiers[int(row["speaker_id"])] = int(row["tier"])
+    return tiers
+
+
+def load_speaker_choices(csv_path: str, tiers: dict[int, int]) -> tuple[list[str], dict[str, int]]:
+    path = Path(csv_path)
+    if not path.exists():
+        choices = [f"Speaker {i} ({i})" for i in range(43)]
+        return choices, {c: i for i, c in enumerate(choices)}
+    choice_rows: list[tuple[int, str, str, int]] = []
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            speaker_id = int(row["speaker_id"])
+            label = row.get("label") or f"{row.get('display_name') or row.get('name')} ({speaker_id})"
+            tier = tiers.get(speaker_id, 9)
+            if tier != 9:
+                label = f"T{tier} - {label}"
+            choice_rows.append((tier, label.lower(), label, speaker_id))
+    choices: list[str] = []
+    speaker_ids: dict[str, int] = {}
+    for _tier, _sort_label, label, speaker_id in sorted(choice_rows):
+        choices.append(label)
+        speaker_ids[label] = speaker_id
+    return choices, speaker_ids
+
+
+SPEAKER_TIERS = load_speaker_tiers(str(BUILD_ROOT / "speaker_hours_tiers.csv"))
+SPEAKER_CHOICES, SPEAKER_IDS = load_speaker_choices(
+    str(BUILD_ROOT / "speaker_id_map.csv"), SPEAKER_TIERS
+)
+DEFAULT_SPEAKER = next(
+    (c for c in SPEAKER_CHOICES if "Twilight (31)" in c),
+    SPEAKER_CHOICES[0] if SPEAKER_CHOICES else "Speaker 31 (31)",
+)
+
+# ── Load model at module scope (ZeroGPU rule 2) ───────────────────────────
+from portable_tts_runtime import (  # noqa: E402
+    OptimizedTTSConfig,
+    OptimizedTTSRunner,
+    save_wav_pcm16,
+)
+
+# Use fixed-full torch opt mode (avoids the ~4-minute Triton compile of the
+# packed-local path; still gets torch.compile on the global transformer).
+RUNNER = OptimizedTTSRunner(
+    OptimizedTTSConfig(
+        checkpoint=CHECKPOINT_PATH,
+        codec_path=CODEC_PATH,
+        decoder_dir=DECODER_DIR,
+        decoder_runtime="torchscript_cuda",
+        decoder4_features_runtime="torch_fp16",
+        dtype="fp16",
+        attn_implementation="sdpa",
+        torch_opt_mode="fixed-full",
+        cache_implementation="static",
+        compile_global_transformer=True,
+        global_compile_mode="default",
+        fast_prepare_inputs=True,
+        triton_top_p=True,
+        packed_local_qkv=False,
+        packed_local_mlp=False,
+        static_packed_weights=False,
+        tensorize_rmsnorm_eps=True,
+        feedback_lookup=True,
+        vocoder_bucket_frames=64,
+        vocoder_prewarm_buckets="64,128,192,256,320,384,448,512,576,640",
+    )
+)
+SAMPLE_RATE = int(RUNNER.sample_rate)
+print(f"Model loaded. sample_rate={SAMPLE_RATE}", flush=True)
+
+# Prewarm the model with a short dummy generation so the first user request
+# does not pay the torch.compile cost.
+print("Prewarming model …", flush=True)
+_prewarm_start = time.perf_counter()
+try:
+    _pw = RUNNER.synthesize(
+        text="The optimized demo is ready.",
+        language="en",
+        speaker_id=31,
+        max_new_tokens=64,
+        text_temperature=0.0,
+        text_top_p=1.0,
+        text_top_k=None,
+        audio_temperature=0.8,
+        audio_top_p=0.92,
+        audio_top_k=None,
+        audio_repetition_penalty=1.05,
+        n_vq_for_inference=32,
+        style_text="The optimized demo is ready.",
+        style_emotion_id=0,
+        style_energy=0.5,
+    )
+    print(f"Prewarm complete in {time.perf_counter() - _prewarm_start:.1f}s", flush=True)
+except Exception as exc:
+    print(f"Prewarm failed ({exc!r}) — continuing anyway", flush=True)
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────
+
+
+def energy_label(energy: float) -> str:
+    if energy < 0.33:
+        return "low energy"
+    if energy < 0.66:
+        return "medium energy"
+    return "high energy"
+
+
+def normalize_client_text(value: str, *, max_chars: int) -> str:
+    if not isinstance(value, str):
+        raise gr.Error("Text must be a string.")
+    text = unicodedata.normalize("NFKC", value).replace("\r\n", "\n").replace("\r", "\n").strip()
+    if not text:
+        raise gr.Error("Enter some text first.")
+    if max_chars > 0 and len(text) > max_chars:
+        raise gr.Error(f"Text is too long. Keep it under {max_chars} characters.")
+    if text.count("\n") + 1 > MAX_TEXT_LINES:
+        raise gr.Error(f"Text has too many lines. Keep it under {MAX_TEXT_LINES} lines.")
+    for char in text:
+        cat = unicodedata.category(char)
+        if cat.startswith("C") and char not in {"\n", "\t"}:
+            raise gr.Error("Text contains unsupported control characters.")
+    if not any(c.isalnum() for c in text):
+        raise gr.Error("Text must contain at least one letter or number.")
+    if "\ufffd" in text:
+        raise gr.Error("Text contains malformed replacement characters.")
+    return text
+
+
+def normalize_language(value: str) -> str:
+    language = unicodedata.normalize("NFKC", value or "en").strip().lower()
+    if not language:
+        return "en"
+    if len(language) > MAX_LANGUAGE_CHARS:
+        raise gr.Error("Language code is too long.")
+    allowed = set("abcdefghijklmnopqrstuvwxyz-")
+    if any(c not in allowed for c in language):
+        raise gr.Error("Language must be a simple code like 'en'.")
+    return language
+
+
+def validate_float(name: str, value: float, minimum: float, maximum: float) -> float:
+    value = float(value)
+    if not math.isfinite(value) or value < minimum or value > maximum:
+        raise gr.Error(f"{name} must be between {minimum} and {maximum}.")
+    return value
+
+
+def validate_int(name: str, value: int, minimum: int, maximum: int) -> int:
+    value = int(value)
+    if value < minimum or value > maximum:
+        raise gr.Error(f"{name} must be between {minimum} and {maximum}.")
+    return value
+
+
+def _random_text() -> str:
+    return random.choice(RANDOM_TEXTS)
+
+
+# ── Inference (decorated for ZeroGPU) ─────────────────────────────────────
+
+
+@spaces.GPU(duration=120)
+def synthesize(
+    text: str,
+    style_text: str,
+    language: str,
+    speaker_label: str,
+    emotion_label: str,
+    style_energy: float,
+    audio_temperature: float,
+    audio_top_p: float,
+    audio_top_k: int,
+    audio_repetition_penalty: float,
+) -> tuple[str, str]:
+    """Generate speech audio from text using MOSS-TTS-PNY.
+
+    Args:
+        text: The text to synthesize.
+        style_text: Optional style reference text (falls back to ``text``).
+        language: Language code (e.g. ``"en"``).
+        speaker_label: Speaker name from the dropdown.
+        emotion_label: Emotion name from the dropdown.
+        style_energy: Energy level (0.0 – 1.0).
+        audio_temperature: Sampling temperature for audio tokens.
+        audio_top_p: Top-p value for audio token sampling.
+        audio_top_k: Top-k value (0 = disabled).
+        audio_repetition_penalty: Repetition penalty for audio tokens.
+
+    Returns:
+        A tuple of (wav_filepath, stats_json).
+    """
+    clean_text = normalize_client_text(text, max_chars=MAX_TEXT_CHARS)
+    clean_style_text = (
+        normalize_client_text(style_text, max_chars=MAX_TEXT_CHARS)
+        if style_text and style_text.strip()
+        else ""
+    )
+    clean_language = normalize_language(language)
+    if speaker_label not in SPEAKER_IDS:
+        raise gr.Error("Choose a valid speaker.")
+    emotion_lookup = {label: eid for label, eid in EMOTION_CHOICES}
+    if emotion_label not in emotion_lookup:
+        raise gr.Error("Choose a valid emotion.")
+    clean_energy = validate_float("Energy", style_energy, 0.0, 1.0)
+    clean_temperature = validate_float("Audio temperature", audio_temperature, 0.0, 1.5)
+    clean_top_p = validate_float("Audio top-p", audio_top_p, 0.05, 1.0)
+    clean_top_k = validate_int("Audio top-k", audio_top_k, 0, 200)
+    clean_rep_pen = validate_float(
+        "Audio repetition penalty", audio_repetition_penalty, 0.0, 2.0
+    )
+
+    start = time.perf_counter()
+    result = RUNNER.synthesize(
+        text=clean_text,
+        language=clean_language,
+        speaker_id=SPEAKER_IDS[speaker_label],
+        max_new_tokens=MAX_OUTPUT_FRAMES,
+        text_temperature=0.0,
+        text_top_p=1.0,
+        text_top_k=None,
+        audio_temperature=clean_temperature,
+        audio_top_p=clean_top_p,
+        audio_top_k=clean_top_k if clean_top_k > 0 else None,
+        audio_repetition_penalty=clean_rep_pen,
+        n_vq_for_inference=32,
+        style_text=clean_style_text or clean_text,
+        style_emotion_id=emotion_lookup[emotion_label],
+        style_energy=clean_energy,
+    )
+    elapsed = time.perf_counter() - start
+
+    # Write to a temp file (concurrency-safe — no fixed output paths).
+    tmp_wav = tempfile.NamedTemporaryFile(
+        suffix=".wav", delete=False, dir=str(BUILD_ROOT / "outputs")
+    )
+    tmp_wav.close()
+    output_path = Path(tmp_wav.name)
+    save_wav_pcm16(output_path, result["audio"], SAMPLE_RATE)
+
+    stats = {
+        "speaker": speaker_label,
+        "speaker_id": SPEAKER_IDS[speaker_label],
+        "emotion": emotion_label,
+        "style_energy": clean_energy,
+        "energy_label": energy_label(clean_energy),
+        "language": clean_language,
+        "text_chars": len(clean_text),
+        "audio_sec": round(result["audio_sec"], 3),
+        "prompt_sec": round(result["prompt_sec"], 3),
+        "generate_sec": round(result["generate_sec"], 3),
+        "decode_sec": round(result["decode_sec"], 3),
+        "total_sec": round(elapsed, 3),
+        "generate_x_realtime": round(result["generate_x_realtime"], 2),
+        "generated_tokens": result.get("generated_tokens", 0),
+        "prompt_tokens": result.get("prompt_tokens", 0),
+        "sample_rate": SAMPLE_RATE,
+    }
+    return str(output_path), json.dumps(stats, indent=2)
+
+
+# ── UI ────────────────────────────────────────────────────────────────────
+
+CSS = """
+#col-container { max-width: 1100px; margin: 0 auto; }
+.dark .gradio-container { color: var(--body-text-color); }
+"""
+
+with gr.Blocks(
+    title="MOSS-TTS-PNY",
+    theme=gr.themes.Citrus(),
+    css=CSS,
+) as demo:
+    gr.Markdown(
+        "# 🎙️ MOSS-TTS-PNY\n"
+        "Speaker-conditioned text-to-speech with emotion and energy control. "
+        "Fine-tuned MOSS-TTS checkpoint featuring character voices.\n\n"
+        "Model: [ZDisket/MOSS-TTS-PNY](https://huggingface.co/ZDisket/MOSS-TTS-PNY)"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            text = gr.Textbox(
+                label="Text",
+                value="I wasn't expecting that to work, but now I'm kind of excited.",
+                lines=4,
+                max_length=MAX_TEXT_CHARS,
+            )
+            style_text = gr.Textbox(
+                label="Style text (optional)",
+                placeholder="Leave empty to use the same text as input.",
+                lines=2,
+                max_length=MAX_TEXT_CHARS,
+            )
+            with gr.Row():
+                randomize = gr.Button("Random Text")
+                generate = gr.Button("Generate", variant="primary")
+
+        with gr.Column(scale=2):
+            language = gr.Textbox(label="Language", value="en")
+            speaker = gr.Dropdown(
+                label="Speaker",
+                choices=SPEAKER_CHOICES,
+                value=DEFAULT_SPEAKER,
+            )
+            emotion = gr.Dropdown(
+                label="Emotion",
+                choices=[label for label, _ in EMOTION_CHOICES],
+                value="Neutral",
+            )
+            style_energy = gr.Slider(
+                label="Energy",
+                minimum=0.0,
+                maximum=1.0,
+                value=0.5,
+                step=0.05,
+            )
+            gr.Markdown(f"Max {MAX_OUTPUT_SECONDS}s of audio output")
+
+    with gr.Accordion("Advanced settings", open=False):
+        gr.Markdown("If you don't know what you're doing, leave these untouched.")
+        with gr.Row():
+            audio_temperature = gr.Slider(
+                label="Audio temperature", minimum=0.0, maximum=1.5, value=0.8, step=0.05
+            )
+            audio_top_p = gr.Slider(
+                label="Audio top-p", minimum=0.05, maximum=1.0, value=0.92, step=0.05
+            )
+            audio_top_k = gr.Slider(
+                label="Audio top-k", minimum=0, maximum=200, value=0, step=1
+            )
+            audio_repetition_penalty = gr.Slider(
+                label="Audio repetition penalty",
+                minimum=0.0,
+                maximum=2.0,
+                value=1.05,
+                step=0.05,
+            )
+
+    with gr.Row():
+        audio_output = gr.Audio(label="Generated audio", type="filepath", autoplay=True)
+        stats = gr.Code(label="Stats", language="json")
+
+    gr.Examples(
+        examples=[
+            ["I wasn't expecting that to work, but now I'm kind of excited.", "", "en",
+             DEFAULT_SPEAKER, "Neutral", 0.5, 0.8, 0.92, 0, 1.05],
+            ["You have no idea how happy that made me.", "", "en",
+             DEFAULT_SPEAKER, "Happy", 0.8, 0.8, 0.92, 0, 1.05],
+            ["I'm trying to stay calm, but that was way closer than I expected.", "", "en",
+             DEFAULT_SPEAKER, "Fearful", 0.3, 0.8, 0.92, 0, 1.05],
+            ["Okay, deep breath. We can fix this if we take it one step at a time.", "", "en",
+             DEFAULT_SPEAKER, "Calm", 0.4, 0.8, 0.92, 0, 1.05],
+        ],
+        inputs=[
+            text, style_text, language, speaker, emotion, style_energy,
+            audio_temperature, audio_top_p, audio_top_k, audio_repetition_penalty,
+        ],
+        outputs=[audio_output, stats],
+        fn=synthesize,
+        cache_examples=True,
+        cache_mode="lazy",
+    )
+
+    randomize.click(_random_text, inputs=[], outputs=[text], queue=False)
+    generate.click(
+        synthesize,
+        inputs=[
+            text, style_text, language, speaker, emotion, style_energy,
+            audio_temperature, audio_top_p, audio_top_k, audio_repetition_penalty,
+        ],
+        outputs=[audio_output, stats],
+        api_name="generate",
+    )
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=1, max_size=20)
+    demo.launch(mcp_server=True, show_error=False)

decoder4_features_torch.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+class Decoder4FeatureExtractor(nn.Module):
+    """MOSS audio-tokenizer codebook decode plus decoder blocks 0..4."""
+
+    def __init__(
+        self,
+        audio_tokenizer: nn.Module,
+        num_quantizers: int = 32,
+        output_dtype: torch.dtype = torch.float16,
+    ) -> None:
+        super().__init__()
+        quantizer = getattr(audio_tokenizer, "quantizer")
+        self.quantizers = quantizer.quantizers
+        self.output_proj = quantizer.output_proj
+        self.decoder_prefix = nn.ModuleList(list(audio_tokenizer.decoder[:5]))
+        self.rvq_dim = int(quantizer.rvq_dim)
+        self.num_quantizers = int(num_quantizers)
+        self.output_dtype = output_dtype
+
+    def forward(self, codes: torch.Tensor, lengths: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        _, batch, frames = codes.shape
+        emb = torch.zeros(batch, self.rvq_dim, frames, device=codes.device, dtype=self.output_dtype)
+        for index, quantizer in enumerate(self.quantizers[: self.num_quantizers]):
+            if self.output_dtype == torch.float16:
+                z_q = quantizer.embed_code(codes[index]).transpose(1, 2).to(self.output_dtype)
+                z_q = quantizer.out_proj(z_q)
+            else:
+                z_q = quantizer.decode_code(codes[index])
+            emb = emb + z_q.to(self.output_dtype)
+        features = self.output_proj(emb)
+        feature_lengths = lengths
+        for module in self.decoder_prefix:
+            features, feature_lengths = module(features, feature_lengths)
+        return features.to(self.output_dtype), feature_lengths

portable_tts_runtime.py

@@ -0,0 +1,800 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import gc
+import importlib.util
+import json
+import os
+import site
+import sys
+import time
+import wave
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import AutoConfig, AutoModel, AutoTokenizer, TorchAoConfig
+
+from decoder4_features_torch import Decoder4FeatureExtractor
+
+
+BUNDLE_ROOT = Path(__file__).resolve().parent
+
+
+def _candidate_roots() -> list[Path]:
+    roots = [
+        BUNDLE_ROOT,
+        BUNDLE_ROOT.parent,
+        Path.cwd(),
+        Path.cwd() / "moss_tts_clipper_istftnet2_release",
+        BUNDLE_ROOT.parent / "moss_tts_clipper_istftnet2_release",
+    ]
+    seen: set[Path] = set()
+    unique: list[Path] = []
+    for root in roots:
+        resolved = root.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique.append(resolved)
+    return unique
+
+
+def resolve_asset(value: str | Path) -> Path:
+    path = Path(value)
+    if path.exists():
+        return path.resolve()
+    for root in _candidate_roots():
+        candidate = root / path
+        if candidate.exists():
+            return candidate.resolve()
+    return path
+
+
+def add_release_root_to_syspath(checkpoint: str | Path) -> Path:
+    checkpoint_path = resolve_asset(checkpoint)
+    release_root = checkpoint_path.parent
+    release_root_str = str(release_root)
+    if release_root_str not in sys.path:
+        sys.path.insert(0, release_root_str)
+    return checkpoint_path
+
+
+def ensure_nvidia_library_path() -> None:
+    if os.environ.get("MOSS_TTS_NVIDIA_LD_LIBRARY_PATH_READY") == "1":
+        return
+    lib_dirs: list[str] = []
+    site_roots = list(dict.fromkeys(site.getsitepackages() + [site.getusersitepackages()]))
+    for site_root in site_roots:
+        nvidia_root = Path(site_root) / "nvidia"
+        if not nvidia_root.exists():
+            continue
+        for lib_dir in nvidia_root.glob("*/lib"):
+            if lib_dir.is_dir():
+                lib_dirs.append(str(lib_dir))
+    if not lib_dirs:
+        return
+    current = os.environ.get("LD_LIBRARY_PATH", "")
+    current_parts = [part for part in current.split(":") if part]
+    wanted = [part for part in lib_dirs if part not in current_parts]
+    if not wanted:
+        os.environ["MOSS_TTS_NVIDIA_LD_LIBRARY_PATH_READY"] = "1"
+        return
+    os.environ["LD_LIBRARY_PATH"] = ":".join(wanted + current_parts)
+    os.environ["MOSS_TTS_NVIDIA_LD_LIBRARY_PATH_READY"] = "1"
+    os.execv(sys.executable, [sys.executable, *sys.argv])
+
+
+def choose_providers(requested: str, available: list[str]) -> list[str]:
+    return [requested] if requested in available else ["CPUExecutionProvider"]
+
+
+def select_dtype(device: torch.device, dtype_arg: str) -> torch.dtype:
+    if device.type != "cuda":
+        return torch.float32
+    if dtype_arg == "fp16":
+        return torch.float16
+    if dtype_arg == "bf16":
+        return torch.bfloat16
+    if dtype_arg == "fp32":
+        return torch.float32
+    major, _minor = torch.cuda.get_device_capability(device)
+    return torch.bfloat16 if major >= 8 else torch.float16
+
+
+def save_wav_pcm16(path: Path, audio: torch.Tensor, sample_rate: int) -> None:
+    pcm = (audio.clamp(-1.0, 1.0) * 32767.0).to(torch.int16).cpu().numpy()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(path), "wb") as handle:
+        handle.setnchannels(1)
+        handle.setsampwidth(2)
+        handle.setframerate(sample_rate)
+        handle.writeframes(pcm.tobytes())
+
+
+def summarize(values: list[float]) -> dict[str, float]:
+    if not values:
+        return {"mean": 0.0, "min": 0.0, "max": 0.0}
+    return {
+        "mean": sum(values) / len(values),
+        "min": min(values),
+        "max": max(values),
+    }
+
+
+def build_processor_without_audio_model(checkpoint: str | Path):
+    bundled_release_root = BUNDLE_ROOT.parent
+    if (bundled_release_root / "moss_tts_local_clipper_checkpoint").exists():
+        bundled_release_root_str = str(bundled_release_root)
+        if bundled_release_root_str not in sys.path:
+            sys.path.insert(0, bundled_release_root_str)
+    try:
+        from moss_tts_local_clipper_checkpoint.processing_moss_tts import MossTTSDelayProcessor
+    except ImportError:
+        processing_file = Path(checkpoint) / "processing_moss_tts.py"
+        if not processing_file.exists():
+            raise
+        spec = importlib.util.spec_from_file_location("moss_tts_checkpoint_processing", processing_file)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load processor module from {processing_file}.")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+        MossTTSDelayProcessor = module.MossTTSDelayProcessor
+
+    config = AutoConfig.from_pretrained(checkpoint, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(checkpoint, trust_remote_code=True)
+    return MossTTSDelayProcessor(tokenizer=tokenizer, model_config=config)
+
+
+def load_style_extractor_class(checkpoint: str | Path):
+    try:
+        from moss_tts_local.style_features import BertStyleFeatureExtractor
+
+        return BertStyleFeatureExtractor
+    except ImportError:
+        pass
+
+    style_file = Path(checkpoint) / "style_features.py"
+    if style_file.exists():
+        spec = importlib.util.spec_from_file_location("moss_tts_checkpoint_style_features", style_file)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load style feature module from {style_file}.")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+        return module.BertStyleFeatureExtractor
+
+    from moss_tts_local_clipper_checkpoint.style_features import BertStyleFeatureExtractor
+
+    return BertStyleFeatureExtractor
+
+
+class TorchDecoder4FeatureRuntime:
+    def __init__(self, codec_path: str | Path, device: torch.device, dtype: torch.dtype) -> None:
+        if device.type != "cuda" or dtype != torch.float16:
+            raise RuntimeError("torch_fp16 decoder4 runtime requires CUDA fp16.")
+        audio_tokenizer = AutoModel.from_pretrained(codec_path, trust_remote_code=True).to(
+            device=device,
+            dtype=dtype,
+        )
+        audio_tokenizer.eval()
+        num_quantizers = int(audio_tokenizer.config.quantizer_kwargs.get("num_quantizers", 32))
+        self.extractor = Decoder4FeatureExtractor(
+            audio_tokenizer,
+            num_quantizers=num_quantizers,
+            output_dtype=dtype,
+        ).to(device=device, dtype=dtype)
+        self.extractor.eval()
+        self.device = device
+        self.inputs = [SimpleNamespace(name="codes"), SimpleNamespace(name="lengths")]
+        del audio_tokenizer
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    def get_inputs(self) -> list[Any]:
+        return self.inputs
+
+    def get_providers(self) -> list[str]:
+        return ["torch_fp16_cuda"]
+
+    def run(self, output_names: Any, feeds: dict[str, np.ndarray]) -> list[np.ndarray]:
+        del output_names
+        codes = torch.from_numpy(feeds["codes"]).to(device=self.device, dtype=torch.long)
+        lengths = torch.from_numpy(feeds["lengths"]).to(device=self.device, dtype=torch.long)
+        with torch.inference_mode():
+            features, feature_lengths = self.extractor(codes, lengths)
+        if self.device.type == "cuda":
+            torch.cuda.synchronize()
+        return [
+            features.detach().float().cpu().numpy(),
+            feature_lengths.detach().cpu().numpy(),
+        ]
+
+
+def run_vocoder_onnx(session: Any, features: np.ndarray, feature_lengths: np.ndarray) -> torch.Tensor:
+    input_name = session.get_inputs()[0].name
+    audio_np = session.run(None, {input_name: features.astype(np.float32, copy=False)})[0]
+    samples = int(feature_lengths[0]) * 960
+    audio = torch.from_numpy(audio_np[0, 0, :samples]).float().cpu()
+    return torch.nan_to_num(audio).reshape(-1).clamp(-1.0, 1.0)
+
+
+class TorchScriptVocoderRuntime:
+    def __init__(
+        self,
+        decoder_dir: str | Path,
+        device: torch.device,
+        *,
+        use_cudagraph: bool = False,
+        bucket_frames: int = 0,
+    ) -> None:
+        artifact = Path(decoder_dir) / (
+            "istftnet2_decoder_cuda.ts" if device.type == "cuda" else "istftnet2_decoder_cpu.ts"
+        )
+        if not artifact.exists():
+            raise FileNotFoundError(f"Missing TorchScript vocoder artifact: {artifact}")
+        self.device = device
+        self.module = torch.jit.load(str(artifact), map_location=device).eval()
+        self.use_cudagraph = bool(use_cudagraph and device.type == "cuda")
+        self.bucket_frames = max(0, int(bucket_frames))
+        self.graphs: dict[tuple[Any, ...], tuple[torch.cuda.CUDAGraph, torch.Tensor, torch.Tensor]] = {}
+
+    def get_inputs(self) -> list[Any]:
+        return [SimpleNamespace(name="features")]
+
+    def get_providers(self) -> list[str]:
+        suffix = "_cudagraph" if self.use_cudagraph else ""
+        return [f"torchscript_{self.device.type}{suffix}"]
+
+    def prewarm_buckets(self, frame_lengths: list[int]) -> dict[str, Any]:
+        requested = [int(length) for length in frame_lengths if int(length) > 0]
+        if not requested:
+            return {"requested": [], "elapsed_sec": 0.0}
+        if self.device.type == "cuda":
+            torch.cuda.synchronize(self.device)
+        start = time.perf_counter()
+        warmed: list[int] = []
+        with torch.inference_mode():
+            for frames in requested:
+                features = torch.randn(1, 768, frames, device=self.device, dtype=torch.float32)
+                self.run_tensor(features)
+                warmed.append(frames)
+        if self.device.type == "cuda":
+            torch.cuda.synchronize(self.device)
+        return {"requested": requested, "warmed": warmed, "elapsed_sec": time.perf_counter() - start}
+
+    def run_tensor(self, features_tensor: torch.Tensor) -> torch.Tensor:
+        features_tensor = features_tensor.to(device=self.device, dtype=torch.float32).contiguous()
+        if self.bucket_frames > 0 and features_tensor.ndim == 3:
+            frames = int(features_tensor.shape[-1])
+            bucketed = ((frames + self.bucket_frames - 1) // self.bucket_frames) * self.bucket_frames
+            if bucketed > frames:
+                padded = torch.zeros(
+                    *features_tensor.shape[:-1],
+                    bucketed,
+                    device=features_tensor.device,
+                    dtype=features_tensor.dtype,
+                )
+                padded[..., :frames] = features_tensor
+                features_tensor = padded
+        if not self.use_cudagraph:
+            with torch.inference_mode():
+                return self.module(features_tensor)
+        key = (
+            features_tensor.device.index,
+            features_tensor.dtype,
+            tuple(features_tensor.shape),
+        )
+        entry = self.graphs.get(key)
+        if entry is None:
+            try:
+                static_features = torch.empty_like(features_tensor)
+                static_features.copy_(features_tensor)
+                warmup_stream = torch.cuda.Stream(device=features_tensor.device)
+                warmup_stream.wait_stream(torch.cuda.current_stream(features_tensor.device))
+                with torch.cuda.stream(warmup_stream), torch.inference_mode():
+                    for _ in range(3):
+                        static_audio = self.module(static_features)
+                torch.cuda.current_stream(features_tensor.device).wait_stream(warmup_stream)
+
+                graph = torch.cuda.CUDAGraph()
+                with torch.cuda.graph(graph), torch.inference_mode():
+                    static_audio = self.module(static_features)
+                entry = (graph, static_features, static_audio)
+                self.graphs[key] = entry
+            except Exception:
+                self.use_cudagraph = False
+                self.graphs.clear()
+                try:
+                    torch.cuda.synchronize(features_tensor.device)
+                except Exception:
+                    pass
+                with torch.inference_mode():
+                    return self.module(features_tensor)
+
+        graph, static_features, static_audio = entry
+        static_features.copy_(features_tensor)
+        graph.replay()
+        return static_audio
+
+
+def run_vocoder(
+    session: Any,
+    features: np.ndarray | torch.Tensor,
+    feature_lengths: np.ndarray | torch.Tensor,
+) -> torch.Tensor:
+    if isinstance(session, TorchScriptVocoderRuntime):
+        if isinstance(features, np.ndarray):
+            features_tensor = torch.from_numpy(features).to(device=session.device, dtype=torch.float32)
+        else:
+            features_tensor = features.to(device=session.device, dtype=torch.float32)
+        with torch.inference_mode():
+            audio_tensor = session.run_tensor(features_tensor)
+        if session.device.type == "cuda":
+            torch.cuda.synchronize()
+        if isinstance(feature_lengths, torch.Tensor):
+            samples = int(feature_lengths[0].item()) * 960
+        else:
+            samples = int(feature_lengths[0]) * 960
+        audio = audio_tensor[0, 0, :samples].detach().float().cpu()
+        return torch.nan_to_num(audio).reshape(-1).clamp(-1.0, 1.0)
+
+    if isinstance(features, torch.Tensor):
+        features = features.detach().cpu().numpy()
+    if isinstance(feature_lengths, torch.Tensor):
+        feature_lengths = feature_lengths.detach().cpu().numpy()
+    return run_vocoder_onnx(session, features, feature_lengths)
+
+
+def parse_int_csv(value: str) -> list[int]:
+    values: list[int] = []
+    for part in value.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        values.append(int(part))
+    return values
+
+
+def enable_static_cache_for_global_model(model: Any) -> None:
+    type(model)._can_compile_fullgraph = True
+    language_config = model.config.language_config
+    for field in (
+        "max_position_embeddings",
+        "hidden_size",
+        "num_attention_heads",
+        "head_dim",
+        "num_key_value_heads",
+        "sliding_window",
+        "layer_types",
+        "num_hidden_layers",
+    ):
+        if hasattr(language_config, field):
+            setattr(model.config, field, getattr(language_config, field))
+
+
+def configure_torch_compile() -> None:
+    import importlib
+    import torch._inductor.config as inductor_config
+
+    dynamo_config = importlib.import_module("torch._dynamo.config")
+    dynamo_config.cache_size_limit = 256
+    dynamo_config.capture_scalar_outputs = True
+    inductor_config.triton.cudagraphs = False
+    inductor_config.triton.cudagraph_trees = False
+    inductor_config.triton.cudagraph_skip_dynamic_graphs = True
+
+
+@dataclass
+class OptimizedTTSConfig:
+    checkpoint: str | Path = "moss_tts_local_clipper_checkpoint"
+    codec_path: str | Path = "moss_audio_tokenizer"
+    decoder_dir: str | Path = "istftnet2_decoder4_50hz"
+    decoder4_features_onnx: str | Path = "ort_sessions/decoder4_features_fp32/model.onnx"
+    decoder_runtime: str = "torchscript_cuda"
+    vocoder_cudagraph: bool = False
+    vocoder_bucket_frames: int = 0
+    vocoder_prewarm_buckets: str = ""
+    decoder4_features_runtime: str = "torch_fp16"
+    decoder4_provider: str = "CUDAExecutionProvider"
+    dtype: str = "fp16"
+    tts_quantization: str = "none"
+    torch_opt_mode: str = "static-local-cache-triton-compile-cudagraph"
+    compile_mode: str = "max-autotune-no-cudagraphs"
+    cache_implementation: str = "static"
+    compile_global_transformer: bool = True
+    global_compile_mode: str = "default"
+    attn_implementation: str = "sdpa"
+    fast_prepare_inputs: bool = True
+    tensorrt_local: bool = False
+    triton_top_p: bool = False
+    triton_fused_lm_head: bool = False
+    triton_qkv_cache: bool = False
+    packed_local_qkv: bool = False
+    packed_local_mlp: bool = False
+    packed_adapter_mlp: bool = False
+    packed_adapter_mlp_scope: str = "heads"
+    static_packed_weights: bool = False
+    triton_rmsnorm: bool = False
+    tensorize_rmsnorm_eps: bool = True
+    fast_control_head: bool = False
+    feedback_lookup: bool = True
+    local_compile_fullgraph: bool = False
+    style_bert_model: str = "cirimus/modernbert-base-go-emotions"
+    style_bert_layer: int = 19
+    style_bert_max_length: int = 512
+
+
+class OptimizedTTSRunner:
+    def __init__(self, config: OptimizedTTSConfig) -> None:
+        ensure_nvidia_library_path()
+        torch.backends.cudnn.benchmark = False
+        try:
+            torch.backends.cuda.enable_cudnn_sdp(False)
+            torch.backends.cuda.enable_flash_sdp(True)
+            torch.backends.cuda.enable_mem_efficient_sdp(True)
+            torch.backends.cuda.enable_math_sdp(True)
+        except Exception:
+            pass
+
+        checkpoint = add_release_root_to_syspath(config.checkpoint)
+        codec_path = resolve_asset(config.codec_path)
+        decoder_dir = resolve_asset(config.decoder_dir)
+        decoder4_features_onnx = resolve_asset(config.decoder4_features_onnx)
+
+        from torch_hf_optimizations import install_torch_frame_sampler, tensorize_rmsnorm_eps
+
+        import onnxruntime as ort
+
+        self.config = config
+        self.checkpoint = checkpoint
+        self.codec_path = codec_path
+        self.decoder_dir = decoder_dir
+        self.decoder4_features_onnx = decoder4_features_onnx
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.dtype = select_dtype(self.device, config.dtype)
+
+        wants_cuda = (
+            config.decoder4_provider == "CUDAExecutionProvider"
+            or config.decoder_runtime == "onnx_cuda"
+            or config.decoder4_features_runtime == "torch_fp16"
+        )
+        if wants_cuda and hasattr(ort, "preload_dlls"):
+            ort.preload_dlls(cuda=True, cudnn=True, directory="")
+        available_providers = ort.get_available_providers()
+        session_options = ort.SessionOptions()
+        session_options.log_severity_level = 2
+        self.available_ort_providers = available_providers
+
+        self.processor = build_processor_without_audio_model(checkpoint)
+        self.processor.model_config.sampling_rate = 48000
+        if config.decoder4_features_runtime == "onnx":
+            self.decoder4_session = ort.InferenceSession(
+                str(decoder4_features_onnx),
+                sess_options=session_options,
+                providers=choose_providers(config.decoder4_provider, available_providers),
+            )
+        elif config.decoder4_features_runtime == "torch_fp16":
+            self.decoder4_session = TorchDecoder4FeatureRuntime(codec_path, device=self.device, dtype=torch.float16)
+        else:
+            raise ValueError(f"Unsupported decoder4_features_runtime: {config.decoder4_features_runtime}")
+
+        if config.decoder_runtime.startswith("torchscript_"):
+            vocoder_device = torch.device(
+                "cuda" if config.decoder_runtime == "torchscript_cuda" and torch.cuda.is_available() else "cpu"
+            )
+            self.vocoder_session = TorchScriptVocoderRuntime(
+                decoder_dir,
+                vocoder_device,
+                use_cudagraph=config.vocoder_cudagraph,
+                bucket_frames=config.vocoder_bucket_frames,
+            )
+        else:
+            vocoder_provider = "CUDAExecutionProvider" if config.decoder_runtime == "onnx_cuda" else "CPUExecutionProvider"
+            self.vocoder_session = ort.InferenceSession(
+                str(decoder_dir / "istftnet2_decoder.onnx"),
+                sess_options=session_options,
+                providers=choose_providers(vocoder_provider, available_providers),
+            )
+        self.vocoder_prewarm_result: dict[str, Any] | None = None
+        if isinstance(self.vocoder_session, TorchScriptVocoderRuntime):
+            prewarm_buckets = parse_int_csv(config.vocoder_prewarm_buckets)
+            if prewarm_buckets:
+                self.vocoder_prewarm_result = self.vocoder_session.prewarm_buckets(prewarm_buckets)
+        tts_load_kwargs: dict[str, Any] = {
+            "trust_remote_code": True,
+            "torch_dtype": self.dtype,
+            "attn_implementation": config.attn_implementation,
+        }
+        if config.tts_quantization != "none":
+            if self.device.type != "cuda":
+                raise RuntimeError("TorchAO TTS quantization requires CUDA in this runner.")
+            modules_to_not_convert = None
+            if config.tts_quantization in {
+                "torchao_fp8_weight_only_global",
+                "torchao_fp8_dynamic_activation_fp8_weight_global",
+            }:
+                modules_to_not_convert = [
+                    "local_transformer",
+                    "speech_embedding_to_local_mlp",
+                    "local_to_speech_embedding_mlps",
+                    "layer_norm_before_lm_heads",
+                    "lm_heads",
+                ]
+                if config.tts_quantization == "torchao_fp8_weight_only_global":
+                    quant_kind = "torchao_fp8_weight_only"
+                else:
+                    quant_kind = "torchao_fp8_dynamic_activation_fp8_weight"
+            else:
+                quant_kind = config.tts_quantization
+            if quant_kind == "torchao_fp8_weight_only":
+                from torchao.quantization import Float8WeightOnlyConfig
+
+                tts_load_kwargs["quantization_config"] = TorchAoConfig(
+                    Float8WeightOnlyConfig(),
+                    modules_to_not_convert=modules_to_not_convert,
+                )
+            elif quant_kind == "torchao_fp8_dynamic_activation_fp8_weight":
+                from torchao.quantization import Float8DynamicActivationFloat8WeightConfig
+
+                tts_load_kwargs["quantization_config"] = TorchAoConfig(
+                    Float8DynamicActivationFloat8WeightConfig(),
+                    modules_to_not_convert=modules_to_not_convert,
+                )
+            else:
+                raise ValueError(f"Unsupported tts_quantization: {config.tts_quantization}")
+            tts_load_kwargs["device_map"] = {"": self.device.index or 0}
+        self.model = AutoModel.from_pretrained(checkpoint, **tts_load_kwargs)
+        if config.tts_quantization == "none":
+            self.model = self.model.to(self.device)
+        self.model.eval()
+        self.style_feature_dim = int(getattr(self.model.config, "style_feature_dim", 0) or 0)
+        self.num_emotions = int(getattr(self.model.config, "num_emotions", 0) or 0)
+        self.style_extractor = None
+        if self.style_feature_dim > 0 and self.style_feature_dim != 2:
+            BertStyleFeatureExtractor = load_style_extractor_class(checkpoint)
+            self.style_extractor = BertStyleFeatureExtractor(
+                repo_id=config.style_bert_model,
+                layer_index=config.style_bert_layer,
+                max_length=config.style_bert_max_length,
+                target_dim=self.style_feature_dim,
+                device=self.device,
+                dtype=self.dtype,
+                attn_implementation="sdpa" if self.device.type == "cuda" else "eager",
+            )
+        self.tensorized_rmsnorm_eps = 0
+        if config.tensorize_rmsnorm_eps:
+            self.tensorized_rmsnorm_eps = tensorize_rmsnorm_eps(self.model, device=self.device)
+        if config.compile_global_transformer:
+            configure_torch_compile()
+        if config.compile_global_transformer or config.cache_implementation == "static":
+            enable_static_cache_for_global_model(self.model)
+        if config.compile_global_transformer:
+            if config.global_compile_mode == "default":
+                global_compile_mode = None
+                global_compile_options = None
+                self.global_compile_mode_effective = "default"
+            else:
+                global_compile_mode = None
+                global_compile_options = {
+                    "triton.cudagraphs": False,
+                    "triton.cudagraph_trees": False,
+                    "triton.cudagraph_skip_dynamic_graphs": True,
+                }
+                self.global_compile_mode_effective = "default-no-inductor-cudagraphs"
+            self.model.model.language_model = torch.compile(
+                self.model.model.language_model,
+                mode=global_compile_mode,
+                options=global_compile_options,
+                fullgraph=False,
+                dynamic=True,
+            )
+        else:
+            self.global_compile_mode_effective = "disabled"
+        install_torch_frame_sampler(
+            self.model,
+            mode=config.torch_opt_mode,
+            compile_mode=config.compile_mode,
+            packed_local_qkv=config.packed_local_qkv,
+            packed_local_mlp=config.packed_local_mlp,
+            packed_adapter_mlp=config.packed_adapter_mlp,
+            packed_adapter_mlp_scope=config.packed_adapter_mlp_scope,
+            static_packed_weights=config.static_packed_weights,
+            triton_rmsnorm=config.triton_rmsnorm,
+            tensorrt_local=config.tensorrt_local,
+            triton_top_p=config.triton_top_p,
+            triton_fused_lm_head=config.triton_fused_lm_head,
+            triton_qkv_cache=config.triton_qkv_cache,
+            fast_prepare_inputs=config.fast_prepare_inputs,
+            fast_control_head=config.fast_control_head,
+            feedback_lookup=config.feedback_lookup,
+            local_compile_fullgraph=config.local_compile_fullgraph,
+        )
+        self.sample_rate = int(self.processor.model_config.sampling_rate)
+
+    def decode_outputs(self, outputs: list[tuple[int, torch.Tensor]]) -> tuple[torch.Tensor, float]:
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()
+        start = time.perf_counter()
+        decoded_segments: list[torch.Tensor] = []
+        codes_input_name = self.decoder4_session.get_inputs()[0].name
+        lengths_input_name = self.decoder4_session.get_inputs()[1].name
+        for start_length, generation_ids in outputs:
+            frame_tokens = generation_ids.detach().cpu()[:, 0]
+            audio_codes = generation_ids.detach().cpu()[:, 1:]
+            is_pad = (audio_codes == int(self.processor.model_config.audio_pad_code)).all(dim=1)
+            is_eos = frame_tokens == int(self.processor.model_config.audio_end_token_id)
+            non_pad = ~is_pad & ~is_eos
+            if not non_pad.any():
+                continue
+            idx = torch.nonzero(non_pad).squeeze(1)
+            breaks = torch.where(idx[1:] != idx[:-1] + 1)[0] + 1
+            segments_idx = [idx] if breaks.numel() == 0 else list(torch.split(idx, breaks.tolist()))
+            for segment_index, segment_idx in enumerate(segments_idx):
+                segment_codes = audio_codes[segment_idx].contiguous()
+                if int(segment_codes.shape[0]) <= 0:
+                    continue
+                codes_np = segment_codes.T.unsqueeze(1).numpy().astype(np.int64, copy=False)
+                lengths_np = np.asarray([int(segment_codes.shape[0])], dtype=np.int64)
+                feeds = {codes_input_name: codes_np, lengths_input_name: lengths_np}
+                if hasattr(self.decoder4_session, "run_tensors"):
+                    features, feature_lengths = self.decoder4_session.run_tensors(feeds)
+                else:
+                    features, feature_lengths = self.decoder4_session.run(None, feeds)
+                segment_audio = run_vocoder(self.vocoder_session, features, feature_lengths)
+                if segment_index == 0 and int(start_length) > 0:
+                    trim_ratio = max(0.0, min(float(start_length) / float(segment_codes.shape[0]), 1.0))
+                    if trim_ratio >= 1.0:
+                        continue
+                    if trim_ratio > 0.0:
+                        segment_audio = segment_audio[..., int(segment_audio.shape[-1] * trim_ratio) :]
+                decoded_segments.append(segment_audio)
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()
+        elapsed = time.perf_counter() - start
+        if not decoded_segments:
+            raise RuntimeError("Generation did not produce decodable audio.")
+        return torch.cat(decoded_segments, dim=-1).float().cpu(), elapsed
+
+    def synthesize(
+        self,
+        *,
+        text: str,
+        language: str = "en",
+        speaker_id: int = 31,
+        max_new_tokens: int = 160,
+        text_temperature: float = 0.0,
+        text_top_p: float = 1.0,
+        text_top_k: int | None = None,
+        audio_temperature: float = 0.8,
+        audio_top_p: float = 0.92,
+        audio_top_k: int | None = None,
+        audio_repetition_penalty: float = 1.0,
+        n_vq_for_inference: int = 32,
+        style_text: str | None = None,
+        style_features: torch.Tensor | None = None,
+        style_emotion_id: int | None = None,
+        style_energy: float = 0.7,
+    ) -> dict[str, Any]:
+        conversations = [[self.processor.build_user_message(text=text, language=language)]]
+        prompt_start = time.perf_counter()
+        batch = self.processor(conversations, mode="generation")
+        input_ids = batch["input_ids"].to(self.device)
+        attention_mask = batch["attention_mask"].to(self.device)
+        prompt_sec = time.perf_counter() - prompt_start
+
+        if self.device.type == "cuda":
+            torch.cuda.synchronize()
+        generate_start = time.perf_counter()
+        generation_kwargs = {}
+        if self.config.cache_implementation != "none":
+            generation_kwargs["cache_implementation"] = self.config.cache_implementation
+        speaker_tensor = torch.tensor([speaker_id], device=self.device, dtype=torch.long)
+        generation_kwargs["speaker_ids"] = speaker_tensor
+        if self.style_feature_dim > 0:
+            if style_features is None:
+                if self.style_feature_dim == 2 and style_emotion_id is not None:
+                    max_emotion = max(0, (self.num_emotions or 1) - 1)
+                    style_features = torch.tensor(
+                        [
+                            [
+                                float(max(0, min(max_emotion, int(style_emotion_id)))),
+                                float(max(0.0, min(1.0, style_energy))),
+                            ]
+                        ],
+                        dtype=torch.float32,
+                    )
+                elif self.style_extractor is None:
+                    raise RuntimeError("Checkpoint expects style features, but no style extractor is available.")
+                else:
+                    style_features = self.style_extractor.encode((style_text or text).strip())
+            generation_kwargs["style_features"] = style_features.to(device=self.device)
+        with torch.inference_mode():
+            outputs = self.model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=max_new_tokens,
+                n_vq_for_inference=n_vq_for_inference,
+                text_temperature=text_temperature,
+                text_top_p=text_top_p,
+                text_top_k=text_top_k,
+                audio_temperature=audio_temperature,
+                audio_top_p=audio_top_p,
+                audio_top_k=None,
+                audio_repetition_penalty=audio_repetition_penalty,
+                **generation_kwargs,
+            )
+        if self.device.type == "cuda":
+            torch.cuda.synchronize()
+        generate_sec = time.perf_counter() - generate_start
+
+        audio, decode_sec = self.decode_outputs(outputs)
+        audio_sec = float(audio.numel() / self.sample_rate)
+        return {
+            "audio": audio,
+            "audio_sec": audio_sec,
+            "prompt_sec": prompt_sec,
+            "generate_sec": generate_sec,
+            "decode_sec": decode_sec,
+            "generate_x_realtime": audio_sec / generate_sec if generate_sec else 0.0,
+            "total_x_realtime": audio_sec / (generate_sec + decode_sec) if generate_sec + decode_sec else 0.0,
+            "generated_tokens": int(outputs[0][1].shape[0]) if outputs else 0,
+            "prompt_tokens": int(input_ids.shape[1]),
+        }
+
+    def runtime_summary(self) -> dict[str, Any]:
+        return {
+            "device": str(self.device),
+            "dtype": str(self.dtype),
+            "tts_quantization": self.config.tts_quantization,
+            "processor_loads_audio_tokenizer": False,
+            "audio_decode_runtime": f"{self.config.decoder4_features_runtime}_decoder4_features_plus_{self.config.decoder_runtime}_vocoder",
+            "checkpoint": str(self.checkpoint),
+            "codec_path": str(self.codec_path),
+            "decoder_dir": str(self.decoder_dir),
+            "decoder4_features_onnx": str(self.decoder4_features_onnx),
+            "vocoder_onnx": str(self.decoder_dir / "istftnet2_decoder.onnx"),
+            "decoder4_providers": self.decoder4_session.get_providers(),
+            "vocoder_providers": self.vocoder_session.get_providers(),
+            "available_ort_providers": self.available_ort_providers,
+            "torch_opt_mode": self.config.torch_opt_mode,
+            "compile_mode": self.config.compile_mode,
+            "cache_implementation": self.config.cache_implementation,
+            "compile_global_transformer": bool(self.config.compile_global_transformer),
+            "global_compile_mode": self.global_compile_mode_effective,
+            "fast_prepare_inputs": bool(self.config.fast_prepare_inputs),
+            "tensorrt_local": bool(self.config.tensorrt_local),
+            "triton_top_p": bool(self.config.triton_top_p),
+            "triton_fused_lm_head": bool(self.config.triton_fused_lm_head),
+            "triton_qkv_cache": bool(self.config.triton_qkv_cache),
+            "packed_local_qkv": bool(self.config.packed_local_qkv),
+            "packed_local_mlp": bool(self.config.packed_local_mlp),
+            "packed_adapter_mlp": bool(self.config.packed_adapter_mlp),
+            "packed_adapter_mlp_scope": self.config.packed_adapter_mlp_scope,
+            "static_packed_weights": bool(self.config.static_packed_weights),
+            "triton_rmsnorm": bool(self.config.triton_rmsnorm),
+            "tensorize_rmsnorm_eps": bool(self.config.tensorize_rmsnorm_eps),
+            "tensorized_rmsnorm_eps": int(self.tensorized_rmsnorm_eps),
+            "fast_control_head": bool(self.config.fast_control_head),
+            "feedback_lookup": bool(self.config.feedback_lookup),
+            "local_compile_fullgraph": bool(self.config.local_compile_fullgraph),
+            "style_feature_dim": int(self.style_feature_dim),
+            "num_emotions": int(self.num_emotions),
+            "vocoder_cudagraph": bool(self.config.vocoder_cudagraph),
+            "vocoder_bucket_frames": int(self.config.vocoder_bucket_frames),
+            "vocoder_prewarm_buckets": parse_int_csv(self.config.vocoder_prewarm_buckets),
+            "vocoder_prewarm_result": self.vocoder_prewarm_result,
+        }
+
+
+def write_summary(path: Path, summary: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    serializable = {
+        key: value
+        for key, value in summary.items()
+        if not isinstance(value, torch.Tensor)
+    }
+    path.write_text(json.dumps(serializable, indent=2))

requirements.txt

@@ -0,0 +1,4 @@
+transformers==4.55.0
+onnxruntime-gpu==1.26.0
+safetensors
+numpy

speaker_hours_tiers.csv

@@ -0,0 +1,44 @@
+tier,speaker_id,speaker,utterances,codec_hours,flac_hours,avg_sec,min_sec,max_sec,missing
+1,0,Apple Bloom,1296,0.8802888888888889,0.8941135879629628,2.445246913580247,0.32,8.64,0
+1,1,Applejack,3143,2.1064666666666665,2.1398366145833307,2.412752147629653,0.24,8.4,0
+3,2,Autumn Blaze,161,0.11495555555555555,0.11679866898148142,2.5704347826086953,0.16,7.2,0
+3,3,Big Mac,222,0.11515555555555555,0.11741705439814816,1.8673873873873874,0.32,7.12,0
+3,4,Cadance,165,0.12504444444444446,0.12680443865740743,2.7282424242424246,0.64,9.6,0
+2,5,Celestia,583,0.4552222222222222,0.46121357638888894,2.8109777015437394,0.48,10.56,0
+3,6,Cheerilee,111,0.07991111111111111,0.08106452546296296,2.591711711711712,0.72,6.56,0
+2,7,Chrysalis,178,0.1591111111111111,0.16089883101851857,3.2179775280898872,0.48,8.24,0
+3,8,Cozy Glow,157,0.11946666666666667,0.1210344386574074,2.739363057324841,0.72,7.2,0
+3,9,Diamond Tiara,102,0.08711111111111111,0.08823683449074078,3.074509803921569,0.8,8.4,0
+2,10,Discord,476,0.38424444444444444,0.38949334490740734,2.906050420168067,0.56,9.12,0
+1,11,Fluttershy,1792,1.2326666666666668,1.252261811342593,2.476339285714286,0.24,9.04,0
+2,12,Goldie Delicious,177,0.15811111111111112,0.16000179398148143,3.215819209039548,0.96,7.44,0
+2,13,Granny Smith,286,0.23762222222222223,0.24077664351851852,2.9910489510489513,0.64,9.36,0
+3,14,Luna,191,0.1398888888888889,0.14183635416666662,2.636649214659686,0.56,7.28,0
+3,15,Maud,177,0.09362222222222223,0.0954588541666667,1.904180790960452,0.48,8.32,0
+3,16,Mrs. Cake,135,0.11806666666666667,0.11953124421296295,3.1484444444444444,0.72,7.04,0
+1,17,Pinkie,2080,1.2596,1.2820753935185158,2.1800769230769235,0.24,8.8,0
+1,18,Rainbow,2333,1.513088888888889,1.5377426851851859,2.3348135447921132,0.32,9.2,0
+1,19,Rarity,2383,1.6880444444444445,1.71413467013889,2.550130088124213,0.16,12.16,0
+1,20,Scootaloo,774,0.5134888888888889,0.5219100347222223,2.3883204134366927,0.4,8.32,0
+3,21,Shining Armor,118,0.09484444444444444,0.09610426504629628,2.8935593220338984,0.4,11.28,0
+1,22,Spike,1791,1.0443111111111112,1.0638599907486153,2.099117811278615,0.32,9.6,0
+3,23,Spitfire,134,0.08724444444444444,0.08878343749999998,2.3438805970149255,0.4,6.16,0
+1,24,Starlight,1125,0.8553777777777778,0.8673828676933746,2.737208888888889,0.24,8.56,0
+3,25,Sunburst,198,0.131,0.1332123370575082,2.381818181818182,0.4,7.6,0
+2,26,Sunset Shimmer,549,0.36691111111111113,0.3728748379629632,2.4059744990892535,0.48,7.6,0
+1,27,Sweetie Belle,771,0.5104222222222222,0.5186199594907405,2.383294422827497,0.16,8.08,0
+3,28,Thorax,124,0.08544444444444445,0.0869096238425926,2.480645161290323,0.64,7.04,0
+2,29,Tirek,150,0.15304444444444446,0.1547323090277777,3.6730666666666667,0.88,8.16,0
+1,30,Trixie,609,0.5680888888888889,0.5745289583333333,3.3581609195402295,0.4,9.12,0
+1,31,Twilight,4628,3.041355555555555,3.0922718935027667,2.365790838375108,0.16,10.96,0
+3,32,Zecora,111,0.10197777777777778,0.1031401215277778,3.3073873873873874,0.96,6.8,0
+2,33,Demo,571,0.4166666666666667,0.42297333333333315,2.626970227670753,0.32,10.56,0
+2,34,Engineer,665,0.35619999999999996,0.3636970312500003,1.928300751879699,0.24,9.04,0
+1,35,Heavy,807,0.5254888888888889,0.5347120081018519,2.344188351920694,0.32,19.52,0
+2,36,Medic,489,0.25353333333333333,0.2588444097222222,1.8665030674846625,0.24,6.4,0
+1,37,Merasmus,739,1.079911111111111,1.0880798206018514,5.260730717185385,0.72,43.68,0
+2,38,Pauling,317,0.20524444444444445,0.20856595486111115,2.3308517350157727,0.4,11.36,0
+2,39,Scout,992,0.4975333333333333,0.5081581655092591,1.8055645161290321,0.16,15.28,0
+2,40,Sniper,852,0.43008888888888885,0.43924168402777747,1.8172769953051642,0.24,7.52,0
+1,41,Soldier,898,0.5638444444444444,0.5731967187500004,2.260400890868597,0.24,13.04,0
+2,42,Spy,691,0.37537777777777775,0.38310017939814806,1.9556584659913168,0.32,9.92,0

speaker_id_map.csv

@@ -0,0 +1,44 @@
+speaker_id,name,display_name,label,utterance_count
+0,Apple Bloom,Apple Bloom,Apple Bloom (0),1296
+1,Applejack,Applejack,Applejack (1),3143
+2,Autumn Blaze,Autumn Blaze,Autumn Blaze (2),161
+3,Big Mac,Big Mac,Big Mac (3),222
+4,Cadance,Cadance,Cadance (4),165
+5,Celestia,Celestia,Celestia (5),583
+6,Cheerilee,Cheerilee,Cheerilee (6),111
+7,Chrysalis,Chrysalis,Chrysalis (7),178
+8,Cozy Glow,Cozy Glow,Cozy Glow (8),157
+9,Diamond Tiara,Diamond Tiara,Diamond Tiara (9),102
+10,Discord,Discord,Discord (10),476
+11,Fluttershy,Fluttershy,Fluttershy (11),1792
+12,Goldie Delicious,Goldie Delicious,Goldie Delicious (12),177
+13,Granny Smith,Granny Smith,Granny Smith (13),286
+14,Luna,Luna,Luna (14),191
+15,Maud,Maud,Maud (15),177
+16,Mrs. Cake,Mrs. Cake,Mrs. Cake (16),135
+17,Pinkie,Pinkie,Pinkie (17),2080
+18,Rainbow,Rainbow,Rainbow (18),2333
+19,Rarity,Rarity,Rarity (19),2383
+20,Scootaloo,Scootaloo,Scootaloo (20),774
+21,Shining Armor,Shining Armor,Shining Armor (21),118
+22,Spike,Spike,Spike (22),1791
+23,Spitfire,Spitfire,Spitfire (23),134
+24,Starlight,Starlight,Starlight (24),1125
+25,Sunburst,Sunburst,Sunburst (25),198
+26,Sunset Shimmer,Sunset Shimmer,Sunset Shimmer (26),549
+27,Sweetie Belle,Sweetie Belle,Sweetie Belle (27),771
+28,Thorax,Thorax,Thorax (28),124
+29,Tirek,Tirek,Tirek (29),150
+30,Trixie,Trixie,Trixie (30),609
+31,Twilight,Twilight,Twilight (31),4628
+32,Zecora,Zecora,Zecora (32),111
+33,demo,Demo,Demo (33),571
+34,engineer,Engineer,Engineer (34),665
+35,heavy,Heavy,Heavy (35),807
+36,medic,Medic,Medic (36),489
+37,merasmus,Merasmus,Merasmus (37),739
+38,pauling,Pauling,Pauling (38),317
+39,scout,Scout,Scout (39),992
+40,sniper,Sniper,Sniper (40),852
+41,soldier,Soldier,Soldier (41),898
+42,spy,Spy,Spy (42),691