windextts 0.1.0__py3-none-any.whl

windextts/__init__.py

@@ -0,0 +1,3 @@
+"""WIndexTTS: pure-torch accelerated inference for IndexTTS-2.5."""
+
+__version__ = "0.1.0"

windextts/__main__.py

@@ -0,0 +1,5 @@
+"""python -m windextts → windextts.cli:main"""
+from windextts.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

windextts/attention.py

@@ -0,0 +1,154 @@
+"""Adaptive SDPA (Scaled Dot-Product Attention) backend selection.
+
+Design goal: **zero external attention dependency** in the core inference path.
+We use only ``torch.nn.functional.scaled_dot_product_attention`` (SDPA) with
+explicit backend pinning via ``torch.nn.attention.sdpa_kernel``. No ``flash_attn``
+import, no triton — works on Windows with stock torch wheels.
+
+Backend policy (verified on torch 2.8.0+cu128, A10G):
+  - prefill (seq > 1, e.g. GPT conditioning / DiT): ``CUDNN_ATTENTION``.
+    Ships inside the torch CUDA wheel (cross-platform, no extra install).
+    Measured ~= flash_attn speed, slightly faster.
+  - decode (q seq == 1, GPT autoregressive step): cuDNN is *rejected* by
+    PyTorch's sdp_utils guard ("cudnn SDPA does not support sequence length 1"
+    — conservative perf guard in sdp_utils.cpp:458, not a library limitation).
+    Use ``FLASH_ATTENTION`` on Linux, ``EFFICIENT_ATTENTION`` on Windows
+    (mem_eff is the Windows-safe fallback; official flash backend needs a
+    wheel match).
+
+The kernel choice is made per-call (cheap) so a single module can mix prefill
+and decode without two code paths. All public helpers accept the standard SDPA
+tensors and forward ``is_causal`` / ``scale``.
+"""
+from __future__ import annotations
+
+import os
+
+import torch
+import torch.nn.functional as F
+from torch.nn.attention import SDPBackend, sdpa_kernel
+
+# ---------------------------------------------------------------------------
+# Platform detection — Windows gets mem_eff for decode; Linux gets flash.
+# cuDNN is always preferred for prefill where available.
+# ---------------------------------------------------------------------------
+
+_IS_WINDOWS = os.name == "nt" or os.environ.get("WINDEXTTS_FORCE_WIN") == "1"
+# Allow override for benchmarking / debugging.
+_FORCE_PREFILL = os.environ.get("WINDEXTTS_ATTN_PREFILL", "")  # cudnn|flash|eff|math
+_FORCE_DECODE = os.environ.get("WINDEXTTS_ATTN_DECODE", "")
+
+
+def _backend_for_prefill() -> SDPBackend:
+    if _FORCE_PREFILL == "flash":
+        return SDPBackend.FLASH_ATTENTION
+    if _FORCE_PREFILL == "eff":
+        return SDPBackend.EFFICIENT_ATTENTION
+    if _FORCE_PREFILL == "math":
+        return SDPBackend.MATH
+    # Default: cuDNN (fastest, bundled in torch CUDA wheel).
+    return SDPBackend.CUDNN_ATTENTION
+
+
+def _backend_for_decode() -> SDPBackend:
+    if _FORCE_DECODE == "flash":
+        return SDPBackend.FLASH_ATTENTION
+    if _FORCE_DECODE == "eff":
+        return SDPBackend.EFFICIENT_ATTENTION
+    if _FORCE_DECODE == "math":
+        return SDPBackend.MATH
+    # cuDNN cannot run with query seq==1 (sdp_utils.cpp:458 guard). Pick the
+    # best available: flash on Linux, mem_eff on Windows (no wheel dependency).
+    return SDPBackend.EFFICIENT_ATTENTION if _IS_WINDOWS else SDPBackend.FLASH_ATTENTION
+
+
+def _is_decode(query: torch.Tensor) -> bool:
+    """A decode step has query sequence length == 1 (single new token)."""
+    return query.size(-2) == 1
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def attn(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    *,
+    attn_mask: torch.Tensor | None = None,
+    dropout_p: float = 0.0,
+    is_causal: bool = False,
+    scale: float | None = None,
+) -> torch.Tensor:
+    """Adaptive-backend scaled dot-product attention.
+
+    Picks cuDNN for prefill (seq>1) and flash/mem_eff for decode (q seq==1),
+    matching the measured-optimal backend per shape.
+
+    Args:
+        query/key/value: [..., seq, head_dim] tensors (leading dims broadcast).
+        attn_mask, dropout_p, is_causal, scale: forwarded to SDPA.
+
+    Returns:
+        Attention output, same shape as ``query``.
+    """
+    backend = _backend_for_decode() if _is_decode(query) else _backend_for_prefill()
+    with sdpa_kernel([backend]):
+        return F.scaled_dot_product_attention(
+            query,
+            key,
+            value,
+            attn_mask=attn_mask,
+            dropout_p=dropout_p,
+            is_causal=is_causal,
+            scale=scale,
+        )
+
+
+def attn_prefill(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    **kwargs,
+) -> torch.Tensor:
+    """Prefill-path attention — pinned to cuDNN (seq>1, e.g. DiT / GPT cond)."""
+    with sdpa_kernel([_backend_for_prefill()]):
+        return F.scaled_dot_product_attention(query, key, value, **kwargs)
+
+
+def attn_decode(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    **kwargs,
+) -> torch.Tensor:
+    """Decode-path attention — flash(Linux)/mem_eff(Win), for q seq==1."""
+    with sdpa_kernel([_backend_for_decode()]):
+        return F.scaled_dot_product_attention(query, key, value, **kwargs)
+
+
+if __name__ == "__main__":
+    # Smoke test: verify backend selection and that decode falls back correctly.
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    dt = torch.bfloat16 if dev == "cuda" else torch.float32
+    print(f"platform: {'windows' if _IS_WINDOWS else 'linux'}, torch {torch.__version__}")
+    print(
+        f"prefill backend: {_backend_for_prefill().name} | "
+        f"decode backend: {_backend_for_decode().name}"
+    )
+
+    # prefill
+    q = k = v = torch.randn(1, 16, 512, 64, device=dev, dtype=dt)
+    o1 = attn(q, k, v, is_causal=True)
+    assert o1.shape == q.shape
+    print(f"prefill ok, out {tuple(o1.shape)}")
+
+    # decode (q seq=1)
+    qd = torch.randn(1, 16, 1, 64, device=dev, dtype=dt)
+    kd = vd = torch.randn(1, 16, 512, 64, device=dev, dtype=dt)
+    o2 = attn(qd, kd, vd)
+    assert o2.shape == qd.shape
+    print(f"decode ok, out {tuple(o2.shape)}")
+    print("SMOKE OK")

windextts/cli.py

@@ -0,0 +1,188 @@
+"""WIndexTTS CLI — synthesize speech from the command line.
+
+Usage:
+    # install model weights first (~7.5GB, one time, resumable)
+    windextts --install-model --model-dir /path/to/IndexTTS-2.5
+
+    # basic (fp16, GPU)
+    windextts --ref ref.wav --text "你好世界" -o out.wav
+
+    # W4A16 quantized GPT (fastest)
+    windextts --ref ref.wav --text "你好世界" -o out.wav --w4a16
+
+    # low VRAM (3-4GB GPUs; keeps beam3, ~2.9GB steady)
+    windextts --ref ref.wav --text "你好世界" -o out.wav --w4a16 --low-vram
+
+    # from a text file, with emotion vector + duration control
+    windextts --ref ref.wav --text-file story.txt -o out.wav \
+        --emo-vector 0.8,0,0,0,0,0,0.2,0 --duration 1.1
+
+    # fp32 reference precision, verbose timing
+    windextts --ref ref.wav --text "hello" -o out.wav --fp32 --verbose
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="windextts",
+        description="WIndexTTS: pure-torch accelerated IndexTTS-2.5 inference "
+                    "(zero JIT compile, Windows friendly).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__.split("Usage:")[-1] if __doc__ else None,
+    )
+    # required inputs
+    p.add_argument("--ref", required=True, help="reference audio path (5-15s clean speech)")
+    p.add_argument("--text", help="text to synthesize (or use --text-file)")
+    p.add_argument("--text-file", help="read text from a file (UTF-8)")
+    p.add_argument("-o", "--output", default="output.wav", help="output wav path")
+
+    # engine mode
+    mode = p.add_mutually_exclusive_group()
+    mode.add_argument("--fp32", action="store_true", help="fp32 weights (highest precision, ~7.6GB)")
+    mode.add_argument("--w4a16", action="store_true",
+                      help="W4A16 INT4 GPT quantization (fastest; needs torchao)")
+    p.add_argument("--low-vram", action="store_true",
+                   help="low-VRAM mode for 3-4GB GPUs (w2v streamed to CPU, "
+                        "beam3 kept, ~2.9GB steady)")
+    p.add_argument("--model-dir", default=None, help="weights directory (gpt.pth, config.yaml, ...)")
+
+    # language / prosody
+    p.add_argument("--lang", default="ZH",
+                   help="language token (ZH/EN/JA/KO/YUE/..., default ZH)")
+    p.add_argument("--duration", type=float, default=1.0,
+                   help="duration factor (official 1.72 scale × factor, default 1.0)")
+
+    # emotion (mutually exclusive sources)
+    emo = p.add_mutually_exclusive_group()
+    emo.add_argument("--emo-vector",
+                     help="8-dim emotion weights happy,angry,sad,afraid,disgusted,"
+                          "melancholic,surprised,calm — e.g. 0.8,0,0,0,0,0,0.2,0")
+    emo.add_argument("--emo-text", help="free-text emotion description (QwenEmotion)")
+    emo.add_argument("--emo-ref", help="emotion reference audio path (conformer path)")
+
+    # sampling
+    p.add_argument("--greedy", action="store_true", help="greedy decode (beam=1, deterministic)")
+    p.add_argument("--top-p", type=float, default=0.8)
+    p.add_argument("--top-k", type=int, default=30)
+    p.add_argument("--temperature", type=float, default=0.8)
+
+    # perf knobs
+    p.add_argument("--cfm-steps", type=int, default=12,
+                   help="S2Mel CFM Euler steps (official 25, default 12)")
+    p.add_argument("--teacache", type=float, default=0.25,
+                   help="TeaCache threshold (0=off, default 0.25)")
+    p.add_argument("--no-normalize", action="store_true",
+                   help="skip text normalization (G2P digits/punctuation)")
+    p.add_argument("--segment-tokens", type=int, default=120,
+                   help="max text tokens per segment (long texts auto-split)")
+
+    p.add_argument("--verbose", action="store_true", help="print per-run timing + VRAM")
+
+    # model install (download weights without synthesizing) — ModelScope direct
+    # links, no SDK dependency, resumable
+    p.add_argument("--install-model", action="store_true",
+                   help="download model weights to --model-dir (or WINDEXTTS_WEIGHTS_DIR) "
+                        "and exit; ~7.5GB from ModelScope direct links. Resumable. "
+                        "Combine with --skip-qwen.")
+    p.add_argument("--skip-qwen", action="store_true",
+                   help="with --install-model: skip qwen0.6bemo4-merge (1.2GB, only "
+                        "needed for emo_text)")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    # --- model install mode ---
+    if args.install_model:
+        from windextts.download import download_model
+        target = args.model_dir or os.environ.get("WINDEXTTS_WEIGHTS_DIR")
+        if not target:
+            print("error: --install-model needs --model-dir or WINDEXTTS_WEIGHTS_DIR",
+                  file=sys.stderr)
+            return 2
+        download_model(target, include_qwen=not args.skip_qwen)
+        return 0
+
+    # --- text source ---
+    if args.text_file:
+        with open(args.text_file, encoding="utf-8") as f:
+            text = f.read()
+    elif args.text:
+        text = args.text
+    else:
+        print("error: either --text or --text-file is required", file=sys.stderr)
+        return 2
+    text = text.strip()
+    if not text:
+        print("error: empty text", file=sys.stderr)
+        return 2
+
+    # --- emotion vector parsing ---
+    emo_vector = None
+    if args.emo_vector:
+        try:
+            emo_vector = [float(x) for x in args.emo_vector.split(",")]
+        except ValueError:
+            print("error: --emo-vector must be 8 comma-separated floats", file=sys.stderr)
+            return 2
+        if len(emo_vector) != 8:
+            print("error: --emo-vector needs exactly 8 values "
+                  "(happy,angry,sad,afraid,disgusted,melancholic,surprised,calm)", file=sys.stderr)
+            return 2
+
+    # --- engine ---
+    import torch
+    from windextts.inference import WIndexTTS
+
+    dtype = torch.float32 if args.fp32 else torch.float16
+    t0 = time.perf_counter()
+    tts = WIndexTTS(
+        weights_dir=args.model_dir, device="cuda", dtype=dtype,
+        enable_w4a16=args.w4a16, low_vram=args.low_vram,
+    )
+    tts.warmup()
+    if args.verbose:
+        print(f"[load+warmup] {time.perf_counter() - t0:.1f}s  "
+              f"VRAM alloc {torch.cuda.memory_allocated() / 1e9:.2f}GB", file=sys.stderr)
+
+    # --- synthesize ---
+    t0 = time.perf_counter()
+    sr, audio = tts.infer(
+        spk_audio_prompt=args.ref,
+        text=text,
+        lang=args.lang,
+        emo_vector=emo_vector,
+        emo_text=args.emo_text,
+        emo_ref_path=args.emo_ref,
+        duration_factor=args.duration,
+        do_sample=not args.greedy,
+        top_p=args.top_p,
+        top_k=args.top_k,
+        temperature=args.temperature,
+        cfm_steps=args.cfm_steps,
+        teacache_thresh=args.teacache,
+        text_normalization=not args.no_normalize,
+        max_text_tokens_per_segment=args.segment_tokens,
+        num_beams=1 if args.greedy else 3,
+    )
+    dt = time.perf_counter() - t0
+    dur = audio.numel() / sr
+
+    import soundfile as sf
+    sf.write(args.output, audio.float().cpu().numpy().squeeze(), sr)
+    print(f"{args.output}  ({dur:.2f}s audio in {dt * 1000:.0f}ms, RTF={dt / dur:.3f}, {sr}Hz)")
+    if args.verbose:
+        print(f"[peak VRAM] {torch.cuda.max_memory_allocated() / 1e9:.2f}GB", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

windextts/config.py

@@ -0,0 +1,326 @@
+"""Typed access to the IndexTTS-2.5 config.yaml.
+
+This is the single source of truth for hyperparameters. The ``Config`` object
+is constructed once from ``/root/IndexTTS-2.5/config.yaml`` (or a copied file)
+and passed to every module. No module should hardcode magic numbers that exist
+in config.yaml — read them here.
+
+Magic numbers that live in source code (infer_v2_5.py), not config.yaml — e.g.
+``w2v-bert hidden_states[17]``, ``1.72`` duration scale, ``diffusion_steps=25`` —
+are collected in :class:`RuntimeConstants` so they are also centralized.
+"""
+from __future__ import annotations
+
+import os
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+# ---------------------------------------------------------------------------
+# Runtime constants — these come from infer_v2_5.py source, NOT config.yaml.
+# Every value must cite its source line. Do NOT invent or tweak.
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class RuntimeConstants:
+    """Constants hardcoded in indextts/infer_v2_5.py (not in config.yaml).
+
+    Each field cites the source line in ``infer_v2_5.py``. These are the
+    "seam magic numbers" — changing any of them produces wrong output.
+    """
+
+    # w2v-bert: which hidden_states layer to use as ref audio feature.
+    # infer_v2_5.py:288  hidden_states[17]
+    w2v_layer: int = 17
+
+    # w2v-bert feature normalization: (feat - mean) / sqrt(var)
+    # stats loaded from wav2vec2bert_stats.pt {mean:[1024], var:[1024]}
+    # infer_v2_5.py:177-179, 289
+    # (handled in weights/frontend, kept here only as documentation anchor)
+
+    # S2Mel duration scaling. infer_v2_5.py:855  1.72 * duration_factor
+    s2mel_duration_scale: float = 1.72
+
+    # S2Mel length_regulator n_quantizers. infer_v2_5.py:655,859
+    s2mel_n_quantizers: int = 3
+
+    # S2Mel CFM. infer_v2_5.py:849-850  diffusion_steps=25, inference_cfg_rate=0.7
+    cfm_diffusion_steps: int = 25
+    cfm_inference_cfg_rate: float = 0.7
+
+    # Output audio. infer_v2_5.py:514  22050 Hz mono
+    output_sr: int = 22050
+
+    # Reference audio resample targets. infer_v2_5.py:628-629
+    ref_sr_mel: int = 22000      # for mel / mel-condition path
+    ref_sr_w2v: int = 16000      # for w2v-bert & campplus
+
+    # Max reference audio length taken (seconds). infer_v2_5.py path
+    ref_max_seconds: float = 15.0
+
+
+# ---------------------------------------------------------------------------
+# config.yaml sections — mirrors /root/IndexTTS-2.5/config.yaml structure.
+# Kept loosely typed (nested dataclasses of plain values) to avoid coupling to
+# any external library's config schema.
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class MelConfig:
+    sample_rate: int = 24000
+    n_fft: int = 1024
+    hop_length: int = 256
+    win_length: int = 1024
+    n_mels: int = 100
+    mel_fmin: float = 0.0
+    normalize: bool = False
+
+
+@dataclass
+class GPTConfig:
+    model_dim: int = 1280
+    max_mel_tokens: int = 1815
+    max_text_tokens: int = 600
+    heads: int = 20
+    use_mel_codes_as_input: bool = True
+    mel_length_compression: int = 1024
+    layers: int = 24
+    number_text_tokens: int = 60509
+    number_mel_codes: int = 8194
+    start_mel_token: int = 8192
+    stop_mel_token: int = 8193
+    start_text_token: int = 0
+    stop_text_token: int = 1
+    train_solo_embeddings: bool = False
+    condition_type: str = "conformer_perceiver"
+    # condition_module / emo_condition_module are nested dicts; kept as-is.
+    condition_module: dict = field(default_factory=dict)
+    emo_condition_module: dict = field(default_factory=dict)
+
+
+@dataclass
+class SemanticCodecConfig:
+    codebook_size: int = 8192
+    hidden_size: int = 1024
+    codebook_dim: int = 8
+    vocos_dim: int = 384
+    vocos_intermediate_dim: int = 2048
+    vocos_num_layers: int = 12
+
+
+@dataclass
+class S2MelDiTConfig:
+    hidden_dim: int = 512
+    num_heads: int = 8
+    depth: int = 13
+    class_dropout_prob: float = 0.1
+    block_size: int = 8192
+    in_channels: int = 80
+    style_condition: bool = True
+    final_layer_type: str = "wavenet"
+    target: str = "mel"
+    content_dim: int = 512
+    content_codebook_size: int = 1024
+    content_type: str = "discrete"
+    f0_condition: bool = False
+    n_f0_bins: int = 512
+    content_codebooks: int = 1
+    is_causal: bool = False
+    long_skip_connection: bool = True
+    zero_prompt_speech_token: bool = False
+    time_as_token: bool = False
+    style_as_token: bool = False
+    uvit_skip_connection: bool = True
+    add_resblock_in_transformer: bool = False
+
+
+@dataclass
+class S2MelLengthRegConfig:
+    channels: int = 512
+    is_discrete: bool = False
+    in_channels: int = 1024
+    content_codebook_size: int = 2048
+    sampling_ratios: tuple = (1, 1, 1, 1)
+    vector_quantize: bool = False
+    n_codebooks: int = 1
+    quantizer_dropout: float = 0.0
+    f0_condition: bool = False
+    n_f0_bins: int = 512
+
+
+@dataclass
+class S2MelConfig:
+    # preprocess_params.spect_params
+    sr: int = 22050
+    n_fft: int = 1024
+    win_length: int = 1024
+    hop_length: int = 256
+    n_mels: int = 80
+    fmin: float = 0.0
+    fmax: float | None = None
+    dit_type: str = "DiT"
+    reg_loss_type: str = "l1"
+    style_encoder_dim: int = 192
+    length_reg: S2MelLengthRegConfig = field(default_factory=S2MelLengthRegConfig)
+    dit: S2MelDiTConfig = field(default_factory=S2MelDiTConfig)
+    wavenet_hidden_dim: int = 512
+    wavenet_num_layers: int = 8
+    wavenet_kernel_size: int = 5
+    wavenet_dilation_rate: int = 1
+    wavenet_p_dropout: float = 0.2
+    wavenet_style_condition: bool = True
+
+
+@dataclass
+class Config:
+    """Top-level config mirroring IndexTTS-2.5 config.yaml."""
+
+    # dataset.mel
+    mel: MelConfig = field(default_factory=MelConfig)
+    gpt: GPTConfig = field(default_factory=GPTConfig)
+    semantic_codec: SemanticCodecConfig = field(default_factory=SemanticCodecConfig)
+    s2mel: S2MelConfig = field(default_factory=S2MelConfig)
+    # vocoder
+    vocoder_type: str = "bigvgan"
+    vocoder_name: str = "bigvgan_generator.pt"
+    version: str = "2.5"
+    # raw dict fallback for anything not yet dataclassed
+    _raw: dict = field(default_factory=dict, repr=False)
+    # runtime constants from infer_v2_5.py
+    rt: RuntimeConstants = field(default_factory=RuntimeConstants)
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "Config":
+        with open(path, "r", encoding="utf-8") as f:
+            raw = yaml.safe_load(f)
+
+        ds = raw.get("dataset", {}) or {}
+        mel_raw = ds.get("mel", {}) or {}
+        mel = MelConfig(
+            sample_rate=mel_raw.get("sample_rate", 24000),
+            n_fft=mel_raw.get("n_fft", 1024),
+            hop_length=mel_raw.get("hop_length", 256),
+            win_length=mel_raw.get("win_length", 1024),
+            n_mels=mel_raw.get("n_mels", 100),
+            mel_fmin=mel_raw.get("mel_fmin", 0.0),
+            normalize=mel_raw.get("normalize", False),
+        )
+
+        g = raw.get("gpt", {}) or {}
+        gpt = GPTConfig(
+            model_dim=g.get("model_dim", 1280),
+            max_mel_tokens=g.get("max_mel_tokens", 1815),
+            max_text_tokens=g.get("max_text_tokens", 600),
+            heads=g.get("heads", 20),
+            use_mel_codes_as_input=g.get("use_mel_codes_as_input", True),
+            mel_length_compression=g.get("mel_length_compression", 1024),
+            layers=g.get("layers", 24),
+            number_text_tokens=g.get("number_text_tokens", 60509),
+            number_mel_codes=g.get("number_mel_codes", 8194),
+            start_mel_token=g.get("start_mel_token", 8192),
+            stop_mel_token=g.get("stop_mel_token", 8193),
+            start_text_token=g.get("start_text_token", 0),
+            stop_text_token=g.get("stop_text_token", 1),
+            train_solo_embeddings=g.get("train_solo_embeddings", False),
+            condition_type=g.get("condition_type", "conformer_perceiver"),
+            condition_module=g.get("condition_module", {}) or {},
+            emo_condition_module=g.get("emo_condition_module", {}) or {},
+        )
+
+        sc = raw.get("semantic_codec", {}) or {}
+        semantic_codec = SemanticCodecConfig(
+            codebook_size=sc.get("codebook_size", 8192),
+            hidden_size=sc.get("hidden_size", 1024),
+            codebook_dim=sc.get("codebook_dim", 8),
+            vocos_dim=sc.get("vocos_dim", 384),
+            vocos_intermediate_dim=sc.get("vocos_intermediate_dim", 2048),
+            vocos_num_layers=sc.get("vocos_num_layers", 12),
+        )
+
+        s2 = raw.get("s2mel", {}) or {}
+        pre = (s2.get("preprocess_params", {}) or {}).get("spect_params", {}) or {}
+        fmax_raw = pre.get("fmax", None)
+        fmax = None if (fmax_raw is None or fmax_raw == "None") else float(fmax_raw)
+        lr_raw = s2.get("length_regulator", {}) or {}
+        length_reg = S2MelLengthRegConfig(
+            channels=lr_raw.get("channels", 512),
+            is_discrete=lr_raw.get("is_discrete", False),
+            in_channels=lr_raw.get("in_channels", 1024),
+            content_codebook_size=lr_raw.get("content_codebook_size", 2048),
+            sampling_ratios=tuple(lr_raw.get("sampling_ratios", [1, 1, 1, 1])),
+            vector_quantize=lr_raw.get("vector_quantize", False),
+            n_codebooks=lr_raw.get("n_codebooks", 1),
+            quantizer_dropout=lr_raw.get("quantizer_dropout", 0.0),
+            f0_condition=lr_raw.get("f0_condition", False),
+            n_f0_bins=lr_raw.get("n_f0_bins", 512),
+        )
+        dit_raw = s2.get("DiT", {}) or {}
+        dit = S2MelDiTConfig(
+            hidden_dim=dit_raw.get("hidden_dim", 512),
+            num_heads=dit_raw.get("num_heads", 8),
+            depth=dit_raw.get("depth", 13),
+            class_dropout_prob=dit_raw.get("class_dropout_prob", 0.1),
+            block_size=dit_raw.get("block_size", 8192),
+            in_channels=dit_raw.get("in_channels", 80),
+            style_condition=dit_raw.get("style_condition", True),
+            final_layer_type=dit_raw.get("final_layer_type", "wavenet"),
+            target=dit_raw.get("target", "mel"),
+            content_dim=dit_raw.get("content_dim", 512),
+            content_codebook_size=dit_raw.get("content_codebook_size", 1024),
+            content_type=dit_raw.get("content_type", "discrete"),
+            f0_condition=dit_raw.get("f0_condition", False),
+            n_f0_bins=dit_raw.get("n_f0_bins", 512),
+            content_codebooks=dit_raw.get("content_codebooks", 1),
+            is_causal=dit_raw.get("is_causal", False),
+            long_skip_connection=dit_raw.get("long_skip_connection", True),
+            zero_prompt_speech_token=dit_raw.get("zero_prompt_speech_token", False),
+            time_as_token=dit_raw.get("time_as_token", False),
+            style_as_token=dit_raw.get("style_as_token", False),
+            uvit_skip_connection=dit_raw.get("uvit_skip_connection", True),
+            add_resblock_in_transformer=dit_raw.get("add_resblock_in_transformer", False),
+        )
+        wn = s2.get("wavenet", {}) or {}
+        s2mel = S2MelConfig(
+            sr=pre.get("sr", 22050),
+            n_fft=pre.get("n_fft", 1024),
+            win_length=pre.get("win_length", 1024),
+            hop_length=pre.get("hop_length", 256),
+            n_mels=pre.get("n_mels", 80),
+            fmin=pre.get("fmin", 0.0),
+            fmax=fmax,
+            dit_type=s2.get("dit_type", "DiT"),
+            reg_loss_type=s2.get("reg_loss_type", "l1"),
+            style_encoder_dim=(s2.get("style_encoder", {}) or {}).get("dim", 192),
+            length_reg=length_reg,
+            dit=dit,
+            wavenet_hidden_dim=wn.get("hidden_dim", 512),
+            wavenet_num_layers=wn.get("num_layers", 8),
+            wavenet_kernel_size=wn.get("kernel_size", 5),
+            wavenet_dilation_rate=wn.get("dilation_rate", 1),
+            wavenet_p_dropout=wn.get("p_dropout", 0.2),
+            wavenet_style_condition=wn.get("style_condition", True),
+        )
+
+        voc = raw.get("vocoder", {}) or {}
+        return cls(
+            mel=mel,
+            gpt=gpt,
+            semantic_codec=semantic_codec,
+            s2mel=s2mel,
+            vocoder_type=voc.get("type", "bigvgan"),
+            vocoder_name=voc.get("name", "bigvgan_generator.pt"),
+            version=raw.get("version", "2.5"),
+            _raw=raw,
+        )
+
+
+DEFAULT_CONFIG_PATH = os.environ.get("WINDEXTTS_WEIGHTS_DIR", "/root/IndexTTS-2.5") + "/config.yaml"
+
+
+def load_default_config() -> Config:
+    """Load config from the canonical IndexTTS-2.5 weights dir."""
+    return Config.from_yaml(DEFAULT_CONFIG_PATH)