polywhisper 0.2.0__py3-none-any.whl

polywhisper/__init__.py

@@ -0,0 +1,7 @@
+"""PolyWhisper — efficient multilingual Indic ASR via frozen Whisper + per-language LoRA."""
+
+__version__ = "0.2.0"
+
+from polywhisper.transcribe import transcribe, TranscriptionResult
+
+__all__ = ["transcribe", "TranscriptionResult"]

polywhisper/__main__.py

@@ -0,0 +1,3 @@
+"""Allow `python -m polywhisper` to work."""
+from polywhisper.cli import main
+main()

polywhisper/audio.py

@@ -0,0 +1,65 @@
+"""Audio loading, format conversion, and chunking utilities."""
+
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+
+TARGET_SR = 16000
+MAX_DURATION_SEC = 30.0
+CHUNK_OVERLAP_SEC = 3.0
+
+
+def load_audio(path, target_sr=TARGET_SR):
+    """Load audio file, return (samples: np.ndarray[float32], sr: int).
+
+    Supports wav, flac, mp3, ogg, m4a via soundfile/libsndfile.
+    For formats not supported by soundfile, falls back to ffmpeg.
+    """
+    path = str(path)
+    try:
+        audio, sr = sf.read(path, dtype="float32")
+    except Exception:
+        # ffmpeg fallback for mp3/ogg/m4a
+        import subprocess, io, tempfile
+        with tempfile.NamedTemporaryFile(suffix=".wav") as tmp:
+            subprocess.run(
+                ["ffmpeg", "-i", path, "-ar", str(target_sr), "-ac", "1",
+                 "-f", "wav", "-y", tmp.name],
+                capture_output=True, check=True,
+            )
+            audio, sr = sf.read(tmp.name, dtype="float32")
+    if audio.ndim > 1:
+        audio = audio.mean(axis=1)  # stereo → mono
+    if sr != target_sr:
+        import resampy
+        audio = resampy.resample(audio, sr, target_sr)
+        sr = target_sr
+    return audio, sr
+
+
+def chunk_audio(audio, chunk_sec=MAX_DURATION_SEC, overlap_sec=CHUNK_OVERLAP_SEC, sr=TARGET_SR):
+    """Split long audio into overlapping chunks. Returns list of (start_sample, end_sample)."""
+    chunk_samples = int(chunk_sec * sr)
+    overlap_samples = int(overlap_sec * sr)
+    n = len(audio)
+    if n <= chunk_samples:
+        return [(0, n)]
+    chunks = []
+    start = 0
+    while start < n:
+        end = min(start + chunk_samples, n)
+        chunks.append((start, end))
+        if end == n:
+            break
+        start += chunk_samples - overlap_samples
+    return chunks
+
+
+def audio_to_chunks(audio_or_path, chunk_sec=MAX_DURATION_SEC, overlap_sec=CHUNK_OVERLAP_SEC, sr=TARGET_SR):
+    """Load audio (if path) and return list of (chunk_np, start_sec, end_sec)."""
+    if isinstance(audio_or_path, (str, Path)):
+        audio, _ = load_audio(audio_or_path, sr)
+    else:
+        audio = np.asarray(audio_or_path, dtype="float32")
+    spans = chunk_audio(audio, chunk_sec, overlap_sec, sr)
+    return [(audio[s:e], s / sr, e / sr) for s, e in spans]

polywhisper/cli.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""PolyWhisper CLI — transcribe audio files from the command line.
+
+Usage:
+    polywhisper transcribe audio.wav --lang hi
+    polywhisper transcribe audio.wav               # auto-detect language
+    polywhisper batch ./audio_folder/ --lang te --output results.json
+    polywhisper languages
+"""
+
+import os
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+
+def cmd_transcribe(args):
+    from polywhisper import transcribe
+    from polywhisper.model import PolyWhisper
+    import sys, io, os, warnings
+
+    # Suppress everything
+    warnings.filterwarnings("ignore")
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    sys.stderr = io.StringIO()
+    sys.stdout = io.StringIO()
+    os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    model = PolyWhisper(backbone=args.backbone, device=args.device)
+
+    t0 = time.time()
+    result = transcribe(
+        args.audio,
+        lang=args.lang,
+        backbone=args.backbone,
+        variant=args.variant,
+        device=args.device,
+        max_new_tokens=args.max_tokens,
+        num_beams=args.beams,
+        model=model,
+        backend=args.backend,
+    )
+    dt = time.time() - t0
+
+    sys.stderr = old_stderr
+    sys.stdout = old_stdout
+
+    if args.format == "text":
+        print(result.text)
+    elif args.format == "json":
+        out = result.to_dict()
+        out["duration_sec"] = result.duration_sec
+        out["process_time_sec"] = round(dt, 2)
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+    elif args.format == "srt":
+        for i, seg in enumerate(result.segments, 1):
+            start = _fmt_srt(seg.start_sec)
+            end = _fmt_srt(seg.end_sec)
+            print(f"{i}\n{start} --> {end}\n{seg.text}\n")
+
+    print(f"[{dt:.1f}s, {result.lang}, {len(result.segments)} segments]", file=old_stderr)
+
+
+def cmd_batch(args):
+    from polywhisper import transcribe
+    from polywhisper.model import PolyWhisper
+    import sys as _sys, io as _io, os as _os
+
+    _os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
+    _os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    audio_dir = Path(args.audio_dir)
+    exts = {".wav", ".flac", ".mp3", ".ogg", ".m4a", ".webm"}
+    files = sorted(f for f in audio_dir.iterdir() if f.suffix.lower() in exts)
+    if not files:
+        print(f"No audio files found in {audio_dir}")
+        return
+
+    old_stderr = _sys.stderr
+    _sys.stderr = _io.StringIO()
+    print(f"Loading model (backbone={args.backbone})...", file=old_stderr)
+    model = PolyWhisper(backbone=args.backbone, device=args.device)
+
+    results = []
+    total_t0 = time.time()
+    for i, f in enumerate(files, 1):
+        t0 = time.time()
+        result = transcribe(
+            f, lang=args.lang, backbone=args.backbone, variant=args.variant,
+            device=args.device, max_new_tokens=args.max_tokens, num_beams=args.beams,
+            model=model,
+        )
+        dt = time.time() - t0
+        entry = result.to_dict()
+        entry["file"] = str(f)
+        entry["process_time_sec"] = round(dt, 2)
+        results.append(entry)
+        print(f"  [{i}/{len(files)}] {f.name} → {result.lang} ({dt:.1f}s)", file=old_stderr)
+
+    total_dt = time.time() - total_t0
+    out = {"results": results, "total_files": len(results), "total_time_sec": round(total_dt, 2)}
+
+    _sys.stderr = old_stderr
+    if args.output:
+        Path(args.output).write_text(json.dumps(out, ensure_ascii=False, indent=2))
+        print(f"Wrote {args.output} ({len(results)} files)", file=old_stderr)
+    else:
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+
+
+def cmd_languages(args):
+    from polywhisper.model import AVAILABLE_LANGS, ADAPTER_REGISTRY, _adapter_search_paths
+    from pathlib import Path
+
+    search = _adapter_search_paths()
+    print("Available languages:")
+    for lang in AVAILABLE_LANGS:
+        reg = ADAPTER_REGISTRY[lang]
+        if isinstance(reg, dict):
+            variants = list(reg.keys())
+        else:
+            variants = ["base"]
+        found = []
+        for variant in variants:
+            fname = reg[variant] if isinstance(reg, dict) else reg
+            for d in search:
+                if (d / fname).exists():
+                    found.append(f"{variant} ({fname})")
+                    break
+        status = ", ".join(found) if found else "NOT FOUND locally"
+        print(f"  {lang:4s}  adapters: {status}")
+    print(f"\nSearch paths: {[str(p) for p in search]}")
+
+
+def _fmt_srt(sec):
+    h = int(sec // 3600)
+    m = int((sec % 3600) // 60)
+    s = int(sec % 60)
+    ms = int((sec - int(sec)) * 1000)
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+
+
+def cmd_export(args):
+    from polywhisper.onnx_backend import export_language
+    from polywhisper.model import ADAPTER_REGISTRY, _adapter_search_paths
+
+    # Resolve adapter path
+    reg = ADAPTER_REGISTRY.get(args.lang)
+    if reg is None:
+        print(f"Unknown language: {args.lang}. Available: {list(ADAPTER_REGISTRY.keys())}")
+        return
+    fname = reg.get(args.variant, reg.get("prod", list(reg.values())[0])) if isinstance(reg, dict) else reg
+    adapter_path = None
+    for d in _adapter_search_paths():
+        p = d / fname
+        if p.exists():
+            adapter_path = p
+            break
+    if adapter_path is None:
+        print(f"Adapter not found: {fname}")
+        return
+
+    print(f"Exporting {args.lang} ({args.variant}) to ONNX...")
+    enc_path, dec_path = export_language(
+        args.lang, str(adapter_path), backbone=args.backbone,
+        out_dir=args.out_dir, int8=args.int8,
+    )
+    print(f"Done. Encoder: {enc_path}\nDecoder: {dec_path}")
+
+
+def main():
+    p = argparse.ArgumentParser(
+        prog="polywhisper",
+        description="PolyWhisper — efficient multilingual Indic ASR",
+    )
+    sub = p.add_subparsers(dest="command", required=True)
+
+    # transcribe
+    t = sub.add_parser("transcribe", help="Transcribe a single audio file")
+    t.add_argument("audio", help="Path to audio file")
+    t.add_argument("--lang", "-l", default=None, help="Language code (hi/ta/te/bn/mr)")
+    t.add_argument("--backbone", "-b", default="small", help="Whisper backbone (default: small)")
+    t.add_argument("--variant", "-v", default="prod", help="Adapter variant (prod/base)")
+    t.add_argument("--device", "-d", default="auto", help="Device (auto/cuda/mps/cpu)")
+    t.add_argument("--max-tokens", type=int, default=256, help="Max tokens to generate")
+    t.add_argument("--beams", type=int, default=1, help="Beam width")
+    t.add_argument("--format", "-f", default="text", choices=["text", "json", "srt"],
+                    help="Output format")
+    t.add_argument("--backend", default="auto", choices=["auto", "torch", "onnx"],
+                    help="Inference backend (auto: ONNX if available, else torch)")
+    t.set_defaults(func=cmd_transcribe)
+
+    # batch
+    b = sub.add_parser("batch", help="Transcribe all audio files in a directory")
+    b.add_argument("audio_dir", help="Directory containing audio files")
+    b.add_argument("--lang", "-l", default=None, help="Language code")
+    b.add_argument("--backbone", "-b", default="small")
+    b.add_argument("--variant", "-v", default="prod")
+    b.add_argument("--device", "-d", default="auto")
+    b.add_argument("--max-tokens", type=int, default=256)
+    b.add_argument("--beams", type=int, default=1)
+    b.add_argument("--output", "-o", default=None, help="Output JSON file")
+    b.set_defaults(func=cmd_batch)
+
+    # export
+    e = sub.add_parser("export", help="Export language to ONNX (CPU inference)")
+    e.add_argument("--lang", "-l", required=True, help="Language to export")
+    e.add_argument("--variant", "-v", default="prod", help="Adapter variant")
+    e.add_argument("--backbone", "-b", default="small")
+    e.add_argument("--out-dir", "-o", default="export/onnx", help="Output directory")
+    e.add_argument("--int8", action="store_true", help="Also quantize to int8")
+    e.set_defaults(func=cmd_export)
+
+    # languages
+    sub.add_parser("languages", help="List available languages and adapters").set_defaults(func=cmd_languages)
+
+    args = p.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

polywhisper/model.py

@@ -0,0 +1,241 @@
+"""PolyWhisper model — frozen Whisper backbone + per-language LoRA adapters."""
+
+import os
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import sys
+import io
+import torch
+import torch.nn as nn
+import logging
+import warnings
+warnings.filterwarnings("ignore", message=".*past_key_values.*")
+warnings.filterwarnings("ignore", message=".*attention mask.*")
+warnings.filterwarnings("ignore", message=".*forced_decoder_ids.*")
+logging.getLogger("transformers").setLevel(logging.ERROR)
+
+from pathlib import Path
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
+
+WHISPER_SMALL = "openai/whisper-small"
+RANK = 16
+LANG_TOKENS = {
+    "en": 50259, "hi": 50276, "ta": 50287,
+    "te": 50299, "bn": 50302, "mr": 50320,
+}
+BOS_EOS = 50257
+
+ADAPTER_REGISTRY = {
+    "hi": {"base": "hi_best_v5.pt", "prod": "hi_best_prod.pt"},
+    "ta": {"base": "ta_best_ta.pt", "prod": "ta_best_prod.pt"},
+    "te": {"base": "te_best_te.pt", "prod": "te_best_prod.pt"},
+    "bn": {"base": "bn_best_bn.pt", "prod": "bn_best_prod.pt"},
+    "mr": {"base": "mr_best_mr.pt", "prod": "mr_best_prod.pt"},
+}
+
+AVAILABLE_LANGS = list(ADAPTER_REGISTRY.keys())
+
+
+def _get_processor(backbone="small"):
+    """Get WhisperProcessor for the given backbone."""
+    from transformers import WhisperProcessor
+    return WhisperProcessor.from_pretrained(f"openai/whisper-{backbone}")
+
+
+def _adapter_search_paths():
+    """Return candidate directories containing adapters_v3/."""
+    candidates = [
+        Path(__file__).parent.parent / "polywhisper_output" / "adapters_v3",
+        Path.home() / "polywhisper_output" / "adapters_v3",
+        Path("/Volumes/KIOXIA 1TB/polywhisper_output/adapters_v3"),
+    ]
+    return [p for p in candidates if p.exists()]
+
+
+class PolyWhisper(nn.Module):
+    """Whisper backbone with frozen weights and per-language LoRA adapters.
+
+    Usage:
+        model = PolyWhisper(backbone="small", device="auto")
+        model.load_adapter("hi", "path/to/hi_best_prod.pt")
+        model.set_language("hi")
+        tokens = model.generate(features, max_new_tokens=256)
+    """
+
+    PROJ_MAP = [
+        ("self_attn", "self_q"), ("self_attn", "self_k"), ("self_attn", "self_v"),
+        ("encoder_attn", "cross_q"), ("encoder_attn", "cross_k"), ("encoder_attn", "cross_v"),
+        ("self_attn", "self_out"), ("encoder_attn", "cross_out"),
+    ]
+    ENC_PROJ_MAP = [
+        ("self_attn", "enc_q"), ("self_attn", "enc_k"), ("self_attn", "enc_v"),
+        ("self_attn", "enc_out"),
+    ]
+
+    def __init__(self, backbone="small", rank=RANK, device="auto"):
+        super().__init__()
+        if device == "auto":
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif torch.backends.mps.is_available():
+                device = "mps"
+            else:
+                device = "cpu"
+        self.device = torch.device(device)
+        self.rank = rank
+        self._current_lang = None
+        self._hooks = []
+
+        whisper_name = f"openai/whisper-{backbone}"
+        import warnings as _warn
+        _warn.filterwarnings("ignore")
+        old_stdout, old_stderr = sys.stdout, sys.stderr
+        sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
+        try:
+            self.whisper = WhisperForConditionalGeneration.from_pretrained(whisper_name)
+        finally:
+            sys.stdout, sys.stderr = old_stdout, old_stderr
+        for p in self.whisper.parameters():
+            p.requires_grad = False
+        self.whisper.to(self.device)
+
+        self.d_model = self.whisper.config.d_model
+        self.decoder_layers = self.whisper.config.decoder_layers
+        self.encoder_layers = self.whisper.config.encoder_layers
+        self.lora_adapters = nn.ModuleDict()
+        old_stdout, old_stderr = sys.stdout, sys.stderr
+        sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
+        try:
+            self.processor = WhisperProcessor.from_pretrained(whisper_name)
+        finally:
+            sys.stdout, sys.stderr = old_stdout, old_stderr
+
+    def add_language(self, lang):
+        d, r = self.d_model, self.rank
+        dev = self.device
+        adpt = nn.ModuleDict()
+        for i in range(self.decoder_layers):
+            for _, base_name in self.PROJ_MAP:
+                adpt[f"d{i}_{base_name}_a"] = nn.Linear(d, r, bias=False).to(dev)
+                adpt[f"d{i}_{base_name}_b"] = nn.Linear(r, d, bias=False).to(dev)
+                nn.init.zeros_(adpt[f"d{i}_{base_name}_b"].weight)
+        if lang not in self.lora_adapters or not any(
+            k.startswith("e0_") for k in self.lora_adapters.get(lang, {}).keys()
+        ):
+            pass  # decoder-only by default; encoder LoRA loaded from checkpoint
+        self.lora_adapters[lang] = adpt
+        return adpt
+
+    @staticmethod
+    def _proj_name(base_name):
+        if "out" in base_name:
+            return "out_proj"
+        if "q" in base_name:
+            return "q_proj"
+        if "k" in base_name:
+            return "k_proj"
+        return "v_proj"
+
+    def set_language(self, lang):
+        if self._current_lang == lang:
+            return
+        self._remove_hooks()
+        if lang not in self.lora_adapters:
+            self.add_language(lang)
+        lora = self.lora_adapters[lang]
+        self._hooks = []
+        for i, layer in enumerate(self.whisper.model.decoder.layers):
+            for attn_name, base_name in self.PROJ_MAP:
+                a = lora[f"d{i}_{base_name}_a"]
+                b = lora[f"d{i}_{base_name}_b"]
+
+                def make_hook(a, b):
+                    def hook(mod, inp, out):
+                        return out + b(a(inp[0]))
+                    return hook
+
+                proj = getattr(getattr(layer, attn_name), self._proj_name(base_name))
+                self._hooks.append(proj.register_forward_hook(make_hook(a, b)))
+        # encoder LoRA hooks (only if adapter has encoder keys)
+        if any(k.startswith("e0_") for k in lora.keys()):
+            for i, layer in enumerate(self.whisper.model.encoder.layers):
+                for attn_name, base_name in self.ENC_PROJ_MAP:
+                    a = lora[f"e{i}_{base_name}_a"]
+                    b = lora[f"e{i}_{base_name}_b"]
+                    proj = getattr(getattr(layer, attn_name), self._proj_name(base_name))
+                    self._hooks.append(proj.register_forward_hook(make_hook(a, b)))
+        self._current_lang = lang
+
+    def _remove_hooks(self):
+        for h in self._hooks:
+            h.remove()
+        self._hooks = []
+
+    def load_adapter(self, lang, path):
+        path = str(path)
+        st = torch.load(path, map_location="cpu", weights_only=True)
+        d, r = self.d_model, self.rank
+        dev = self.device
+        if lang not in self.lora_adapters:
+            self.lora_adapters[lang] = nn.ModuleDict()
+        adpt = self.lora_adapters[lang]
+        # create decoder layers if present in checkpoint
+        dec_keys = [k for k in st if k.startswith("d0_")]
+        if dec_keys:
+            for i in range(self.decoder_layers):
+                for _, base_name in self.PROJ_MAP:
+                    a_key = f"d{i}_{base_name}_a"
+                    b_key = f"d{i}_{base_name}_b"
+                    if a_key not in adpt:
+                        adpt[a_key] = nn.Linear(d, r, bias=False).to(dev)
+                        adpt[b_key] = nn.Linear(r, d, bias=False).to(dev)
+        # create encoder LoRA layers if present in checkpoint
+        enc_keys = [k for k in st if k.startswith("e0_")]
+        if enc_keys:
+            for i in range(self.encoder_layers):
+                for _, base_name in self.ENC_PROJ_MAP:
+                    a_key = f"e{i}_{base_name}_a"
+                    b_key = f"e{i}_{base_name}_b"
+                    if a_key not in adpt:
+                        adpt[a_key] = nn.Linear(d, r, bias=False).to(dev)
+                        adpt[b_key] = nn.Linear(r, d, bias=False).to(dev)
+        adpt.load_state_dict(st)
+
+    def auto_load_adapter(self, lang, variant="prod"):
+        """Load adapter by language name, searching standard paths."""
+        reg = ADAPTER_REGISTRY.get(lang)
+        if reg is None:
+            raise ValueError(f"Unknown language: {lang}. Available: {AVAILABLE_LANGS}")
+        if isinstance(reg, dict):
+            fname = reg.get(variant, reg.get("prod", list(reg.values())[0]))
+        else:
+            fname = reg
+        for search_dir in _adapter_search_paths():
+            path = search_dir / fname
+            if path.exists():
+                self.load_adapter(lang, path)
+                return str(path)
+        raise FileNotFoundError(
+            f"Adapter {fname} not found. Searched: {[str(p) for p in _adapter_search_paths()]}"
+        )
+
+    def forward(self, feat, dec_ids, lang):
+        self.set_language(lang)
+        if (dec_ids == -100).any():
+            dec_ids = torch.where(dec_ids == -100, torch.tensor(BOS_EOS, device=dec_ids.device), dec_ids)
+        enc = self.whisper.model.encoder(feat).last_hidden_state
+        dec_out = self.whisper.model.decoder(dec_ids, encoder_hidden_states=enc)
+        return self.whisper.proj_out(dec_out.last_hidden_state)
+
+    @torch.no_grad()
+    def generate(self, feat, lang, **kwargs):
+        self.set_language(lang)
+        old_stderr = sys.stderr
+        sys.stderr = io.StringIO()
+        result = self.whisper.generate(feat, **kwargs)
+        sys.stderr = old_stderr
+        return result
+
+    def save_adapter(self, lang, path):
+        torch.save(self.lora_adapters[lang].state_dict(), path)

polywhisper/onnx_backend.py

@@ -0,0 +1,215 @@
+"""ONNX Runtime inference backend — no torch required at inference time.
+
+Exports per-language ONNX models (encoder+decoder with LoRA baked in),
+then runs autoregressive decoding via onnxruntime.
+"""
+
+import os
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from typing import Optional
+
+try:
+    import onnxruntime as ort
+except ImportError:
+    ort = None
+
+from polywhisper.audio import load_audio, TARGET_SR
+
+START_TOKEN = 50257
+LANG_TOKENS = {
+    "en": 50259, "hi": 50276, "ta": 50287,
+    "te": 50299, "bn": 50302, "mr": 50320,
+}
+TASK_TOKEN = 50359
+NO_TIME_TOKEN = 50363
+
+
+def _export_dir():
+    candidates = [
+        Path(__file__).parent.parent / "export" / "onnx",
+        Path.home() / "polywhisper_output" / "export" / "onnx",
+        Path("/Volumes/KIOXIA 1TB/polywhisper_output/export/onnx"),
+    ]
+    return next((p for p in candidates if p.exists()), candidates[0])
+
+
+class OnnxBackend:
+    """ONNX Runtime inference for PolyWhisper (no torch needed)."""
+
+    def __init__(self, export_dir: Optional[Path] = None, lang: str = "hi",
+                 int8: bool = False, device: str = "cpu"):
+        if ort is None:
+            raise ImportError("onnxruntime is required: pip install onnxruntime")
+        self.export_dir = Path(export_dir) if export_dir else _export_dir()
+        self.lang = lang
+        self.int8 = int8
+
+        suffix = "_int8" if int8 else ""
+        enc_path = self.export_dir / f"{lang}_encoder{suffix}.onnx"
+        dec_path = self.export_dir / f"{lang}_decoder{suffix}.onnx"
+
+        if not enc_path.exists() or not dec_path.exists():
+            raise FileNotFoundError(
+                f"ONNX models not found for '{lang}'. "
+                f"Expected: {enc_path.name}, {dec_path.name}\n"
+                f"Run: python export_onnx.py --lang {lang} --adapter {lang}_best_prod.pt "
+                f"--adapter-dir polywhisper_output/adapters_v3 --int8"
+            )
+
+        opts = ort.SessionOptions()
+        opts.inter_op_num_threads = 4
+        opts.intra_op_num_threads = 4
+        providers = ["CPUExecutionProvider"]
+
+        self.enc_session = ort.InferenceSession(str(enc_path), opts, providers=providers)
+        self.dec_session = ort.InferenceSession(str(dec_path), opts, providers=providers)
+
+    @staticmethod
+    def _mel(audio, processor):
+        """Compute mel features from audio array."""
+        import torch
+        feats = processor.feature_extractor(
+            [audio], sampling_rate=TARGET_SR, return_tensors="pt", padding=True
+        )["input_features"]
+        if feats.shape[-1] < 3000:
+            feats = torch.cat(
+                [feats, torch.zeros(1, 80, 3000 - feats.shape[-1], dtype=feats.dtype)], -1
+            )
+        return feats.numpy()
+
+    def transcribe(self, audio_input, processor, max_new_tokens=256,
+                   num_beams=1, language=None) -> str:
+        """Transcribe audio via ONNX Runtime (greedy only for now)."""
+        lang = language or self.lang
+
+        # Load audio
+        if isinstance(audio_input, (str, Path)):
+            audio, _ = load_audio(str(audio_input), TARGET_SR)
+        else:
+            audio = np.asarray(audio_input, dtype=np.float32)
+
+        # Compute features
+        feats = self._mel(audio, processor)
+
+        # Encode
+        enc_hidden = self.enc_session.run(None, {"feats": feats})[0]
+
+        # Decode (greedy autoregressive)
+        lang_token = LANG_TOKENS.get(lang, LANG_TOKENS["hi"])
+        ids = np.array([[START_TOKEN, lang_token, TASK_TOKEN, NO_TIME_TOKEN]], dtype=np.int64)
+
+        for _ in range(max_new_tokens):
+            logits = self.dec_session.run(None, {
+                "input_ids": ids,
+                "enc_hidden": enc_hidden,
+            })[0]
+            next_token = int(np.argmax(logits[0, -1]))
+            ids = np.concatenate([ids, [[next_token]]], axis=1)
+            if next_token == START_TOKEN:
+                break
+
+        return processor.decode(ids[0], skip_special_tokens=True).strip()
+
+
+def export_language(lang, adapter_path, backbone="small", out_dir=None, int8=True):
+    """Export a single language to ONNX with LoRA baked in."""
+    import torch
+    import torch.nn as nn
+    from transformers import WhisperForConditionalGeneration, WhisperProcessor
+
+    if ort is None:
+        raise ImportError("onnxruntime required for export")
+
+    out_dir = Path(out_dir) if out_dir else _export_dir()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    whisper_name = f"openai/whisper-{backbone}"
+    processor = WhisperProcessor.from_pretrained(whisper_name)
+
+    # Load model with LoRA
+    from polywhisper.model import PolyWhisper
+    model = PolyWhisper(backbone=backbone, device="cpu")
+    model.load_adapter(lang, adapter_path)
+    model.set_language(lang)
+
+    # Freeze everything for export
+    model.eval()
+    for p in model.parameters():
+        p.requires_grad = False
+    for p in model.lora_adapters[lang].parameters():
+        p.requires_grad = False
+
+    # Wrapper classes matching export_onnx.py
+    class EncoderWrapper(nn.Module):
+        def __init__(self, whisper):
+            super().__init__()
+            self.w = whisper
+        def forward(self, feats):
+            return self.w.model.encoder(feats).last_hidden_state
+
+    class DecoderWrapper(nn.Module):
+        def __init__(self, whisper):
+            super().__init__()
+            self.w = whisper
+        def forward(self, input_ids, enc_hidden):
+            out = self.w.model.decoder(input_ids, encoder_hidden_states=enc_hidden).last_hidden_state
+            return self.w.proj_out(out)
+
+    feats = torch.randn(1, 80, 3000)
+    ids = torch.randint(0, 100, (1, 10))
+    d = model.d_model
+    enc_hidden = torch.randn(1, 1500, d)
+
+    # Export encoder
+    enc_w = EncoderWrapper(model.whisper)
+    enc_path = out_dir / f"{lang}_encoder.onnx"
+    torch.onnx.export(
+        enc_w, (feats,), str(enc_path),
+        input_names=["feats"], output_names=["enc_hidden"],
+        dynamic_axes={"feats": {0: "batch", 2: "time"}, "enc_hidden": {0: "batch", 1: "enc_seq"}},
+        opset_version=17, do_constant_folding=True, dynamo=False,
+    )
+    print(f"  encoder: {enc_path}")
+
+    # Export decoder
+    dec_w = DecoderWrapper(model.whisper)
+    dec_path = out_dir / f"{lang}_decoder.onnx"
+    torch.onnx.export(
+        dec_w, (ids, enc_hidden), str(dec_path),
+        input_names=["input_ids", "enc_hidden"], output_names=["logits"],
+        dynamic_axes={
+            "input_ids": {0: "batch", 1: "seq"},
+            "enc_hidden": {0: "batch", 1: "enc_seq"},
+            "logits": {0: "batch", 1: "seq"},
+        },
+        opset_version=17, do_constant_folding=True, dynamo=False,
+    )
+    print(f"  decoder: {dec_path}")
+
+    # Int8 quantization
+    if int8:
+        from onnxruntime.quantization import quantize_dynamic, QuantType
+        for part in ("encoder", "decoder"):
+            src = out_dir / f"{lang}_{part}.onnx"
+            dst = out_dir / f"{lang}_{part}_int8.onnx"
+            quantize_dynamic(str(src), str(dst), weight_type=QuantType.QInt8)
+            print(f"  int8: {dst}")
+
+    # Parity check
+    s_enc = ort.InferenceSession(str(enc_path), providers=["CPUExecutionProvider"])
+    s_dec = ort.InferenceSession(str(dec_path), providers=["CPUExecutionProvider"])
+    with torch.no_grad():
+        e_t = enc_w(feats).numpy()
+        d_t = dec_w(ids, enc_hidden).numpy()
+    e_o = s_enc.run(None, {"feats": feats.numpy()})[0]
+    d_o = s_dec.run(None, {"input_ids": ids.numpy(), "enc_hidden": enc_hidden.numpy()})[0]
+    enc_diff = float(np.abs(e_t - e_o).max())
+    dec_diff = float(np.abs(d_t - d_o).max())
+    print(f"  parity: enc={enc_diff:.2e} dec={dec_diff:.2e} {'OK' if enc_diff < 1e-3 and dec_diff < 1e-3 else 'FAIL'}")
+
+    return enc_path, dec_path

polywhisper/transcribe.py

@@ -0,0 +1,205 @@
+"""High-level transcription API."""
+
+import os
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import torch
+import numpy as np
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, List, Union
+
+from polywhisper.model import PolyWhisper, AVAILABLE_LANGS
+from polywhisper.audio import load_audio, audio_to_chunks, TARGET_SR
+
+
+@dataclass
+class Segment:
+    """A single transcription segment."""
+    text: str
+    start_sec: float
+    end_sec: float
+    tokens: List[int] = field(default_factory=list)
+
+
+@dataclass
+class TranscriptionResult:
+    """Full transcription result."""
+    text: str
+    lang: str
+    segments: List[Segment] = field(default_factory=list)
+    language_probs: dict = field(default_factory=dict)
+
+    @property
+    def duration_sec(self):
+        if not self.segments:
+            return 0.0
+        return self.segments[-1].end_sec
+
+    def to_dict(self):
+        return {
+            "text": self.text,
+            "lang": self.lang,
+            "segments": [
+                {"text": s.text, "start": s.start_sec, "end": s.end_sec}
+                for s in self.segments
+            ],
+        }
+
+
+def _get_model(backbone="small", device="auto", model=None):
+    """Return a PolyWhisper instance, reusing if already loaded."""
+    if model is not None:
+        return model
+    return PolyWhisper(backbone=backbone, device=device)
+
+
+def _prepare_features(model, audio):
+    """Convert audio array to model input features."""
+    feats = model.processor.feature_extractor(
+        [audio], sampling_rate=TARGET_SR, return_tensors="pt", padding=True
+    )["input_features"]
+    if feats.shape[-1] < 3000:
+        feats = torch.cat(
+            [feats, torch.zeros(1, 80, 3000 - feats.shape[-1], dtype=feats.dtype)], -1
+        )
+    return feats.to(model.device)
+
+
+def _decode_tokens(model, tokens):
+    """Decode token IDs to text."""
+    return model.processor.decode(tokens, skip_special_tokens=True).strip()
+
+
+def transcribe(
+    audio_input: Union[str, Path, np.ndarray],
+    lang: Optional[str] = None,
+    backbone: str = "small",
+    variant: str = "prod",
+    device: str = "auto",
+    max_new_tokens: int = 256,
+    num_beams: int = 1,
+    chunk_sec: float = 30.0,
+    model: Optional[PolyWhisper] = None,
+    language_probs: bool = False,
+    backend: str = "auto",
+) -> TranscriptionResult:
+    """Transcribe audio file or numpy array.
+
+    Args:
+        audio_input: file path (str/Path) or numpy float32 array at 16kHz.
+        lang: language code ("hi", "ta", "te", "bn", "mr"). If None, auto-detect.
+        backbone: whisper backbone ("small" recommended).
+        variant: adapter variant ("prod" or "base").
+        device: "auto", "cuda", "mps", or "cpu".
+        max_new_tokens: max generation length.
+        num_beams: beam width (1 = greedy).
+        chunk_sec: chunk long audio into this many seconds.
+        model: pre-loaded PolyWhisper instance (avoids re-loading).
+        language_probs: if lang is None, return probs for all languages.
+        backend: "auto" (ONNX if available, else torch), "torch", or "onnx".
+
+    Returns:
+        TranscriptionResult with text, segments, and metadata.
+    """
+    # Load audio
+    if isinstance(audio_input, (str, Path)):
+        audio, sr = load_audio(audio_input, TARGET_SR)
+        source = str(audio_input)
+    else:
+        audio = np.asarray(audio_input, dtype=np.float32)
+        source = "<array>"
+
+    # Try ONNX backend first (no torch needed, faster on CPU)
+    use_onnx = backend in ("onnx", "auto") and device in ("auto", "cpu")
+    if use_onnx:
+        try:
+            from polywhisper.onnx_backend import OnnxBackend
+            from polywhisper.model import _get_processor
+            processor = _get_processor(backbone)
+            onnx = OnnxBackend(lang=lang or "hi")
+            text = onnx.transcribe(audio_input, processor, max_new_tokens=max_new_tokens,
+                                   num_beams=num_beams, language=lang)
+            segments = [Segment(text=text, start_sec=0.0, end_sec=len(audio) / TARGET_SR)]
+            return TranscriptionResult(text=text, lang=lang or "hi", segments=segments)
+        except (FileNotFoundError, ImportError):
+            pass  # fall through to torch backend
+
+    m = _get_model(backbone, device, model)
+
+    # Auto-detect language
+    if lang is None:
+        lang, probs = _detect_language(m, audio, max_new_tokens=max_new_tokens)
+        if language_probs:
+            probs_str = ", ".join(f"{k}:{v:.1%}" for k, v in sorted(probs.items(), key=lambda x: -x[1]))
+            print(f"Detected: {lang} ({probs_str})")
+    else:
+        probs = {}
+
+    # Load adapter
+    m.auto_load_adapter(lang, variant=variant)
+
+    # Chunk and transcribe
+    chunks = audio_to_chunks(audio, chunk_sec=chunk_sec)
+    segments = []
+    all_text = []
+
+    for chunk_audio, start_sec, end_sec in chunks:
+        feats = _prepare_features(m, chunk_audio)
+        out = m.generate(
+            feats, lang=lang, max_new_tokens=max_new_tokens,
+            num_beams=num_beams, use_cache=True, task="transcribe",
+        )
+        text = _decode_tokens(m, out[0])
+        if text:
+            segments.append(Segment(text=text, start_sec=start_sec, end_sec=end_sec))
+            all_text.append(text)
+
+    full_text = " ".join(all_text)
+    return TranscriptionResult(
+        text=full_text, lang=lang, segments=segments, language_probs=probs,
+    )
+
+
+def _detect_language(model, audio, max_new_tokens=128):
+    """Run all adapters, pick the one with highest confidence."""
+    from polywhisper.model import ADAPTER_REGISTRY
+    from polywhisper.audio import TARGET_SR
+    import torch.nn.functional as F
+
+    feats = _prepare_features(model, audio)
+    scores = {}
+
+    for lang in ADAPTER_REGISTRY:
+        try:
+            model.auto_load_adapter(lang, variant="prod")
+        except FileNotFoundError:
+            try:
+                model.auto_load_adapter(lang, variant="base")
+            except FileNotFoundError:
+                continue
+
+        model.set_language(lang)
+        with torch.no_grad():
+            # Get decoder logits for the first few tokens
+            enc = model.whisper.model.encoder(feats).last_hidden_state
+            # Start with BOS + lang token
+            lang_token = model.processor.tokenizer.convert_tokens_to_ids(f"<|{lang}|>")
+            if lang_token is None:
+                continue
+            dec_input = torch.tensor([[50257, lang_token, 50359]], device=model.device)
+            logits = model.whisper.model.decoder(dec_input, encoder_hidden_states=enc).last_hidden_state
+            # Score: average log-prob of next-token predictions
+            logprobs = F.log_softmax(logits[0, -1], dim=-1)
+            top_k = logprobs.topk(5)
+            scores[lang] = top_k.values.mean().item()
+
+    if not scores:
+        return "hi", {}
+
+    # Normalize to probabilities
+    total = sum(np.exp(v) for v in scores.values())
+    probs = {k: np.exp(v) / total for k, v in sorted(scores.items(), key=lambda x: -x[1])}
+    best = max(scores, key=scores.get)
+    return best, probs

polywhisper-0.2.0.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.5
+Name: polywhisper
+Version: 0.2.0
+Summary: Efficient multilingual Indic ASR via frozen Whisper + per-language LoRA
+Project-URL: Homepage, https://github.com/eulogik/PolyWhisper
+Project-URL: Documentation, https://github.com/eulogik/PolyWhisper#readme
+Project-URL: Repository, https://github.com/eulogik/PolyWhisper
+Project-URL: Issues, https://github.com/eulogik/PolyWhisper/issues
+Author: Eulogik
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asr,bengali,hindi,indic,lora,marathi,multilingual,onnx,speech-recognition,tamil,telugu,whisper
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: resampy
+Requires-Dist: soundfile
+Requires-Dist: torch>=2.0
+Requires-Dist: transformers>=4.30
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.15; extra == 'onnx'
+Requires-Dist: onnxruntime>=1.16; extra == 'onnx'
+Description-Content-Type: text/markdown
+
+---
+language:
+  - hi
+  - ta
+  - te
+  - bn
+  - mr
+license: mit
+library_name: transformers
+pipeline_tag: automatic-speech-recognition
+base_model: openai/whisper-small
+tags:
+  - polywhisper
+  - indic-asr
+  - hindi-asr
+  - tamil-speech-recognition
+  - telugu-stt
+  - bengali-asr
+  - marathi-speech-to-text
+  - speech-recognition
+  - multilingual
+  - lora
+  - whisper
+  - hindi
+  - tamil
+  - telugu
+  - bengali
+  - marathi
+  - indic-languages
+  - indian-languages
+  - automatic-speech-recognition
+  - speech-to-text
+  - low-resource-asr
+  - fleurs
+  - indicvoices
+  - onnx
+  - quantized
+  - efficient-asr
+  - edge-asr
+  - peft
+datasets:
+  - ai4bharat/indicvoices-st
+  - google/fleurs
+model-index:
+  - name: PolyWhisper v9 (Whisper-Small + Per-Language LoRA)
+    results:
+      - task:
+          type: automatic-speech-recognition
+          name: Hindi Speech Recognition
+        dataset:
+          name: FLEURS Hindi (hi_in)
+          type: google/fleurs
+        metrics:
+          - type: wer
+            value: 46.3
+            name: WER (beam=1, normalized)
+      - task:
+          type: automatic-speech-recognition
+          name: Tamil Speech Recognition
+        dataset:
+          name: FLEURS Tamil (ta_in)
+          type: google/fleurs
+        metrics:
+          - type: wer
+            value: 70.1
+            name: WER (beam=1, normalized)
+      - task:
+          type: automatic-speech-recognition
+          name: Telugu Speech Recognition
+        dataset:
+          name: FLEURS Telugu (te_in)
+          type: google/fleurs
+        metrics:
+          - type: wer
+            value: 100.1
+            name: WER (beam=1, normalized)
+      - task:
+          type: automatic-speech-recognition
+          name: Bengali Speech Recognition
+        dataset:
+          name: FLEURS Bengali (bn_in)
+          type: google/fleurs
+        metrics:
+          - type: wer
+            value: 130.2
+            name: WER (beam=1, normalized)
+      - task:
+          type: automatic-speech-recognition
+          name: Marathi Speech Recognition
+        dataset:
+          name: FLEURS Marathi (mr_in)
+          type: google/fleurs
+        metrics:
+          - type: wer
+            value: 96.7
+            name: WER (beam=1, normalized)
+---
+
+[![Model](https://img.shields.io/badge/%F0%9F%A4%97%20Model-eulogik%2Fpolywhisper-ffd21e)](https://huggingface.co/eulogik/polywhisper)
+[![GitHub](https://img.shields.io/badge/GitHub-eulogik%2FPolyWhisper-181717?style=flat&logo=github)](https://github.com/eulogik/PolyWhisper)
+[![Release](https://img.shields.io/github/v/release/eulogik/PolyWhisper?label=release)](https://github.com/eulogik/PolyWhisper/releases)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-ee4c2c?logo=pytorch)](https://pytorch.org/)
+[![ONNX](https://img.shields.io/badge/ONNX-Runtime-orange?logo=onnx)](https://onnxruntime.ai/)
+![Hindi](https://img.shields.io/badge/Hindi-hi-138808) ![Tamil](https://img.shields.io/badge/Tamil-ta-FF9933) ![Telugu](https://img.shields.io/badge/Telugu-te-046A38) ![Bengali](https://img.shields.io/badge/Bengali-bn-006A4E) ![Marathi](https://img.shields.io/badge/Marathi-mr-FF9933)
+
+# 🎙️ PolyWhisper v9 — Efficient Multilingual Indic ASR
+
+> **TL;DR:** PolyWhisper v9 is a production-ready automatic speech recognition (ASR) system for **Hindi, Tamil, Telugu, Bengali, and Marathi**. It pairs a **frozen OpenAI Whisper-Small backbone (244M params)** with tiny **per-language LoRA adapters (~14MB each)**. Bengali WER drops **−34.5%** and Marathi **−43.2%** versus the no-augmentation baseline — at roughly **1% of the storage cost** of full fine-tuning.
+
+## ✨ Why PolyWhisper?
+
+| | Full fine-tune (per language) | **PolyWhisper v9** |
+|---|---|---|
+| Storage per language | ~1.5 GB | **~14 MB (100× smaller)** |
+| Backbone | retrained each time | **frozen once, shared by all 5** |
+| Bengali (bn) FLEURS WER | 198.8 (baseline) | **130.2 (−34.5%)** |
+| Marathi (mr) FLEURS WER | 170.1 (baseline) | **96.7 (−43.2%)** |
+| Telugu (te) FLEURS WER | 105.9 (baseline) | **100.1 (−5.5%)** |
+| Hindi (hi) FLEURS WER | 43.0 (baseline) | **46.3** |
+| Tamil (ta) FLEURS WER | 68.2 (baseline) | **70.1** |
+| CPU deployment | heavy | **ONNX INT8, no GPU needed** |
+
+*WER = word error rate (lower is better). FLEURS test set, beam=1, punctuation-normalized scoring.*
+
+## 📊 Benchmarks (FLEURS, beam=1, normalized WER)
+
+| Language | Code | Script | v7 (no augment) | **v9 final** | Δ vs v7 |
+|---|---|---|---|---|---|
+| Hindi | `hi` | Devanagari | 43.0 | **46.3** | +7.7% |
+| Tamil | `ta` | Tamil | 68.2 | **70.1** | +2.8% |
+| Telugu | `te` | Telugu | 105.9 | **100.1** | ✅ **−5.5%** |
+| Bengali | `bn` | Bengali | 198.8 | **130.2** | ✅ **−34.5%** |
+| Marathi | `mr` | Devanagari | 170.1 | **96.7** | ✅ **−43.2%** |
+
+### 🧪 The v9 finding: augment per language, not globally
+
+Training with SpecAugment + speed perturbation on **all** languages damaged Hindi/Tamil (token-loop degeneration) while massively helping Bengali/Marathi. The v9 recipe augments **only `bn`/`mr`** and trains `hi`/`ta` clean:
+
+| Language | Augmentation | Result |
+|---|---|---|
+| Hindi, Tamil | none (clean) | matches no-augment baseline |
+| Telugu, Bengali, Marathi | SpecAugment + 0.9×/1.1× speed perturb | large gains on hard languages |
+
+## 📦 Which adapter should I use?
+
+| Language | Adapter file | Backbone | WER |
+|---|---|---|---|
+| Hindi (`hi`) | `polywhisper_output_hi/adapters_v3/hi_best_clean.pt` | `openai/whisper-small` | 46.3 |
+| Tamil (`ta`) | `polywhisper_output_ta/adapters_v3/ta_best_clean.pt` | `openai/whisper-small` | 70.1 |
+| Telugu (`te`) | `polywhisper_output_gpu0/adapters_v3/te_best_prod.pt` | `openai/whisper-small` | 100.1 |
+| Bengali (`bn`) | `polywhisper_output_gpu0/adapters_v3/bn_best_prod.pt` | `openai/whisper-small` | 130.2 |
+| Marathi (`mr`) | `polywhisper_output_gpu1/adapters_v3/mr_best_prod.pt` | `openai/whisper-small` | 96.7 |
+
+All adapters are rank-16 LoRA (decoder + encoder attention), ~14MB each. Backbone weights are **not** included — they load from `openai/whisper-small` at runtime.
+
+## 🚀 Quickstart
+
+```bash
+pip install -e .
+```
+
+```bash
+# Hindi speech to text
+polywhisper transcribe audio.wav --lang hi
+
+# Tamil with JSON output
+polywhisper transcribe audio.wav --lang ta --format json
+
+# Auto-detect language, SRT subtitles
+polywhisper transcribe audio.wav --format srt > subs.srt
+
+# Batch a folder
+polywhisper batch ./audio_folder/ --lang bn --output results.json
+```
+
+```python
+from polywhisper import transcribe
+
+result = transcribe("audio.wav", lang="mr")
+print(result.text)
+print(result.segments)  # timestamped segments
+```
+
+## 🖥️ CPU-only inference (ONNX Runtime)
+
+Export INT8-quantized ONNX graphs (no PyTorch, no GPU needed at inference):
+
+```bash
+polywhisper export --lang hi --variant prod --int8
+```
+
+Pre-exported v9 graphs live under `export/onnx/` on the [Hub](https://huggingface.co/eulogik/polywhisper/tree/main/export/onnx) — per language, fp32 + INT8:
+
+| Lang | Encoder (fp32 / INT8) | Decoder (fp32 / INT8) |
+|---|---|---|
+| hi | 358MB / 97MB | 784MB / 204MB |
+| ta | 358MB / 97MB | 784MB / 204MB |
+| te | 358MB / 97MB | 784MB / 204MB |
+| bn | 358MB / 97MB | 784MB / 204MB |
+| mr | 358MB / 97MB | 784MB / 204MB |
+
+Files are named `{lang}_{lang}_best_prod_{encoder,decoder}{,_int8}.onnx`. INT8 is ~4× smaller.
+
+**Verification:** fp32 ONNX vs PyTorch max diff < 1e-3 on all five languages (encoder + decoder). End-to-end greedy spot-checks (FLEURS audio, beam=1):
+
+| Lang | torch WER | ONNX INT8 WER |
+|---|---|---|
+| hi (10 samples) | 43.4% | 48.3% |
+| ta (5 samples) | 100.0% | 100.0% |
+| te (5 samples) | 100.0% | 101.6% |
+| bn (5 samples) | 104.9% | 118.7% |
+| mr (5 samples) | 82.9% | 89.4% |
+
+*Spot-checks are tiny (5–10 utterances) so single-sentence flips move the numbers; fp32 ONNX is at parity with torch. INT8 trades a few points for 4× smaller files.*
+
+## 🏋️ Training recipe (reproducible)
+
+- **Data:** [IndicVoices-ST](https://huggingface.co/datasets/ai4bharat/indicvoices-st) (~19–20k clips/language) · **Eval:** [FLEURS](https://huggingface.co/datasets/google/fleurs)
+- **Backbone:** `openai/whisper-small`, frozen · **Adapters:** LoRA rank-16, encoder + decoder attention
+- **Schedule:** 3–5 epochs/language, batch 4, AdamW, cosine LR (peak 1e-4), 2× NVIDIA T4
+- **Augmentation (v9):** SpecAugment + speed perturb for `bn`/`mr` only; `hi`/`ta`/`te` clean
+- **Selection:** WER-gated checkpoints (`*_best_*.pt`) on FLEURS dev slices
+- **Code:** [`train_v3.py`](https://github.com/eulogik/PolyWhisper/blob/main/train_v3.py) · orchestrator [`kaggle_train_resumable.py`](https://github.com/eulogik/PolyWhisper/blob/main/kaggle_train_resumable.py) · scoring [`normalize_ortho.py`](https://github.com/eulogik/PolyWhisper/blob/main/normalize_ortho.py)
+
+## ❓ FAQ
+
+**What is PolyWhisper?**
+PolyWhisper is an open-source Indic ASR toolkit: one frozen Whisper-Small backbone plus five small per-language LoRA adapters covering Hindi, Tamil, Telugu, Bengali, and Marathi.
+
+**How is it different from fine-tuning Whisper?**
+Full fine-tuning rewrites ~244M–1.5B weights per language. PolyWhisper freezes the backbone and trains ~3.5M LoRA parameters per language (~14MB), so five languages ship for the storage cost of a rounding error.
+
+**Which languages are production-ready?**
+All five ship working adapters. Hindi (46.3 WER) and Tamil (70.1) are strongest; Bengali and Marathi improved dramatically in v9 (−34.5% / −43.2% vs baseline) but remain the hardest languages.
+
+**Can I run it on CPU?**
+Yes — export to ONNX INT8 and run with ONNX Runtime, no GPU required.
+
+**Can I run it on a Mac?**
+Yes — PyTorch MPS is supported (`Device: mps`), plus CPU via ONNX.
+
+**What data was it trained/evaluated on?**
+Trained on IndicVoices-ST conversational speech, evaluated on FLEURS read speech with punctuation-normalized, script-aware scoring.
+
+## ⚠️ Limitations
+
+- Absolute WER on Telugu/Bengali/Marathi is still high — usable for assistive/search/subtitle-draft workflows, not verbatim legal/medical transcription.
+- Evaluated on read speech (FLEURS); spontaneous conversational accuracy will differ.
+- Beam=1 numbers above; beam=5 decoding improves results at higher latency.
+
+## 📄 License & citation
+
+Apache 2.0. Whisper weights © OpenAI. Training data: IndicVoices-ST (CC-BY) · Eval: FLEURS (CC-BY).
+
+```bibtex
+@misc{polywhisper2026,
+  title  = {PolyWhisper: Efficient Multilingual Indic ASR via Frozen Backbone + Per-Language LoRA},
+  author = {Eulogik},
+  year   = {2026},
+  publisher = {HuggingFace},
+  url    = {https://huggingface.co/eulogik/polywhisper}
+}
+```
+
+## 🔗 Links
+
+- 🤗 Model: [huggingface.co/eulogik/polywhisper](https://huggingface.co/eulogik/polywhisper)
+- 💻 Code: [github.com/eulogik/PolyWhisper](https://github.com/eulogik/PolyWhisper)
+- 🗣️ Train data: [ai4bharat/indicvoices-st](https://huggingface.co/datasets/ai4bharat/indicvoices-st)
+- 🧪 Eval data: [google/fleurs](https://huggingface.co/datasets/google/fleurs)

polywhisper-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+polywhisper/__init__.py,sha256=vDnGpzmeWV2WoULg72CuAfvQ-cNf_WWJtYihEX1KnRc,235
+polywhisper/__main__.py,sha256=Gsf4y5lgUzui6-4PrYwWfGwZRoYRFJhVj5f-wi8aAeo,85
+polywhisper/audio.py,sha256=4OFpJIs3LH2LbwlVX6PaxSvlWO8r70KiX7MdzEB1uOs,2261
+polywhisper/cli.py,sha256=YRHGHCCofXeYhuXcR2LGOA9ZWCtt7SkRt0EOEs3o5ks,8374
+polywhisper/model.py,sha256=jLc1b0LPkfNwFxH5ycQWxvi_IylIeLWzahWup_qguaE,9567
+polywhisper/onnx_backend.py,sha256=nbUcDVb2rpA0rbqmzWjOEM3Qafh2DSDTU0U1kSoQvxg,7889
+polywhisper/transcribe.py,sha256=D6UcK7QUHQMJXDp9AMrM8VtlWj8n9xeFq_btvp5rV3Y,7177
+polywhisper-0.2.0.dist-info/METADATA,sha256=yOw05KVIcUrsVF1K1A85J5An7_KaVZMlHNaBZM7164Q,12763
+polywhisper-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+polywhisper-0.2.0.dist-info/entry_points.txt,sha256=iBrqtTyS0CGIDyHlkd96O8EkgxRhzN2SulXUC4uefKk,53
+polywhisper-0.2.0.dist-info/licenses/LICENSE,sha256=4bt-7Tb8w5uJ6opej7_pcNbLsqhfXSHvxDKW1YEivSE,1064
+polywhisper-0.2.0.dist-info/RECORD,,

polywhisper-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

polywhisper-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+polywhisper = polywhisper.cli:main

polywhisper-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eulogik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.