evaluation methods update

backends/auto.py

@@ -1,6 +1,8 @@
 """
-When the model id matches a known special stack, use that first; otherwise try:
-ASR pipeline -> SpeechSeq2Seq -> AutoModel (remote code) -> CTC.
+Simplified backend cascade:
+    pipeline -> (Granite chat path if the id matches) -> universal -> CTC.
+
+`universal` replaces the old SpeechSeq2Seq / AutoModel+remote / Cohere-specific backends.
 """
 
 from __future__ import annotations
@@ -8,12 +10,10 @@ from __future__ import annotations
 from collections.abc import Callable
 
 from . import (
-    cohere_asr,
     granite_speech,
-    transformers_auto_remote,
     transformers_ctc,
     transformers_pipeline,
-    transformers_seq2seq,
+    universal,
 )
 
 
@@ -22,54 +22,34 @@ def _is_granite_speech_model(model_id: str) -> bool:
     return "ibm-granite/" in m and "granite-" in m and "-speech" in m
 
 
-def _is_cohere_transcribe_model(model_id: str) -> bool:
-    m = model_id.lower()
-    return "cohere-transcribe" in m or (
-        m.startswith("coherelabs/") and "transcribe" in m
-    )
-
-
 def build_transcriber(
     model_id: str,
     device_str: str,
     device_int: int,
 ) -> tuple[Callable[..., str], Callable[[], None]]:
-    last_err: Exception | None = None
+    errors: list[str] = []
 
-    # Prefer authoritative recipes before the generic ASR pipeline (avoids wrong wrappers).
     if _is_granite_speech_model(model_id):
         try:
             return granite_speech.build_transcriber(model_id, device_str)
         except Exception as e:
-            last_err = e
-
-    if _is_cohere_transcribe_model(model_id):
-        try:
-            return cohere_asr.build_transcriber(model_id, device_str)
-        except Exception as e:
-            last_err = e
+            errors.append(f"granite_speech: {type(e).__name__}: {e}")
 
     try:
         return transformers_pipeline.build_transcriber(model_id, device_int)
     except Exception as e:
-        last_err = e
-
-    try:
-        return transformers_seq2seq.build_transcriber(model_id, device_str)
-    except Exception as e:
-        last_err = e
+        errors.append(f"pipeline: {type(e).__name__}: {e}")
 
     try:
-        return transformers_auto_remote.build_transcriber(model_id, device_str)
+        return universal.build_transcriber(model_id, device_str)
     except Exception as e:
-        last_err = e
+        errors.append(f"universal: {type(e).__name__}: {e}")
 
     try:
         return transformers_ctc.build_transcriber(model_id, device_str)
     except Exception as e:
-        last_err = e
+        errors.append(f"ctc: {type(e).__name__}: {e}")
 
     raise RuntimeError(
-        f"Could not load {model_id} with Granite speech, Cohere transcribe, pipeline, "
-        f"SpeechSeq2Seq, AutoModel (remote), or CTC. Last error: {last_err}"
-    ) from last_err
+        f"Could not load {model_id}. Tried: " + " | ".join(errors)
+    )

backends/cohere_asr.py

@@ -1,56 +0,0 @@
-"""
-Cohere Transcribe (CohereLabs/cohere-transcribe-*): `CohereAsrForConditionalGeneration.transcribe()`.
-
-This path does **not** use generic `generate()` + `batch_decode`; the model exposes `transcribe(processor=..., audio_arrays=..., ...)`.
-Requires a recent `transformers` (Cohere ASR support). Gated checkpoints need `HF_TOKEN` on the Space.
-Language: env `FFASR_COHERE_LANGUAGE` (default `en`).
-"""
-
-from __future__ import annotations
-
-import os
-from collections.abc import Callable
-
-import numpy as np
-import torch
-from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
-
-
-def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str], Callable[[], None]]:
-    processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
-    use_cuda = device_str == "cuda" and torch.cuda.is_available()
-    dtype = torch.bfloat16 if use_cuda and torch.cuda.is_bf16_supported() else (
-        torch.float16 if use_cuda else torch.float32
-    )
-    model = AutoModelForSpeechSeq2Seq.from_pretrained(
-        model_id,
-        trust_remote_code=True,
-        torch_dtype=dtype,
-    ).to(device_str)
-    model.eval()
-
-    if not hasattr(model, "transcribe"):
-        raise RuntimeError(
-            "Loaded class has no transcribe(); upgrade transformers to a build with Cohere ASR support."
-        )
-
-    lang = os.environ.get("FFASR_COHERE_LANGUAGE", "en").strip() or "en"
-
-    def transcribe(audio_np: np.ndarray, sampling_rate: int = 16000) -> str:
-        arr = np.asarray(audio_np, dtype=np.float32).reshape(-1)
-        texts = model.transcribe(
-            processor=processor,
-            audio_arrays=[arr],
-            sample_rates=[int(sampling_rate)],
-            language=lang,
-        )
-        if not texts:
-            return ""
-        t = texts[0]
-        return str(t).strip() if t is not None else ""
-
-    def cleanup() -> None:
-        nonlocal model, processor
-        del model, processor
-
-    return transcribe, cleanup

backends/registry.py

@@ -8,49 +8,47 @@ from collections.abc import Callable
 
 from . import (
     auto,
-    cohere_asr,
     granite_speech,
-    transformers_auto_remote,
     transformers_ctc,
     transformers_pipeline,
-    transformers_seq2seq,
+    universal,
 )
 
+
 # id -> (short label for CSV, one-line description for UI)
 FAMILY_META: dict[str, tuple[str, str]] = {
     "auto": (
         "Auto",
-        "Pipeline, then Granite/Cohere-specific paths when the model id matches, then SpeechSeq2Seq, AutoModel+remote, CTC.",
+        "Pipeline → (Granite chat if id matches) → universal (AutoModelForSpeechSeq2Seq or AutoModel+remote) → CTC.",
     ),
     "transformers_pipeline": (
         "Transformers pipeline",
         "`pipeline('automatic-speech-recognition')` — Whisper, many bundled ASR heads.",
     ),
-    "transformers_seq2seq": (
-        "Transformers SpeechSeq2Seq",
-        "`AutoModelForSpeechSeq2Seq` + `generate()` — use when pipeline fails (e.g. some remote-code models).",
-    ),
-    "transformers_ctc": (
-        "Transformers CTC",
-        "`AutoModelForCTC` — Wav2Vec2 / HuBERT CTC and similar.",
-    ),
-    "transformers_auto_remote": (
-        "AutoModel + remote code (Whisper input_features)",
-        "`AutoModel` + `trust_remote_code` + `generate(input_features)` — efficient-speech / custom Whisper checkpoints. "
-        "Optional env `FFASR_REMOTE_PROCESSOR_ID` if the processor is not in the model repo (default fallback: openai/whisper-large-v3).",
+    "universal": (
+        "Universal speech-seq2seq",
+        "`AutoModelForSpeechSeq2Seq` (or `AutoModel` + `trust_remote_code`) + `generate()` + `decode()`. "
+        "Works for Whisper, Cohere Transcribe, efficient-speech / custom Whisper variants, etc. "
+        "Env: `FFASR_PROCESSOR_ID`, `FFASR_LANGUAGE` (default `en`), `FFASR_MAX_NEW_TOKENS`.",
     ),
     "granite_speech": (
         "IBM Granite speech (chat prompt)",
         "`ibm-granite/granite-*-speech`: chat template + `processor(prompt, wav)` + decode new tokens only. "
         "Optional env `FFASR_GRANITE_PROMPT` to override the default transcription prompt.",
     ),
-    "cohere_asr": (
-        "Cohere Transcribe",
-        "`CohereLabs/cohere-transcribe-*`: uses the model's `transcribe()` API (not generic ASR pipeline). "
-        "Gated checkpoints require Hub access + `HF_TOKEN`. Env `FFASR_COHERE_LANGUAGE` (default `en`).",
+    "transformers_ctc": (
+        "Transformers CTC",
+        "`AutoModelForCTC` — Wav2Vec2 / HuBERT CTC and similar.",
     ),
 }
 
+# Aliases: keep older submissions / CSV rows working after the cleanup.
+_FAMILY_ALIASES: dict[str, str] = {
+    "transformers_seq2seq": "universal",
+    "transformers_auto_remote": "universal",
+    "cohere_asr": "universal",
+}
+
 FAMILY_IDS: tuple[str, ...] = tuple(FAMILY_META.keys())
 
 # Gradio Dropdown expects each tuple as (label, value): label is shown; value is passed to Python.
@@ -60,17 +58,14 @@ DROPDOWN_CHOICES: list[tuple[str, str]] = [
 
 
 def normalize_family_id(raw: str | None) -> str | None:
-    """
-    Map UI / API input to a canonical family id.
-
-    Gradio must receive (label, value) tuples in DROPDOWN_CHOICES; if an old client
-    still sends the long label string, map it back to the id when possible.
-    """
+    """Map UI / API input (or an older CSV value) to a canonical family id."""
     if raw is None:
         return None
     s = raw.strip()
     if s in FAMILY_META:
         return s
+    if s in _FAMILY_ALIASES:
+        return _FAMILY_ALIASES[s]
     for fid, (short, desc) in FAMILY_META.items():
         long_label = f"{short} — {desc}"
         if s == long_label:
@@ -83,6 +78,8 @@ def default_family_id() -> str:
 
 
 def resolve_label(family_id: str) -> str:
+    if family_id in _FAMILY_ALIASES:
+        family_id = _FAMILY_ALIASES[family_id]
     return FAMILY_META.get(family_id, (family_id, ""))[0]
 
 
@@ -92,18 +89,15 @@ def build_transcriber(
     device_str: str,
     device_int: int,
 ) -> tuple[Callable[..., str], Callable[[], None]]:
-    if family_id == "auto":
+    fid = _FAMILY_ALIASES.get(family_id, family_id)
+    if fid == "auto":
         return auto.build_transcriber(model_id, device_str, device_int)
-    if family_id == "transformers_pipeline":
+    if fid == "transformers_pipeline":
         return transformers_pipeline.build_transcriber(model_id, device_int)
-    if family_id == "transformers_seq2seq":
-        return transformers_seq2seq.build_transcriber(model_id, device_str)
-    if family_id == "transformers_ctc":
-        return transformers_ctc.build_transcriber(model_id, device_str)
-    if family_id == "transformers_auto_remote":
-        return transformers_auto_remote.build_transcriber(model_id, device_str)
-    if family_id == "granite_speech":
+    if fid == "universal":
+        return universal.build_transcriber(model_id, device_str)
+    if fid == "granite_speech":
         return granite_speech.build_transcriber(model_id, device_str)
-    if family_id == "cohere_asr":
-        return cohere_asr.build_transcriber(model_id, device_str)
+    if fid == "transformers_ctc":
+        return transformers_ctc.build_transcriber(model_id, device_str)
     raise ValueError(f"Unknown model family: {family_id!r}. Choose one of {FAMILY_IDS}.")

backends/transformers_auto_remote.py

@@ -1,114 +0,0 @@
-"""
-Hugging Face `AutoModel` + `trust_remote_code=True` with Whisper-style `input_features` + `generate()`.
-
-Used by compressed / custom Whisper checkpoints (e.g. efficient-speech/*) that are **not**
-registered as `AutoModelForSpeechSeq2Seq` but follow: processor → `input_features` → `model.generate(...)`.
-
-Processor repo often differs from the weight repo (e.g. weights on `efficient-speech/...`,
-processor on `openai/whisper-large-v3`). Override with env `FFASR_REMOTE_PROCESSOR_ID`.
-"""
-
-from __future__ import annotations
-
-import os
-from collections.abc import Callable
-
-import numpy as np
-import torch
-from transformers import AutoModel, AutoProcessor
-
-
-def _whisper_like_generate(model, processor, input_features: torch.Tensor):
-    """
-    LiteWhisper / Whisper checkpoints need task+language (or forced_decoder_ids); otherwise
-    `generate` can fail validation on `decoder_input_ids` length vs `max_new_tokens`.
-    """
-    base = dict(max_new_tokens=2048, num_beams=1)
-    attempts: list[dict] = [
-        {**base, "task": "transcribe", "language": "en"},
-        {**base, "task": "transcribe", "language": "english"},
-    ]
-
-    for extra in attempts:
-        try:
-            return model.generate(input_features, **extra)
-        except Exception:
-            try:
-                return model.generate(input_features=input_features, **extra)
-            except Exception:
-                continue
-
-    try:
-        if hasattr(processor, "get_decoder_prompt_ids"):
-            fd = processor.get_decoder_prompt_ids(language="english", task="transcribe")
-            return model.generate(
-                input_features,
-                forced_decoder_ids=fd,
-                max_new_tokens=2048,
-                num_beams=1,
-            )
-    except Exception:
-        pass
-
-    try:
-        return model.generate(input_features, **base)
-    except Exception:
-        return model.generate(input_features=input_features, **base)
-
-
-def _load_processor(model_id: str):
-    """
-    If `FFASR_REMOTE_PROCESSOR_ID` is set, use it (matches many model cards: weights on one repo,
-    processor on `openai/whisper-large-v3`). Otherwise try the checkpoint repo, then Whisper large-v3.
-    """
-    override = os.environ.get("FFASR_REMOTE_PROCESSOR_ID", "").strip()
-    if override:
-        return AutoProcessor.from_pretrained(override, trust_remote_code=True)
-    fallback = "openai/whisper-large-v3"
-    try:
-        return AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
-    except Exception:
-        return AutoProcessor.from_pretrained(fallback, trust_remote_code=True)
-
-
-def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str], Callable[[], None]]:
-    processor = _load_processor(model_id)
-    use_cuda = device_str == "cuda" and torch.cuda.is_available()
-    dtype = torch.float16 if use_cuda else torch.float32
-
-    model = AutoModel.from_pretrained(
-        model_id,
-        trust_remote_code=True,
-        torch_dtype=dtype,
-    ).to(device_str)
-    model.eval()
-
-    def transcribe(audio_np: np.ndarray, sampling_rate: int = 16000) -> str:
-        wav = np.asarray(audio_np, dtype=np.float32).reshape(-1)
-        inputs = processor(wav, sampling_rate=sampling_rate, return_tensors="pt")
-        if hasattr(inputs, "input_features"):
-            input_features = inputs.input_features
-        elif isinstance(inputs, dict) and "input_features" in inputs:
-            input_features = inputs["input_features"]
-        else:
-            raise RuntimeError(
-                "Processor did not return input_features; set FFASR_REMOTE_PROCESSOR_ID to a "
-                "Whisper-compatible processor (e.g. openai/whisper-large-v3)."
-            )
-        input_features = input_features.to(device_str)
-        if input_features.dtype != dtype:
-            input_features = input_features.to(dtype=dtype)
-
-        with torch.no_grad():
-            generated_ids = _whisper_like_generate(model, processor, input_features)
-
-        text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-        return str(text).strip()
-
-    def cleanup() -> None:
-        # `nonlocal` is required: otherwise `del model` makes `model` local to `cleanup` and raises
-        # UnboundLocalError ("cannot access local variable 'model'...").
-        nonlocal model, processor
-        del model, processor
-
-    return transcribe, cleanup

backends/transformers_seq2seq.py

@@ -1,45 +0,0 @@
-"""
-Hugging Face SpeechSeq2Seq: AutoProcessor + AutoModelForSpeechSeq2Seq + generate().
-For models that do not work with the ASR pipeline (e.g. some remote-code Granite stacks).
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-
-import numpy as np
-import torch
-from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
-
-
-def _prepare_inputs(processor, waveform_batched, sampling_rate: int):
-    try:
-        return processor(waveform_batched, sampling_rate=sampling_rate, return_tensors="pt")
-    except TypeError:
-        try:
-            return processor(audios=waveform_batched, sampling_rate=sampling_rate, return_tensors="pt")
-        except TypeError:
-            return processor(waveform_batched, return_tensors="pt")
-
-
-def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str], Callable[[], None]]:
-    processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
-    model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, trust_remote_code=True).to(device_str)
-    model.eval()
-
-    def transcribe(audio_np: np.ndarray, sampling_rate: int = 16000) -> str:
-        wav = torch.from_numpy(audio_np).float()
-        if wav.dim() == 1:
-            wav = wav.unsqueeze(0)
-        inputs = _prepare_inputs(processor, wav, sampling_rate)
-        inputs = {k: v.to(device_str) if hasattr(v, "to") else v for k, v in inputs.items()}
-        with torch.no_grad():
-            generated_ids = model.generate(**inputs, max_new_tokens=256)
-        pred_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-        return pred_text
-
-    def cleanup() -> None:
-        nonlocal model, processor
-        del model, processor
-
-    return transcribe, cleanup

backends/universal.py

@@ -0,0 +1,205 @@
+"""
+One ASR backend for ~every speech-seq2seq model: built-in (Whisper, CohereAsr, ...) and
+remote-code (efficient-speech, custom Whisper variants, etc.).
+
+Flow:
+    processor(audio, sr, return_tensors="pt", [language="en"])
+    model.generate(**inputs, max_new_tokens=_safe_cap(model))
+    processor.decode(outputs, ...)  (falls back to processor.batch_decode)
+
+Loading order:
+    1. `AutoModelForSpeechSeq2Seq.from_pretrained(..., trust_remote_code=True)`
+       Covers standard HF classes (Whisper, CohereAsrForConditionalGeneration, ...).
+    2. `AutoModel.from_pretrained(..., trust_remote_code=True)`
+       Covers repos that expose their generator class via `auto_map["AutoModel"]`
+       (e.g. `efficient-speech/lite-whisper-*`).
+
+Environment overrides (all optional):
+    FFASR_PROCESSOR_ID  — force a fallback processor (e.g. `openai/whisper-large-v3`).
+    FFASR_LANGUAGE      — pass language=... to processor/generate when supported. Default: `en`.
+    FFASR_MAX_NEW_TOKENS — override generate() length budget. Default: auto (safe cap).
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+
+import numpy as np
+import torch
+from transformers import AutoModel, AutoModelForSpeechSeq2Seq, AutoProcessor
+
+
+def _safe_max_new_tokens(model, env_override: int | None, default_cap: int = 256) -> int:
+    """
+    Whisper-style models enforce `len(decoder_prefix) + max_new_tokens ≤ max_target_positions`.
+    Derive a cap from the config so we never trip that validation.
+    """
+    if env_override is not None and env_override > 0:
+        return int(env_override)
+    cfg = getattr(model, "config", None)
+    if cfg is None:
+        return default_cap
+    mtp = (
+        getattr(cfg, "max_target_positions", None)
+        or getattr(cfg, "max_length", None)
+        or getattr(cfg, "max_position_embeddings", None)
+    )
+    try:
+        mtp = int(mtp) if mtp else 0
+    except Exception:
+        mtp = 0
+    if mtp and mtp <= 2048:
+        # Leave headroom for task/language/timestamp prefix tokens.
+        return max(32, min(448, mtp - 16))
+    return default_cap
+
+
+def _pick_dtype(device_str: str) -> torch.dtype:
+    use_cuda = device_str == "cuda" and torch.cuda.is_available()
+    if use_cuda and torch.cuda.is_bf16_supported():
+        return torch.bfloat16
+    if use_cuda:
+        return torch.float16
+    return torch.float32
+
+
+def _load_processor(model_id: str):
+    override = os.environ.get("FFASR_PROCESSOR_ID", "").strip()
+    if override:
+        return AutoProcessor.from_pretrained(override, trust_remote_code=True)
+    try:
+        return AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+    except Exception:
+        return AutoProcessor.from_pretrained(
+            "openai/whisper-large-v3", trust_remote_code=True
+        )
+
+
+def _load_model(model_id: str, dtype: torch.dtype, device_str: str):
+    errors: list[str] = []
+    for cls in (AutoModelForSpeechSeq2Seq, AutoModel):
+        try:
+            model = cls.from_pretrained(
+                model_id,
+                trust_remote_code=True,
+                torch_dtype=dtype,
+            ).to(device_str)
+            return model, cls.__name__
+        except Exception as e:
+            errors.append(f"{cls.__name__}: {type(e).__name__}: {e}")
+    raise RuntimeError("; ".join(errors))
+
+
+def _call_processor(processor, audio: np.ndarray, sampling_rate: int, language: str):
+    """Most ASR processors accept `sampling_rate` and either ignore or consume `language`."""
+    tries = (
+        dict(sampling_rate=sampling_rate, return_tensors="pt", language=language),
+        dict(sampling_rate=sampling_rate, return_tensors="pt"),
+    )
+    last_exc: Exception | None = None
+    for kwargs in tries:
+        try:
+            return processor(audio, **kwargs)
+        except (TypeError, ValueError) as e:
+            last_exc = e
+            continue
+    if last_exc is not None:
+        raise last_exc
+    return processor(audio, sampling_rate=sampling_rate, return_tensors="pt")
+
+
+def _move_to_device(inputs, device_str: str, dtype: torch.dtype):
+    if hasattr(inputs, "to"):
+        inputs = inputs.to(device_str)
+        try:
+            inputs = inputs.to(dtype=dtype)
+        except Exception:
+            pass
+    batch = dict(inputs)
+    meta: dict = {}
+    for key in ("audio_chunk_index",):
+        if key in batch:
+            meta[key] = batch.pop(key)
+    return batch, meta
+
+
+def _generate(model, batch: dict, max_new_tokens: int, language: str):
+    """Try language-aware generate first (Whisper path); fall back to plain generate."""
+    base = dict(max_new_tokens=max_new_tokens, num_beams=1)
+
+    attempts = (
+        {**base, "task": "transcribe", "language": language},
+        base,
+    )
+    last: Exception | None = None
+    for extra in attempts:
+        try:
+            return model.generate(**batch, **extra)
+        except TypeError as e:
+            last = e
+        except Exception as e:
+            # Whisper sometimes raises when a kwarg (language) is unsupported for this model.
+            last = e
+            if "language" in extra:
+                continue
+            raise
+    if last is not None:
+        raise last
+    return model.generate(**batch, **base)
+
+
+def _decode(processor, outputs, meta: dict, language: str) -> str:
+    """Prefer `processor.decode` (Cohere / long-form chunking); else `batch_decode`."""
+    if hasattr(processor, "decode"):
+        try:
+            if meta.get("audio_chunk_index") is not None:
+                return str(
+                    processor.decode(
+                        outputs,
+                        skip_special_tokens=True,
+                        audio_chunk_index=meta["audio_chunk_index"],
+                        language=language,
+                    )
+                ).strip()
+            result = processor.decode(outputs, skip_special_tokens=True)
+            if isinstance(result, str):
+                return result.strip()
+        except TypeError:
+            pass
+        except Exception:
+            pass
+    try:
+        decoded = processor.batch_decode(outputs, skip_special_tokens=True)
+        return str(decoded[0]).strip() if decoded else ""
+    except Exception:
+        if hasattr(processor, "tokenizer"):
+            decoded = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            return str(decoded[0]).strip() if decoded else ""
+        raise
+
+
+def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str], Callable[[], None]]:
+    processor = _load_processor(model_id)
+    dtype = _pick_dtype(device_str)
+    model, _cls = _load_model(model_id, dtype, device_str)
+    model.eval()
+
+    language = os.environ.get("FFASR_LANGUAGE", "en").strip() or "en"
+    env_cap_raw = os.environ.get("FFASR_MAX_NEW_TOKENS", "").strip()
+    env_cap = int(env_cap_raw) if env_cap_raw.isdigit() else None
+    max_new = _safe_max_new_tokens(model, env_cap)
+
+    def transcribe(audio_np: np.ndarray, sampling_rate: int = 16000) -> str:
+        arr = np.asarray(audio_np, dtype=np.float32).reshape(-1)
+        inputs = _call_processor(processor, arr, int(sampling_rate), language)
+        batch, meta = _move_to_device(inputs, device_str, dtype)
+        with torch.no_grad():
+            outputs = _generate(model, batch, max_new, language)
+        return _decode(processor, outputs, meta, language)
+
+    def cleanup() -> None:
+        nonlocal model, processor
+        del model, processor
+
+    return transcribe, cleanup

constants.py

@@ -16,7 +16,7 @@ INTRODUCTION_TEXT = (
     "We report the [WER](https://huggingface.co/learn/audio-course/chapter5/evaluation#word-error-rate) "
     "(lower the better) for each condition, plus an average. "
     "Models are ranked by Average WER, lowest to highest.\n\n"
-    "On submit, choose a **model family** (Transformers pipeline, SpeechSeq2Seq, AutoModel+remote, CTC, or Auto) "
+    "On submit, choose a **model family** (Transformers pipeline, Universal speech-seq2seq, Granite speech, CTC, or Auto) "
     "so the server loads the checkpoint the right way.\n\n"
     "The test data is **private** and never leaves our infrastructure. "
     "Submit a HuggingFace model ID below and we run the evaluation server-side.\n\n"
@@ -99,7 +99,7 @@ only accessed by this Space at inference time. This prevents data leakage into t
 
 ## Model compatibility
 
-Supported stacks include **Auto** (Granite speech / Cohere transcribe when the model id matches, then pipeline, SpeechSeq2Seq, AutoModel+remote, CTC), plus explicit families: **Transformers pipeline**, **SpeechSeq2Seq**, **AutoModel + remote code**, **IBM Granite speech**, **Cohere Transcribe**, **CTC**. Gated Hub models need a token with access. Pick the family that matches your checkpoint (or Auto if unsure).
+Supported stacks: **Auto** (Transformers pipeline → Granite speech chat path if the id matches → Universal speech-seq2seq → CTC). Explicit families: **Transformers pipeline**, **Universal speech-seq2seq** (`AutoModelForSpeechSeq2Seq` or `AutoModel` with `trust_remote_code` — Whisper, Cohere Transcribe, efficient-speech / custom Whisper variants), **IBM Granite speech**, **CTC**. Gated Hub models need a token with access. Pick the family that matches your checkpoint (or Auto if unsure).
 
 ## API usage