Release latentASR adapter, code, docs, and reproducibility artifacts

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+

.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+venv/
+env/
+logs/
+eval_runs/
+wandb/
+*.log
+core
+*.tmp
+
+# Keep the released adapter checkpoint, ignore accidental large local artifacts.
+*.bin
+*.safetensors
+*.ckpt
+*.pt
+*.pth
+!checkpoints/latentASR_adapter.pth
+

LICENSE

@@ -0,0 +1,18 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2026 LatentASR contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

README.md

@@ -0,0 +1,126 @@
+---
+license: apache-2.0
+library_name: transformers
+base_model: Qwen/Qwen3-ASR-0.6B
+tags:
+  - automatic-speech-recognition
+  - qwen3-asr
+  - latent-reasoning
+  - test-time-compute
+  - parameter-efficient
+datasets:
+  - google/fleurs
+  - facebook/voxpopuli
+metrics:
+  - wer
+  - cer
+---
+
+# latentASR
+
+`latentASR` is the release repo for **Listen, Think, Transcribe: Continuous
+Latent Test-Time Scaling for ASR**. The method adds a small trainable latent
+adapter and value head on top of a frozen `Qwen/Qwen3-ASR-0.6B` backbone.
+
+The released checkpoint is an adapter-only artifact. It does not redistribute
+the Qwen3-ASR base weights.
+
+## What Is Included
+
+- Core model/training/evaluation code: `model.py`, `train.py`, `eval.py`.
+- Paper-aligned adapter checkpoint: `checkpoints/latentASR_adapter.pth`.
+- Experiment runners: `experiments/`.
+- Analysis and summarization scripts: `scripts/`.
+- Reproducibility artifacts: `results/`.
+- Documentation: `docs/`.
+
+## Method Summary
+
+LatentASR inserts `N=4` latent prefix positions before transcript generation.
+At each latent step, a frozen decoder hidden state is projected into a bounded
+delta, gated, and added around a fixed latent-token embedding. A value head
+predicts whether further latent computation is useful and halts dynamically.
+
+The frozen ASR backbone is never updated in the LatentASR setting. The adapter
+has 5,251,077 trainable parameters.
+
+## Install
+
+```bash
+git clone https://huggingface.co/voidful/latentASR
+cd latentASR
+python -m pip install -r requirements.txt
+```
+
+The code expects the `qwen-asr` package, which provides
+`Qwen3ASRModel.from_pretrained`.
+
+## Quick Evaluation
+
+Evaluate the released adapter on FLEURS English:
+
+```bash
+python eval.py \
+  --model-id Qwen/Qwen3-ASR-0.6B \
+  --dataset-name google/fleurs \
+  --configs en_us \
+  --split test \
+  --latent-ckpt checkpoints/latentASR_adapter.pth \
+  --dynamic-halt-threshold 0.0 \
+  --skip-baseline-ft \
+  --skip-prompt-tuning \
+  --skip-lora-r16 \
+  --output-json eval_runs/fleurs_en_us.json
+```
+
+Use `--max-samples-per-config 100` for a quick smoke test.
+
+## Single-File Transcription
+
+```bash
+python examples/transcribe_file.py path/to/audio.wav \
+  --latent-ckpt checkpoints/latentASR_adapter.pth \
+  --theta 0.0
+```
+
+## Training
+
+The paper-aligned minimal-data activation setting uses:
+
+- `N_LATENT=4`
+- `TRAIN_MAX_SAMPLES=500`
+- effective batch size 16
+- 10 epochs
+- value forced-negative probability `0.3`
+- latent input noise `0.5`
+- latent-loop dropout `0.15`
+
+Run the maintained sequential baseline/adapter trainer:
+
+```bash
+./experiments/run_all_training_modes.sh
+```
+
+Run the paper ablation checkpoint retraining suite:
+
+```bash
+./experiments/run_paper_tbd_retrain.sh
+```
+
+## Result Scope
+
+The clean benchmark deltas are single-run point estimates. They are reported as
+directional, not statistically established, and should be confirmed with paired
+multi-seed testing before making strong claims.
+
+ASCEND is included only as an overlap-confounded in-domain diagnostic because
+ASCEND contributes 5/500 activation utterances and speaker-disjointness was not
+enforced.
+
+## Important Files
+
+- `docs/METHOD.md`: architecture and loss details.
+- `docs/REPRODUCIBILITY.md`: exact commands and evaluation workflow.
+- `docs/RESULTS.md`: headline tables and caveats.
+- `model_metadata.json`: released checkpoint metadata.
+

checkpoints/README.md

@@ -0,0 +1,28 @@
+# Checkpoints
+
+This directory contains the released LatentASR adapter checkpoint:
+
+- `latentASR_adapter.pth`
+
+The checkpoint stores only the lightweight LatentASR modules:
+
+- `init_proj`
+- `delta_proj`
+- `step_proj`
+- `step_embed`
+- `log_scale`
+- `value_head`
+- `injection_gate`
+
+It does not include the frozen `Qwen/Qwen3-ASR-0.6B` backbone. Evaluation and
+inference load the base model from Hugging Face and then attach this adapter.
+
+Checkpoint metadata:
+
+- Source run: `activation_500_epoch10.pth`
+- Base model: `Qwen/Qwen3-ASR-0.6B`
+- Latent budget: `N=4`
+- Training set size: 500 utterances
+- Adapter parameters: 5,251,077
+- SHA256: `f0ce39fa5e6952fced6992508f3e2b32ea8467442b545678781a0f04e64f2430`
+

checkpoints/latentASR_adapter.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0ce39fa5e6952fced6992508f3e2b32ea8467442b545678781a0f04e64f2430
+size 10507457

config.py

@@ -0,0 +1,195 @@
+"""Training configuration dataclass for lr_whisper.
+
+All hyperparameters are read from environment variables via ``TrainingConfig.from_env()``.
+Use ``get_config()`` to obtain a process-wide singleton (lazy, never called at import time).
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from utils import env_flag, normalize_train_mode
+
+
+@dataclass
+class TrainingConfig:
+    # Model / dataset
+    model_id: str = "Qwen/Qwen3-ASR-0.6B"
+    dataset_name: str = "openslr/librispeech_asr"
+    dataset_config: str = "clean"
+
+    # Training batch / epoch
+    batch_size: int = 4
+    grad_accum_steps: int = 4
+    num_epochs: int = 10
+    eval_samples: int = 1000
+    pretrain_eval_samples: int = 10
+
+    # Latent tokens
+    n_latent: int = 4
+    is_deq_train: bool = False
+    deq_train_iters: int = 15
+    halt_threshold: float = 0.0
+    latent_drop_prob: float = 0.15
+    latent_input_noise_std: float = 0.5
+    value_forced_neg_prob: float = 0.3
+    latent_use_bounded_delta: bool = True
+    latent_use_injection_gate: bool = True
+    latent_use_embedding_anchor: bool = True
+    train_max_samples: int = 0
+    checkpoint_prefix: str = ""
+
+    # Thought layout
+    thought_mode: str = "prefix"       # "prefix" | "interleaved"
+    thought_group_size: int = 1        # words per NT token in interleaved mode
+
+    # Training mode
+    train_mode: str = "latent"
+
+    # Learning rates
+    lr_adapter: float = 1e-4
+
+    lr_scale: float = 5e-5
+    lr_baseline_ft: float = 1e-5
+    lr_prompt_tuning: float = 5e-4
+    lr_lora_r16: float = 1e-4
+
+    # Prompt text
+    user_prompt_text: str = "Transcribe the audio into text."
+
+    # Prompt-tuning hyperparameters
+    prompt_tuning_init_mode: str = "text"
+    prompt_tuning_num_virtual_tokens: int = 4
+    prompt_tuning_init_text: str = "Transcribe the audio into text."
+
+    # LoRA hyperparameters
+    lora_rank: int = 16
+    lora_alpha: int = 32
+    lora_dropout: float = 0.05
+    lora_target_modules: List[str] = field(
+        default_factory=lambda: [
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj",
+        ]
+    )
+
+
+    # Delta stabilisation / scale
+    delta_tanh_c: float = 5.0
+    scale_max: float = 3.0
+    scale_init: float = 0.2
+
+    # Regularisation weights
+    w_smooth: float = 0.0  # Disabled — replaced by w_cycle
+    w_cycle: float = 0.1  # Cycle consistency loss (vocabulary-independent) - main regularizer
+    w_value: float = 3.0
+
+    # Logging intervals
+    log_every: int = 50
+    grad_log_every: int = 50
+
+    # Derived flags (set in __post_init__)
+    use_latent_reasoning: bool = False
+    use_prompt_tuning: bool = False
+    use_lora_r16: bool = False
+    use_peft_mode: bool = False
+
+    def __post_init__(self) -> None:
+        valid_modes = {"latent", "baseline", "prompt_tuning", "lora_r16"}
+        if self.train_mode not in valid_modes:
+            raise ValueError(
+                f"Unsupported train_mode={self.train_mode!r}. "
+                f"Use one of: {sorted(valid_modes)}"
+            )
+        valid_thought_modes = {"prefix", "interleaved"}
+        if self.thought_mode not in valid_thought_modes:
+            raise ValueError(
+                f"Unsupported thought_mode={self.thought_mode!r}. "
+                f"Use one of: {sorted(valid_thought_modes)}"
+            )
+        if self.thought_group_size < 1:
+            raise ValueError(f"thought_group_size must be >= 1, got {self.thought_group_size}")
+        self.use_latent_reasoning = self.train_mode == "latent"
+        self.use_prompt_tuning = self.train_mode == "prompt_tuning"
+        self.use_lora_r16 = self.train_mode == "lora_r16"
+        self.use_peft_mode = self.use_lora_r16
+
+    @classmethod
+    def from_env(cls) -> "TrainingConfig":
+        """Construct a ``TrainingConfig`` by reading environment variables."""
+        lora_modules_raw = os.getenv(
+            "LORA_TARGET_MODULES",
+            "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj",
+        )
+        lora_target_modules = [x.strip() for x in lora_modules_raw.split(",") if x.strip()]
+
+        train_mode = normalize_train_mode(os.getenv("TRAIN_MODE", "latent"))
+        default_dataset = "openslr/librispeech_asr"
+        default_config = "clean"
+        if train_mode == "latent":
+            default_dataset = "SpeechTest/extreme_asr_pony"
+            default_config = "default"
+
+        return cls(
+            model_id=os.getenv("MODEL_ID", "Qwen/Qwen3-ASR-0.6B"),
+            dataset_name=os.getenv("DATASET_NAME", default_dataset),
+            dataset_config=os.getenv("DATASET_CONFIG", default_config),
+            batch_size=int(os.getenv("BATCH_SIZE", "4")),
+            grad_accum_steps=int(os.getenv("GRAD_ACCUM_STEPS", "4")),
+            num_epochs=int(os.getenv("NUM_EPOCHS", "10")),
+            eval_samples=int(os.getenv("EVAL_SAMPLES", "1000")),
+            pretrain_eval_samples=int(os.getenv("PRETRAIN_EVAL_SAMPLES", "10")),
+            n_latent=int(os.getenv("N_LATENT", "4")),
+            is_deq_train=os.getenv("IS_DEQ_TRAIN", "true").strip().lower() == "true",
+            deq_train_iters=int(os.getenv("DEQ_TRAIN_ITERS", "15")),
+            halt_threshold=float(os.getenv("HALT_THRESHOLD", "0.0")),
+            latent_drop_prob=float(os.getenv("LATENT_DROP_PROB", "0.15")),
+            latent_input_noise_std=float(os.getenv("LATENT_INPUT_NOISE_STD", "0.5")),
+            value_forced_neg_prob=float(os.getenv("VALUE_FORCED_NEG_PROB", "0.3")),
+            latent_use_bounded_delta=env_flag("LATENT_USE_BOUNDED_DELTA", True),
+            latent_use_injection_gate=env_flag("LATENT_USE_INJECTION_GATE", True),
+            latent_use_embedding_anchor=env_flag("LATENT_USE_EMBEDDING_ANCHOR", True),
+            train_max_samples=int(os.getenv("TRAIN_MAX_SAMPLES", "0")),
+            checkpoint_prefix=os.getenv("CHECKPOINT_PREFIX", "").strip(),
+            thought_mode=os.getenv("THOUGHT_MODE", "prefix").strip().lower(),
+            thought_group_size=int(os.getenv("THOUGHT_GROUP_SIZE", "1")),
+            train_mode=train_mode,
+            lr_adapter=float(os.getenv("LR_ADAPTER", "1e-4")),
+            lr_scale=float(os.getenv("LR_SCALE", "5e-5")),
+            lr_baseline_ft=float(os.getenv("LR_BASELINE_FT", "1e-5")),
+            lr_prompt_tuning=float(os.getenv("LR_PROMPT_TUNING", "5e-4")),
+            lr_lora_r16=float(os.getenv("LR_LORA_R16", "1e-4")),
+            user_prompt_text=os.getenv(
+                "USER_PROMPT_TEXT", "Transcribe the audio into text."
+            ).strip(),
+            prompt_tuning_init_mode=os.getenv("PROMPT_TUNING_INIT_MODE", "text").strip().lower(),
+            prompt_tuning_num_virtual_tokens=int(
+                os.getenv("PROMPT_TUNING_NUM_VIRTUAL_TOKENS", "4")
+            ),
+            prompt_tuning_init_text=os.getenv(
+                "PROMPT_TUNING_INIT_TEXT", "Transcribe the audio into text."
+            ).strip(),
+            lora_rank=int(os.getenv("LORA_RANK", "16")),
+            lora_alpha=int(os.getenv("LORA_ALPHA", "32")),
+            lora_dropout=float(os.getenv("LORA_DROPOUT", "0.05")),
+            lora_target_modules=lora_target_modules,
+            delta_tanh_c=float(os.getenv("DELTA_TANH_C", "5.0")),
+            scale_max=float(os.getenv("SCALE_MAX", "3.0")),
+            scale_init=float(os.getenv("SCALE_INIT", "0.2")),
+            w_smooth=float(os.getenv("W_SMOOTH", "0.0")),
+            w_cycle=float(os.getenv("W_CYCLE", "0.1")),
+            w_value=float(os.getenv("W_VALUE", "3.0")),
+            log_every=int(os.getenv("LOG_EVERY", "50")),
+            grad_log_every=int(os.getenv("GRAD_LOG_EVERY", "50")),
+        )
+
+
+_config: Optional[TrainingConfig] = None
+
+
+def get_config() -> TrainingConfig:
+    """Return the process-wide ``TrainingConfig`` singleton (lazy init from env)."""
+    global _config
+    if _config is None:
+        _config = TrainingConfig.from_env()
+    return _config

data.py

@@ -0,0 +1,258 @@
+"""Dataset preparation and collation for lr_whisper."""
+
+import numpy as np
+from typing import Any, Dict, List, Optional
+
+import torch
+
+
+# ---------------------------------------------------------------------------
+# Audio token sequence helpers
+# ---------------------------------------------------------------------------
+
+def build_audio_token_seq(
+    audio_bos_id: int,
+    audio_token_id: int,
+    audio_eos_id: int,
+    l_audio: int,
+    device: torch.device,
+) -> torch.Tensor:
+    """Build ``[<|audio_start|>, <audio_pad>×L, <|audio_end|>]`` token tensor.
+
+    Args:
+        audio_bos_id: Token id for ``<|audio_start|>``.
+        audio_token_id: Token id for the audio placeholder (repeated L times).
+        audio_eos_id: Token id for ``<|audio_end|>``.
+        l_audio: Number of audio placeholder tokens.
+        device: Target device.
+
+    Returns:
+        1-D LongTensor of length ``l_audio + 2``.
+    """
+    audio_bos = torch.tensor([audio_bos_id], dtype=torch.long, device=device)
+    audio_eos = torch.tensor([audio_eos_id], dtype=torch.long, device=device)
+    audio_pads = torch.full((l_audio,), audio_token_id, dtype=torch.long, device=device)
+    return torch.cat([audio_bos, audio_pads, audio_eos])
+
+
+def _coerce_feat_attention_mask(
+    mask: Any,
+    target_len: int,
+) -> torch.Tensor:
+    """Coerce a feature-attention mask to a LongTensor of length *target_len*.
+
+    Pads with zeros or truncates as needed.
+
+    Args:
+        mask: A list, numpy array, or Tensor representing the mask.
+        target_len: Required length.
+
+    Returns:
+        1-D LongTensor of length ``target_len``.
+    """
+    if not isinstance(mask, torch.Tensor):
+        mask = torch.tensor(mask, dtype=torch.long)
+    mask = mask.long()
+    cur = mask.size(-1)
+    if cur < target_len:
+        mask = torch.cat([mask, torch.zeros(target_len - cur, dtype=torch.long)])
+    elif cur > target_len:
+        mask = mask[:target_len]
+    return mask
+
+
+# ---------------------------------------------------------------------------
+# Dataset preparation
+# ---------------------------------------------------------------------------
+
+def prepare_dataset(
+    processor: Any,
+    lang_id: int,
+    transcribe_id: int,
+    nt_id: Optional[int],
+    n_latent: int,
+    batch: Dict[str, Any],
+    thought_mode: str = "prefix",
+    thought_group_size: int = 1,
+    language: str = "English",
+) -> Dict[str, Any]:
+    """Prepare a single sample for training.
+
+    This helper converts raw audio and text into model inputs and labels.  The
+    audio waveform is passed through the processor's feature extractor and
+    encoded into log-Mel features.  The transcript text is tokenised without
+    special tokens.
+
+    Labels use Qwen Chat Template format to be compatible with the pre-trained
+    model.  Two layout modes are supported:
+
+    Prefix mode (default)::
+
+        <|im_start|>assistant\\n[NT*N]transcription<|im_end|>
+
+    Interleaved mode (``thought_mode="interleaved"``)::
+
+        <|im_start|>assistant\\n[NT][word1][NT][word2]...<|im_end|>
+
+    In interleaved mode, one NT token is placed before each group of
+    ``thought_group_size`` word tokens.  NT positions are masked in the model's
+    labels so no CE loss is computed on them.
+
+    The user turn with audio is handled as input in the forward method.
+
+    Args:
+        processor: The Qwen3-ASR processor returned by ``asr_wrapper.processor``.
+        lang_id: Integer token id for ``<|im_start|>``.
+        transcribe_id: Unused (kept for API compatibility).
+        nt_id: Integer token id for the latent "NT" token.
+        n_latent: Number of latent tokens to prepend (prefix mode only).
+        batch: A dictionary with keys ``audio`` and ``text`` as provided by
+            ``load_dataset``.
+        thought_mode: ``"prefix"`` (default) or ``"interleaved"``.
+        thought_group_size: Words per NT token in interleaved mode (default 1).
+
+    Returns:
+        A dictionary containing the input features, decoder labels and
+        reference text.
+    """
+    audio = batch["audio"]
+    feat_out = processor.feature_extractor(
+        audio["array"], sampling_rate=audio["sampling_rate"],
+        return_attention_mask=True,
+    )
+    feats = feat_out.input_features[0]
+    if hasattr(feat_out, "attention_mask") and feat_out.attention_mask is not None:
+        feat_attention_mask = feat_out.attention_mask[0]
+    else:
+        feat_attention_mask = [1] * len(feats[0]) if hasattr(feats, "__len__") else None
+
+    raw_text = batch["text"].strip()
+    if raw_text:
+        fmt_text = raw_text.capitalize()
+        # Add a period if it doesn't have one to match base model grammar
+        if not fmt_text.endswith((".", "!", "?")):
+            fmt_text += "."
+    else:
+        fmt_text = ""
+
+    text_ids = processor.tokenizer(fmt_text, add_special_tokens=False).input_ids
+
+    im_start = lang_id
+    _im_end_token = "<|im_end|>"
+    im_end = processor.tokenizer.convert_tokens_to_ids(_im_end_token)
+    if im_end is None or im_end == processor.tokenizer.unk_token_id:
+        im_end = processor.tokenizer.eos_token_id
+
+    # Original: asst_nl = processor.tokenizer.encode("assistant\n", add_special_tokens=False)
+    # if not asst_nl:
+    #     raise ValueError("Tokenizer returned empty ids for 'assistant\\n'.")
+
+    # New construction for asst_nl to include language formatting
+    asst = processor.tokenizer.encode("assistant", add_special_tokens=False)
+    nl = processor.tokenizer.encode("\n", add_special_tokens=False)
+    if not asst or not nl:
+        raise ValueError("Tokenizer returned empty ids for 'assistant' or '\\n'.")
+    asr_prefix_ids = processor.tokenizer.encode(f"language {language}<asr_text>", add_special_tokens=False)
+    asst_nl_prefix = asst + nl + asr_prefix_ids
+
+    # For labels, we mask the prefix part including `asst_nl`
+    # Let's verify `nt_id` logic.
+    interleaved = (thought_mode == "interleaved")
+    if interleaved:
+        # Interleave: [NT, tok1, NT, tok2, ...] with one NT per thought_group_size words.
+        if nt_id is None or nt_id < 0:
+            raise ValueError("interleaved thought_mode requires a valid nt_id.")
+        group = max(1, int(thought_group_size))
+        # Build interleaved sequence
+        num_toks = len(text_ids)
+        num_groups = (num_toks + group - 1) // group
+        actual_nt = min(n_latent, num_groups) # Use n_latent as max NTs
+
+        interleaved_body: List[int] = []
+        for i, tok in enumerate(text_ids):
+            if i % group == 0 and (i // group) < actual_nt:
+                interleaved_body.append(nt_id)
+            interleaved_body.append(tok)
+        body = interleaved_body
+    else:
+        # Prefix mode: [NT*N, tok1, tok2, ...]
+        latent_tokens: List[int] = []
+        if n_latent > 0:
+            if nt_id is None or nt_id < 0:
+                raise ValueError("n_latent > 0 requires a valid nt_id.")
+            latent_tokens = [nt_id] * int(n_latent)
+        body = latent_tokens + text_ids
+
+    labels: List[int] = [im_start] + asst_nl_prefix + body + [im_end]
+    if labels[-1] != im_end:
+        raise ValueError("Label sequence must end with <|im_end|>.")
+
+    result: Dict[str, Any] = {
+        "input_features": feats,
+        "labels": labels,
+        "reference_text": fmt_text, # evaluate on formatted text to allow cleaner debug
+    }
+    if feat_attention_mask is not None:
+        result["feature_attention_mask"] = feat_attention_mask
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Collation
+# ---------------------------------------------------------------------------
+
+class DataCollatorQwenASR:
+    """Collate function for Qwen-ASR latent finetuning.
+
+    This collator pads the list of input feature arrays into a batch tensor and
+    pads the decoder label sequences.  Padding positions in the labels are
+    replaced with ``-100`` so that they are ignored by the cross-entropy loss.
+
+    Args:
+        processor: The Qwen3-ASR processor used for tokenisation and feature
+            extraction.
+    """
+
+    def __init__(self, processor: Any) -> None:
+        self.processor = processor
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
+        # Pad input features
+        input_features = [{"input_features": f["input_features"]} for f in features]
+        batch_inputs = self.processor.feature_extractor.pad(
+            input_features, return_tensors="pt", return_attention_mask=True
+        )
+
+        # Build feature_attention_mask from per-sample masks saved in
+        # prepare_dataset.  The collator's pad() creates an attention_mask
+        # but it's ALL 1s when every sample is pre-padded to 3000 frames.
+        if "feature_attention_mask" in features[0]:
+            max_len = batch_inputs["input_features"].size(-1)
+            masks = []
+            for f in features:
+                m = f["feature_attention_mask"]
+                if hasattr(m, "tolist"):
+                    m = m if isinstance(m, list) else m.tolist()
+                m = list(m) + [0] * (max_len - len(m))
+                masks.append(m[:max_len])
+            feature_attention_mask = torch.tensor(masks, dtype=torch.long)
+        else:
+            feature_attention_mask = batch_inputs["attention_mask"]
+
+        # Pad labels using the tokenizer
+        label_features = [{"input_ids": f["labels"]} for f in features]
+        labels_batch = self.processor.tokenizer.pad(
+            label_features,
+            padding=True,
+            return_tensors="pt",
+            return_attention_mask=True,
+        )
+        labels = labels_batch["input_ids"]
+        attn = labels_batch["attention_mask"]
+        labels = labels.masked_fill(attn.eq(0), -100)
+
+        return {
+            "input_features": batch_inputs["input_features"],
+            "feature_attention_mask": feature_attention_mask,
+            "labels": labels,
+        }

docs/HUGGINGFACE.md

@@ -0,0 +1,38 @@
+# Hugging Face Release
+
+The public model repo is intended to be:
+
+```text
+voidful/latentASR
+```
+
+The repository hosts:
+
+- LatentASR code
+- adapter checkpoint
+- documentation
+- model card
+- reproducibility outputs
+
+## Upload
+
+From this project root:
+
+```bash
+python hf_upload/upload_to_hf.py --repo-id voidful/latentASR
+```
+
+The script creates the model repo if needed and uploads the current folder.
+
+## Download Checkpoint Programmatically
+
+```python
+from huggingface_hub import hf_hub_download
+
+ckpt = hf_hub_download(
+    repo_id="voidful/latentASR",
+    filename="checkpoints/latentASR_adapter.pth",
+)
+print(ckpt)
+```
+

docs/METHOD.md

@@ -0,0 +1,77 @@
+# Method
+
+LatentASR adds continuous latent test-time scaling to a frozen ASR backbone.
+The implementation wraps `Qwen/Qwen3-ASR-0.6B` with two lightweight modules:
+
+- **Latent Adapter**: converts decoder hidden states into bounded latent
+  deltas.
+- **Value Head**: predicts whether additional latent compute is useful and
+  enables dynamic halting.
+
+## Prefix Layout
+
+The default layout is prefix mode:
+
+```text
+system/user/audio prompt
+assistant language <asr_text>
+<|latent|> <|latent|> <|latent|> <|latent|>
+transcript tokens
+```
+
+Transcript loss masks all prompt and latent positions.
+
+## Stable Injection
+
+Each latent delta is stabilized by three mechanisms:
+
+1. **Bounded delta**: `delta_proj(h_k)` is L2-normalized and scaled by a
+   learned per-step scalar.
+2. **Sigmoid gate**: a zero-initialized gate starts at `0.5` and learns how
+   much of the delta to apply.
+3. **Fixed embedding anchor**: the injected vector is
+   `embedding(<|latent|>) + gate * delta`, keeping the input near a real token
+   embedding.
+
+These mechanisms correspond to the ablation flags:
+
+```bash
+LATENT_USE_BOUNDED_DELTA=1
+LATENT_USE_INJECTION_GATE=1
+LATENT_USE_EMBEDDING_ANCHOR=1
+```
+
+## Value Head Target
+
+For each training utterance, the value head predicts the latent-vs-baseline
+accuracy gain. The default target is:
+
+```text
+0.9 * tanh(3.0 * (latent_accuracy - baseline_accuracy))
+```
+
+If both baseline and latent accuracies are zero for an utterance, the target
+uses a clamped CE-difference fallback:
+
+```text
+0.9 * tanh(0.5 * clamp(baseline_ce - latent_ce, -2, 2))
+```
+
+With probability `VALUE_FORCED_NEG_PROB=0.3` per minibatch, the target is
+flipped to `-|target|` for conservative calibration.
+
+The current implementation supervises the value prediction at every produced
+latent state, matching the fact that inference can halt after any step.
+
+## Dynamic Halting
+
+At inference time:
+
+1. The initial value prediction gates the whole loop.
+2. If `v_0 < theta`, all latent tokens are removed and generation falls back to
+   the frozen baseline.
+3. After each latent step, the value head is re-evaluated.
+4. If `v_k < theta`, unused latent tokens are removed before decoding.
+
+The paper uses `theta=0.0` for the deployed setting.
+

docs/REPRODUCIBILITY.md

@@ -0,0 +1,107 @@
+# Reproducibility
+
+This document describes how to run the released code and adapter checkpoint.
+
+## Environment
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+Recommended runtime:
+
+- Python 3.10+
+- CUDA GPU with bfloat16 support for practical speed
+- `qwen-asr>=0.0.6`
+
+## Released Adapter
+
+The released checkpoint is:
+
+```text
+checkpoints/latentASR_adapter.pth
+```
+
+It was copied from:
+
+```text
+activation_500_epoch10.pth
+```
+
+Metadata:
+
+- Base model: `Qwen/Qwen3-ASR-0.6B`
+- Latent budget: `N=4`
+- Activation size: 500 utterances
+- Adapter parameters: 5,251,077
+- SHA256: `f0ce39fa5e6952fced6992508f3e2b32ea8467442b545678781a0f04e64f2430`
+
+## Main Evaluation
+
+FLEURS English:
+
+```bash
+python eval.py \
+  --model-id Qwen/Qwen3-ASR-0.6B \
+  --dataset-name google/fleurs \
+  --configs en_us \
+  --split test \
+  --latent-ckpt checkpoints/latentASR_adapter.pth \
+  --dynamic-halt-threshold 0.0 \
+  --max-samples-per-config 0 \
+  --skip-baseline-ft \
+  --skip-prompt-tuning \
+  --skip-lora-r16 \
+  --output-json eval_runs/fleurs_en_us.json
+```
+
+VoxPopuli English:
+
+```bash
+python eval.py \
+  --model-id Qwen/Qwen3-ASR-0.6B \
+  --dataset-name facebook/voxpopuli \
+  --configs en \
+  --split test \
+  --latent-ckpt checkpoints/latentASR_adapter.pth \
+  --dynamic-halt-threshold 0.0 \
+  --max-samples-per-config 0 \
+  --skip-baseline-ft \
+  --skip-prompt-tuning \
+  --skip-lora-r16 \
+  --output-json eval_runs/voxpopuli_en.json
+```
+
+## Threshold Sweep
+
+```bash
+LATENT_CKPT=checkpoints/latentASR_adapter.pth \
+./experiments/run_threshold_sweep.sh
+```
+
+## Minimal-Data Activation Training
+
+```bash
+TRAIN_MODE=latent \
+N_LATENT=4 \
+TRAIN_MAX_SAMPLES=500 \
+BATCH_SIZE=4 \
+GRAD_ACCUM_STEPS=4 \
+NUM_EPOCHS=10 \
+python train.py
+```
+
+The sequential comparison runner defaults to the paper-aligned protocol:
+
+```bash
+./experiments/run_all_training_modes.sh
+```
+
+## Notes
+
+- The clean benchmark improvements are small single-run point estimates.
+- The ASCEND diagnostic is overlap-confounded and should not be treated as
+  speaker-independent generalization evidence.
+- Results in `results/` are included for transparency and summarization, not as
+  a substitute for rerunning evaluation in your environment.
+

docs/RESULTS.md

@@ -0,0 +1,54 @@
+# Results
+
+This release includes JSON and Markdown outputs under `results/`. The most
+important caveat is that the clean benchmark gains are single-run directional
+point estimates, not statistically established improvements.
+
+## Clean Main Benchmarks
+
+| Model | FLEURS WER | VoxPopuli WER |
+| --- | ---: | ---: |
+| Frozen Qwen3-ASR baseline | 4.900 | 9.038 |
+| LatentASR, N=4, theta=0 | 4.776 | 8.995 |
+
+Relative WER deltas:
+
+- FLEURS: `-2.54%`
+- VoxPopuli: `-0.47%`
+
+## Robustness Diagnostics
+
+At SNR `0` dB:
+
+| Dataset | Baseline WER | LatentASR WER | Relative delta |
+| --- | ---: | ---: | ---: |
+| FLEURS | 29.81 | 29.42 | -1.32% |
+| VoxPopuli | 19.71 | 19.51 | -1.02% |
+
+Stress broad suite weighted aggregate:
+
+- Baseline WER: `36.843`
+- LatentASR WER: `36.265`
+- Delta: `-0.578` pp (`-1.57%` relative)
+
+## ASCEND Diagnostic
+
+ASCEND CER:
+
+- Baseline: `57.81`
+- LatentASR: `48.55`
+- Relative CER delta: `-16.02%`
+
+This is explicitly treated as an overlap-confounded in-domain diagnostic.
+ASCEND contributes 5/500 activation utterances and speaker-disjointness was not
+enforced.
+
+## Included Result Folders
+
+- `results/paper500_main_eval_20260518/`
+- `results/paper500_english_clean_noise_20260518/`
+- `results/paper500_multilingual_streaming_20260518/`
+- `results/paper500_threshold_20260518/`
+- `results/paper500_more_testing_stress_20260525/`
+- `results/paper500_ascend_20260518/`
+

docs/paper_latentasr_activation500_updated.tex

@@ -0,0 +1,453 @@
+\documentclass[a4paper]{article}
+\usepackage{ISCSLP2026}
+\usepackage{iftex}
+\ifPDFTeX\else
+  \usepackage{fontspec}
+  \setmainfont{TeX Gyre Termes}
+  \setmonofont{TeX Gyre Cursor}
+\fi
+\usepackage{ifthen}
+\newboolean{blind}
+\setboolean{blind}{true}
+
+%==================================================================================
+% Packages
+\usepackage{cite}
+\usepackage{amsmath,amssymb,amsfonts}
+\usepackage{graphicx}
+\usepackage{textcomp}
+\usepackage{xcolor}
+\usepackage{booktabs}
+\usepackage{bm}
+\usepackage{multirow}
+\usepackage{tikz}
+\usetikzlibrary{positioning, arrows.meta, fit, backgrounds, calc, decorations.pathreplacing}
+\usepackage{pgfplots}
+\pgfplotsset{compat=1.18}
+\usepackage{comment}
+
+%==================================================================================
+% Custom commands
+\newcommand{\method}{LatentASR}
+\newcommand{\vdelta}{\boldsymbol{\delta}}
+
+%==================================================================================
+% Title and Authors (ISCSLP-style: name/address/email with blind toggle)
+\title{Listen, Think, Transcribe: Continuous Latent Test-Time Scaling for ASR}
+
+\name{
+	\ifthenelse{\boolean{blind}}{Anonymous to ISCSLP}
+	{Name$^1$, Co-author Name$^2$}
+}
+
+\address{
+  \ifthenelse{\boolean{blind}}{Anonymous to ISCSLP}
+  {
+  	$^1$Author Affiliation\\
+  $^2$Co-author Affiliation
+  }
+}
+
+\email{
+	\ifthenelse{\boolean{blind}}{Anonymous to ISCSLP}
+	{author@university.edu, coauthor@company.com}
+}
+
+\begin{document}
+
+\maketitle
+
+\begin{abstract}
+End-to-end ASR models transcribe in a single pass, leaving no room for the decoder to revisit hard inputs. We propose \emph{LatentASR}, a parameter-efficient method that adds continuous latent test-time scaling to a frozen ASR backbone. Two small trainable modules drive it: a Latent Adapter that iteratively refines a few latent prefix positions through bounded, stabilized updates, and a Value Head that predicts whether extra computation will help and halts the loop early. The Qwen3-ASR-0.6B backbone stays fully frozen, and we train only ${\sim}5.25$M extra parameters. We activate this loop with a deliberately small, diverse 500-utterance training set. Under this minimal-data regime, standard adaptation methods regress: full fine-tuning, LoRA, and prompt tuning each increase WER on the two clean main benchmarks. \method{} instead gives the only negative single-run point estimate on both clean benchmarks, lowering FLEURS WER from $4.900\%$ to $4.776\%$ and VoxPopuli WER from $9.038\%$ to $8.995\%$. These clean-set deltas are small and should be read as directional rather than as statistically established gains. Same-protocol diagnostics on multilingual and noisy stress conditions suggest that the latent loop preserves the frozen backbone while converting fixed per-utterance compute into input-dependent compute. Dynamic halting allocates compute sparsely on clean read speech, skipping $47.0\%$ of FLEURS and $63.0\%$ of VoxPopuli utterances at the entry gate. Our results suggest that a small, carefully chosen activation set can switch on input-dependent latent computation inside a frozen ASR model without adapting, and thereby corrupting, the model itself.
+\end{abstract}
+\noindent\textbf{Index Terms}: automatic speech recognition, latent test-time scaling, continuous thought, parameter-efficient finetuning
+
+\section{Introduction}
+
+End-to-end automatic speech recognition (ASR) models map audio directly to text in a single forward pass~\cite{radford2023robust,peng2025owsm}. This design is simple and effective. However, it forces a single left-to-right decoder to handle acoustic disambiguation, language modeling, and error correction at the same time.
+
+Recent work has shown that allocating extra computation at inference time can substantially improve model performance. This paradigm is broadly known as test-time scaling, and includes explicit chain-of-thought reasoning~\cite{wei2022chain}, parallel sampling, and iterative refinement. Within this line, latent test-time scaling has drawn growing attention. For example, Coconut replaces discrete chain-of-thought tokens with continuous hidden states that are iteratively fed back into the model~\cite{hao2024training}. Quiet-STaR trains models to generate and exploit implicit thoughts to improve next-token prediction~\cite{zelikman2024quiet}. Pause tokens provide extra compute steps without requiring explicit intermediate text~\cite{goyal2024think}. Overall, these findings suggest that latent compute scaling is particularly beneficial on challenging inputs.
+
+Motivated by this, we ask a simple question. Can an ASR decoder benefit from latent test-time scaling before it commits to a transcript?
+
+Applying continuous latent scaling to ASR introduces two challenges absent in standard NLP tasks. First, ASR is a direct transcription task with no intermediate reasoning trajectory to distill, unlike Coconut and Quiet-STaR which rely on explicit chain-of-thought rationales. The model must discover how to use extra latent computation entirely unsupervised. Second, modern ASR backbones are typically kept frozen for efficiency and zero-shot generalization. Standard parameter-efficient methods (LoRA, prompt tuning, prefix tuning) follow this regime~\cite{hu2022lora,lester2021power,li2021prefix}, but recent test-time scaling techniques often fine-tune the entire backbone, which inevitably triggers catastrophic forgetting. Conversely, directly injecting unconstrained continuous states into a frozen backbone causes a geometric mismatch that pushes the decoder out of its native vocabulary distribution and leads to representation collapse.
+
+We propose \method{}, a parameter-efficient method that adds two small trainable modules (a Latent Adapter and a Value Head) to a frozen ASR backbone. The Latent Adapter refines the embeddings of $N$ latent prefix positions through bounded recurrent updates; the Value Head predicts per-utterance utility and halts the loop early. Both modules consume only decoder hidden states; the encoder and decoder weights are never updated.
+
+Our contributions are as follows:
+\begin{itemize}
+    \item We introduce continuous latent test-time scaling into frozen ASR backbones. We propose a soft-gated additive injection strategy that produces bounded updates and constructs scale-invariant compute states without triggering representation collapse. Same-protocol component ablations confirm that the stabilization mechanisms are individually important, with removal costs up to tens of WER points.
+    \item We design a Value Head that predicts per-utterance utility and halts computation when extra steps will not help. At the deployed threshold, dynamic halting uses only $1.20$ average latent steps on FLEURS and $0.70$ on VoxPopuli, while skipping $47.0\%$ and $63.0\%$ of utterances respectively. An ASCEND accented/code-switched diagnostic shows heavier compute allocation. ASCEND accounts for only $5/500$ activation utterances ($1.0\%$), but because speaker-disjointness was not enforced, we still treat this row as an overlap-confounded in-domain diagnostic rather than a headline generalization result.
+    \item We demonstrate \emph{minimal-data activation}: a small training set can \emph{activate} latent test-time scaling on a frozen backbone, while being too small to \emph{adapt} (and thereby corrupt) the backbone itself. An activation-size sweep from 100 to 800 utterances selects the 500-utterance checkpoint used for the main results. This checkpoint gives negative single-run WER point estimates on FLEURS ($-0.124$~pp) and VoxPopuli ($-0.043$~pp), while standard adaptation methods of comparable scale regress; we treat these clean-set deltas as directional and leave statistical confirmation to multi-seed paired testing.
+\end{itemize}
+
+\section{Related Work}
+\label{sec:related}
+
+\textbf{Latent test-time scaling.}\quad Beyond explicit chain-of-thought reasoning~\cite{wei2022chain}, recent work injects \emph{continuous} computation into language models. Coconut~\cite{hao2024training} feeds last-layer hidden states back into the model in place of discrete tokens, allowing reasoning to proceed in a continuous embedding space. Quiet-STaR~\cite{zelikman2024quiet} trains models to generate and exploit implicit thoughts that improve next-token prediction without explicit rationale supervision. Pause tokens~\cite{goyal2024think} insert filler positions that grant the model extra forward compute without producing intermediate text. These methods primarily target language modeling and reasoning benchmarks where intermediate rationales either exist or can be distilled from teacher models. \method{} extends the latent-scaling principle to direct speech-to-text transcription, where the target sequence is the only supervision signal and the backbone must remain frozen to preserve broad acoustic generalization.
+
+\textbf{Adaptive computation.}\quad Spending variable compute per input has a long history. Adaptive Computation Time (ACT)~\cite{graves2016adaptive} learns a halting probability per step inside an RNN, terminating when accumulated halting mass exceeds a threshold. PonderNet~\cite{banino2021pondernet} reformulates this with a probabilistic framework and explicit regularization on the expected pondering steps. Early-exit transformers~\cite{schuster2022confident,xin2020deebert} cut inference cost by exiting at intermediate layers when token-level confidence is high. \method{}'s Value Head sits in this lineage but differs along two axes. First, it operates over a small fixed budget of \emph{latent prefix} positions rather than over network depth or over output sequence length; second, its halting signal is the predicted \emph{latent-vs-baseline accuracy gain}, not a confidence proxy or a learned ponder cost. The signal is therefore directly aligned with the deployment objective (``would extra compute reduce WER?''), rather than a heuristic surrogate.
+
+\textbf{Parameter-efficient adaptation.}\quad LoRA~\cite{hu2022lora}, prompt tuning~\cite{lester2021power}, and prefix tuning~\cite{li2021prefix} keep a backbone frozen while inserting low-rank weight updates or learnable surface prompts. As shown in Table~\ref{tab:main}, under our 500-utterance low-resource regime these gradient-based input or weight perturbations consistently \emph{increase} WER on a strong zero-shot ASR backbone. \method{} differs in two ways. First, it leaves both backbone weights and surface prompts untouched. Second, it does not minimize the input-output discrepancy; it instead introduces additional \emph{computation} along a bounded latent trajectory governed by a learned halting policy.
+
+\textbf{Robust pre-trained ASR.}\quad Foundation ASR models such as Whisper~\cite{radford2023robust}, OWSM~\cite{peng2025owsm}, and Qwen-ASR~\cite{yang2024qwen2audio} achieve strong zero-shot transcription via massive multilingual pre-training. Their generalization, however, is brittle: even small downstream gradient updates can erase it (Section~\ref{sec:exp_setup}). To our knowledge, \method{} is the first method to add a learnable test-time refinement loop on top of such a backbone without modifying any of its parameters, yielding negative clean-set point estimates in a regime where conventional adaptation actively regresses.
+
+\section{Method}
+
+\subsection{Problem Setup}
+\label{sec:setup}
+
+We consider an end-to-end ASR pipeline with a frozen acoustic encoder and a frozen autoregressive text decoder. Given an utterance $a$, the encoder produces acoustic states $\mathbf{Z}=\mathrm{Enc}(a)$, and the decoder generates transcript tokens conditioned on $\mathbf{Z}$ and a text prefix. \method{} keeps both the encoder and the decoder fully frozen and intervenes \emph{only} on the decoder's input prefix: it inserts $N$ \emph{latent positions} between the system prompt and the transcript target. These positions are non-text continuous slots used solely as additional computation context; no transcript token is emitted at them. We use $N$ both as the number of latent positions and as the maximum number of refinement steps: refinement step $k$ updates the embedding at latent position $k$.
+
+\subsection{Overview}
+
+\method{} adds two small trainable modules to the frozen backbone (Fig.~\ref{fig:arch}): a \textbf{Latent Adapter} that refines the embeddings at the $N$ latent positions through a bounded recurrent loop, and a \textbf{Value Head} that decides how many of those refinement steps to actually run. Both modules consume only decoder hidden states; neither modifies the backbone or the encoder. One difficulty drives the whole design. Feeding an arbitrary continuous vector into a frozen decoder pushes its input off the distribution seen during pre-training and quickly destabilizes it. The Latent Adapter therefore does not inject free vectors; it produces small, bounded, gated updates around a fixed anchor embedding, controlled by three stabilization mechanisms that we detail in Section~\ref{sec:stability}. Sections~\ref{sec:refinement}--\ref{sec:valuehead} describe each component in turn.
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=\columnwidth]{latentASR.png}
+\caption{Architecture of \method{}. The ASR backbone (blue) remains \textbf{frozen}. We add a trainable \textbf{Latent Adapter} (orange) that forms a recurrent compute loop. At step $k$, it maps the decoder hidden state at latent position $k$ to a bounded update $\vdelta_k$ that is added to the latent embedding via a sigmoid gate. A \textbf{Value Head} (diamond) reads each latent state to predict a utility score $v_k$, enabling the model to halt dynamically when further computation is unnecessary.}
+\label{fig:arch}
+\end{figure}
+
+\subsection{Latent Prefix Refinement}
+\label{sec:refinement}
+
+The Latent Adapter computes a bounded update at each refinement step. Let $\mathbf{h}_0$ denote the decoder's last-layer hidden state at the final latent position before any refinement (the \emph{acoustic anchor}); we $L_2$-normalize it before downstream use so the loop starts from a unit-magnitude state. At refinement step $k\in\{1,\dots,N\}$, the frozen decoder reads $\mathbf{Z}$ and the current latent prefix; we extract the last-layer hidden state $\mathbf{h}_k$ at latent position $k$. The adapter, time-conditioned by a learned step embedding $\mathbf{e}_k$, projects $\mathbf{h}_k$ into the embedding space, $L_2$-normalizes the projection, and rescales by a learned scalar $s_k$ to produce a step-bounded delta:
+\begin{equation}
+    \vdelta_k = s_k \cdot \frac{\text{DeltaProj}(\mathbf{h}_k)}{\lVert\text{DeltaProj}(\mathbf{h}_k)\rVert + \epsilon}, \quad \epsilon{=}10^{-6}.
+    \label{eq:delta}
+\end{equation}
+The $L_2$-normalization makes the update direction scale-invariant; the per-step scale $s_k$ controls how far each step moves.
+
+\subsection{Stable Injection into a Frozen Decoder}
+\label{sec:injection}
+\label{sec:stability}
+
+A frozen decoder only interprets inputs that resemble the token embeddings it saw during pre-training. Injecting an arbitrary continuous vector pushes the input off this embedding manifold and destabilizes the decoder. \method{} keeps the injection on-manifold by constraining three distinct properties of the update: how far each step moves the state, whether the step is applied, and where the resulting embedding sits.
+
+\begin{itemize}
+    \item \textbf{Bounded delta.} The per-step scale $s_k$ and the $L_2$-normalization in Eq.~\ref{eq:delta} bound the magnitude of every update, so no single step can grow without limit.
+    \item \textbf{Sigmoid gate.} A learned gate decides how much of each update to apply:
+    \begin{equation}
+        g_k = \sigma\big(\mathbf{W}_g [\mathbf{e}_{\texttt{LT}}; \vdelta_k]\big),
+        \label{eq:gate}
+    \end{equation}
+    with $\mathbf{W}_g$ zero-initialized so $g_k{=}0.5$ at the start of training.
+    \item \textbf{Fixed-embedding anchor.} Every latent position is anchored to the same fixed token embedding $\mathbf{e}_{\texttt{LT}}$ and modified only by an additive residual,
+    \begin{equation}
+        \mathbf{x}_k = \mathbf{e}_{\texttt{LT}} + g_k \cdot \vdelta_k,
+        \label{eq:inject}
+    \end{equation}
+    so the injected embedding stays in a small ball around a real vocabulary embedding the decoder already interprets.
+\end{itemize}
+
+Together, Eqs.~\ref{eq:delta}--\ref{eq:inject} form a gated residual around a fixed anchor. Closing the gate recovers $\mathbf{e}_{\texttt{LT}}$ exactly, so the adapter only learns a small, optionally-zero correction rather than a full continuous input from scratch.
+
+\subsection{Utility Prediction and Dynamic Halting}
+\label{sec:valuehead}
+
+Latent scaling reliably helps some utterances and merely costs compute on others. We therefore need a per-utterance gate that predicts, before any compute is spent, whether further latent steps will help. The Value Head plays this role.
+
+\textbf{Design rationale.}\quad The signal we want is ``would extra latent compute help this utterance?'', which is most directly answered by comparing the latent path against the frozen baseline on the same training utterance, a self-distilled target whose value is the latent-vs-baseline accuracy gain $\Delta$ on supervised transcript positions. As the latent path improves during training, $\Delta$ can become positive on most utterances; we therefore expose a forced-negative sampling knob $p_{\text{neg}}$ that, with probability $p_{\text{neg}}$ per minibatch, flips $y \leftarrow -|y|$, providing a tunable counterweight against this drift. We default to $p_{\text{neg}}{=}0.3$. When both baseline and latent token accuracies are zero for an utterance, we replace the accuracy target for that utterance with a clamped cross-entropy-difference fallback.
+
+\textbf{Implementation.}\quad The Value Head is a single linear layer over each latent hidden state, $v_k = \tanh(\text{ValueHead}(\mathbf{h}_k)) \in [-1, 1]$, so larger $v_k$ predicts a more negative $\Delta$WER. On non-degenerate utterances the target is the tanh-squashed accuracy gain
+\begin{equation}
+    y = \alpha \cdot \tanh(\gamma \cdot \Delta),
+    \label{eq:value_target}
+\end{equation}
+with $\alpha{=}0.9$ and $\gamma{=}3.0$.
+
+\textbf{Two-stage halting at inference.}\quad $v_0$ on the initial anchor gates the entire loop: if $v_0 < \theta$, all $N$ steps are skipped and the utterance falls back to the frozen Baseline. Otherwise, after each step $k\geq 1$, we re-evaluate $v_k$ and break if it drops below $\theta$. Latent compute is thus allocated only to utterances the Value Head predicts will benefit.
+
+\subsection{Training}
+\label{sec:training}
+
+Three losses train the adapter and Value Head while the backbone stays frozen:
+\begin{equation}
+    \mathcal{L} = \mathcal{L}_{\text{CE}} + w_{\text{cyc}}(t) \cdot \mathcal{L}_{\text{cyc}} + w_{\text{val}} \cdot \mathcal{L}_{\text{val}}.
+    \label{eq:loss_total}
+\end{equation}
+$\mathcal{L}_{\text{CE}}$ is cross-entropy on the transcript tokens (latent positions are masked out). $\mathcal{L}_{\text{val}}$ is the mean-squared error between the Value Head output at each produced latent state and the target in Eq.~\ref{eq:value_target}. $\mathcal{L}_{\text{cyc}}$ is a trajectory regularizer
+\begin{equation}
+\mathcal{L}_{\text{cyc}} = \tfrac{\beta}{N}\!\sum_{k=1}^{N}\!\lVert\mathbf{h}_k {-} \mathbf{h}_0\rVert_2^2 + \tfrac{1{-}\beta}{N{-}1}\!\sum_{k=1}^{N-1}\!\lVert\mathbf{h}_{k+1} {-} \mathbf{h}_k\rVert_2^2,
+\label{eq:loss_cyc}
+\end{equation}
+that anchors the latent trajectory near $\mathbf{h}_0$ and damps abrupt step-to-step jumps, with $\beta{=}0.3$ favoring smooth refinement over rigid attachment. The cycle weight $w_{\text{cyc}}(t)$ decays linearly to zero. To prevent over-reliance on the latent path, we additionally drop the entire latent loop with probability $p_{\text{drop}}$ during training and add Gaussian noise of std $\sigma$ to the initial anchor.
+
+\section{Experiments}
+\subsection{Experiment Setup}
+\label{sec:exp_setup}
+
+\textbf{Training Setup.}\quad We use Qwen3-ASR-0.6B~\cite{yang2024qwen2audio} as the base model and keep all its parameters frozen. We train for 10 epochs with effective batch size $16$ on a single NVIDIA RTX 5090. We set $N{=}4$ and use AdamW with decoupled learning rates: $10^{-4}$ for the Latent Adapter and Value Head, and $5 \times 10^{-5}$ for step scales (initialized at $0.2$, capped at $3.0$). We use $w_{\text{cyc}}{=}0.1$ (linearly decayed), $w_{\text{val}}{=}3.0$, $p_{\text{drop}}{=}0.15$, input noise $\sigma{=}0.5$, and $p_{\text{neg}}{=}0.3$. With this configuration, the trainable components add only $\sim 5.25\text{M}$ parameters.
+
+\textbf{Dataset: Minimal-Data Activation.}\quad We construct a 500-utterance training mixture from seven ASR corpora. The mixture is dominated by Common Voice 16.0~\cite{commonvoice:2020}, supplemented by FLEURS~\cite{fleurs2022arxiv} and VoxPopuli~\cite{wang-etal-2021-voxpopuli}, and regularized with challenging tail samples from LibriSpeech~\cite{panayotov2015librispeech}, GigaSpeech~\cite{GigaSpeech2021}, The People's Speech~\cite{DBLP:journals/corr/abs-2111-09344}, and ASCEND~\cite{lovenia2022ascend}. It is strongly multilingual, covering 100+ language codes and intentionally including fragmented English dialect tags. We refer to this principle as \emph{minimal-data activation}: the small, varied training set is enough to activate latent test-time scaling, but too small to adapt the frozen backbone off its pre-trained manifold. We evaluate on the standardized FLEURS (\texttt{en\_us}) test set and VoxPopuli (\texttt{en}). \emph{Disclosure.} The 500-utterance activation set is sampled from an 811-utterance mixture with seed 42. Its corpus counts are 350 Common Voice, 77 FLEURS, 52 VoxPopuli, 8 LibriSpeech, 5 ASCEND, 4 People's Speech, and 4 GigaSpeech utterances. Thus ASCEND contributes only $5/500$ activation utterances ($1.0\%$). However, ASCEND and FLEURS/VoxPopuli each contribute to both the activation mixture (drawn from training splits) and held-out test conditions (standardized test splits), and we did not enforce speaker-disjointness between train and test. For this reason, ASCEND is not used as a headline generalization result; it is reported only as an overlap-confounded diagnostic of accented/code-switched behavior. A leave-ASCEND-out activation run is required before making a cross-domain claim on ASCEND.
+
+\textbf{Baselines and checkpoint selection.}\quad We benchmark \method{} against the frozen Qwen3-ASR-0.6B baseline, full fine-tuning, LoRA~\cite{hu2022lora} (rank 16), and prompt tuning~\cite{lester2021power} (4 soft tokens). All methods are trained for 10 epochs on the same 500-utterance mixture. Full fine-tuning was rerun with micro-batch 4 and gradient accumulation 4 after the larger micro-batch OOMed, preserving effective batch size 16. For the main \method{} row, we use the best 500-utterance $N{=}4$, $\theta{=}0$ checkpoint from the activation-size sweep, \texttt{activation\_500\_epoch10.pth}. Some ablation and cross-domain diagnostics below use independently retrained same-protocol checkpoints; we label these as diagnostics rather than as the canonical main estimate.
+
+\subsection{Main Results}
+\label{sec:main_results}
+
+Table~\ref{tab:main} reports single-run point estimates on FLEURS (\texttt{en\_us}) and VoxPopuli (\texttt{en}). Throughout this paper, all reductions are reported as the relative change in WER (or CER) over the frozen Baseline; \textbf{a negative value indicates a WER reduction (improvement)} and a positive value indicates an increase (regression). Across both test sets, every conventional adaptation method we test increases WER under the 500-utterance training regime. LoRA regresses by $+31.97\%$ relative on FLEURS, full fine-tuning by $+13.38\%$, and prompt tuning collapses outright (FLEURS WER rises to $84.803\%$).
+
+In contrast, \method{} is the only tested adaptation mechanism with a negative $\Delta$WER point estimate on both clean benchmarks. On FLEURS, the canonical 500-utterance checkpoint changes WER from $4.900\%$ to $4.776\%$ ($-0.124$~pp, $-2.54\%$ relative). On VoxPopuli, it changes WER from $9.038\%$ to $8.995\%$ ($-0.043$~pp, $-0.47\%$ relative). These absolute deltas are small. Because we do not yet have multi-seed runs or paired confidence intervals for the canonical checkpoint, we do not interpret Table~\ref{tab:main} as evidence of statistically significant clean-benchmark improvement. Its narrower role is to show that, in the same low-resource regime where conventional adaptation clearly regresses, latent test-time computation preserves the frozen backbone and gives a negative directional estimate.
+
+\begin{table}[ht]
+  \caption{Single-run WER and CER point estimates on the FLEURS (\texttt{en\_us}, 647 utts) and VoxPopuli (\texttt{en}, 1{,}842 utts) test splits. \textbf{Rel. $\boldsymbol{\Delta}$WER (\%)} is computed from unrounded WER against the frozen Baseline. Negative = WER reduction (improvement); positive = WER increase (regression). The clean-set \method{} deltas are directional and not claimed statistically significant.}
+  \label{tab:main}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l | c c c | c c c}
+    \toprule
+    \multirow{2}{*}{\textbf{Model}} & \multicolumn{3}{c|}{\textbf{FLEURS}} & \multicolumn{3}{c}{\textbf{VoxPopuli}} \\
+    \cmidrule(lr){2-4} \cmidrule(lr){5-7}
+     & \textbf{WER (\%)} & \textbf{CER (\%)} & \textbf{Rel.\ $\Delta$WER (\%)} & \textbf{WER (\%)} & \textbf{CER (\%)} & \textbf{Rel.\ $\Delta$WER (\%)} \\
+    \midrule
+    Baseline                 & 4.900 & 2.326 & -- & 9.038 & 5.900 & -- \\
+    \quad + Full Fine-Tuning & 5.556 & 2.481 & $+13.38$ & 9.485 & 6.176 & $+4.96$ \\
+    \quad + Prompt Tuning    & 84.803 & 82.468 & $+1630.70$ & 88.507 & 87.901 & $+879.33$ \\
+    \quad + LoRA (rank 16)   & 6.467 & 2.944 & $+31.97$ & 10.212 & 6.536 & $+13.00$ \\
+    \midrule
+    \quad + \method{} ($N{=}4$, $\theta{=}0$) & \textbf{4.776} & \textbf{2.238} & $\boldsymbol{-2.54}$ & \textbf{8.995} & \textbf{5.869} & $\boldsymbol{-0.47}$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\subsection{Multilingual and Cross-Domain Generalization}
+\label{sec:multilingual}
+
+To verify that \method{} preserves the broad multilingual capability of the frozen backbone, we evaluate on a 23{,}049-utterance multilingual benchmark spanning the FLEURS test sets of 30 languages. This suite is a same-protocol diagnostic and is reported to test whether the latent adapter preserves broad multilingual behavior.
+
+\begin{table}[ht]
+  \caption{Multilingual aggregate WER on FLEURS 30 and its resource-tier partitions. Rel.\ $\Delta$WER is computed against the frozen Baseline; negative = WER reduction = improvement.}
+  \label{tab:multilingual_agg}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l r c c c}
+    \toprule
+    \textbf{Subset} & \textbf{\#utts} & \textbf{Baseline WER (\%)} & \textbf{\method{} WER (\%)} & \textbf{Rel.\ $\Delta$WER (\%)} \\
+    \midrule
+    FLEURS 30 (all)         & 23{,}049 & 32.65 & \textbf{32.57} & $-0.23$ \\
+    \quad core12            &  8{,}876 & 31.71 & \textbf{31.63} & $-0.26$ \\
+    \quad +8                &  5{,}597 & 17.48 & \textbf{17.45} & $-0.19$ \\
+    \quad +10               &  8{,}576 & 43.52 & \textbf{43.42} & $-0.23$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\begin{table}[ht]
+  \caption{Per-language results on character-based FLEURS languages. Negative Rel.\ $\Delta$CER = error reduction = improvement.}
+  \label{tab:per_language}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l r c c c}
+    \toprule
+    \textbf{Language (FLEURS code)} & \textbf{\#utts} & \textbf{Baseline CER (\%)} & \textbf{\method{} CER (\%)} & \textbf{Rel.\ $\Delta$CER (\%)} \\
+    \midrule
+    Mandarin (cmn\_hans\_cn)  &   945 & 47.94 & \textbf{47.58} & $-0.75$ \\
+    Cantonese (yue\_hant\_hk) &   819 & 49.20 & \textbf{48.80} & $-0.82$ \\
+    Japanese (ja\_jp)         &   650 & 10.35 & 10.35 & $\phantom{-}0.00$ \\
+    Thai (th\_th)             & 1{,}021 & 9.53 & \textbf{9.41} & $\boldsymbol{-1.31}$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\subsection{Robustness and In-Domain Diagnostics}
+\label{sec:robustness}
+
+We further evaluate same-protocol checkpoints under acoustic shift. Table~\ref{tab:robustness} reports additive Gaussian noise at SNR $=0$~dB on FLEURS and VoxPopuli. It also includes ASCEND, evaluated with CER following~\cite{lovenia2022ascend}, but this row has a different evidential status: ASCEND contributes only $5/500$ activation utterances ($1.0\%$), yet speaker-disjointness was not enforced. The $16.02\%$ relative CER reduction on ASCEND is therefore an overlap-confounded in-domain diagnostic, not a cross-domain or speaker-independent generalization result.
+
+\begin{table}[ht]
+  \caption{Robustness and in-domain diagnostics. Rel.\ $\Delta$ is the relative WER (or CER) change vs.\ the Baseline; negative = error reduction = improvement. ASCEND$^\dagger$ accounts for only $5/500$ activation utterances ($1.0\%$), but remains overlap-confounded because speaker-disjointness was not enforced, so it is not used as headline generalization evidence.}
+  \label{tab:robustness}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l l c c c c}
+    \toprule
+    \textbf{Dataset} & \textbf{Condition} & \textbf{Metric} & \textbf{Baseline (\%)} & \textbf{\method{} (\%)} & \textbf{Rel.\ $\Delta$ (\%)} \\
+    \midrule
+    FLEURS    & SNR$=0$~dB & WER & 29.81 & \textbf{29.42} & $-1.32$ \\
+    VoxPopuli & SNR$=0$~dB & WER & 19.71 & \textbf{19.51} & $-1.02$ \\
+    \midrule
+    ASCEND$^\dagger$ & accented / code-switched & CER & 57.81 & 48.55 & $-16.02$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\begin{table}[ht]
+  \caption{Stress broad suite at SNR$=0$~dB. Weighted aggregate WER drops by $-0.58$~pp ($-1.57\%$ rel).}
+  \label{tab:stress_broad}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l r c c c c}
+    \toprule
+    \textbf{Dataset} & \textbf{\#utts} & \textbf{Baseline WER (\%)} & \textbf{\method{} WER (\%)} & \textbf{$\Delta$WER (pp)} & \textbf{Rel.\ $\Delta$WER (\%)} \\
+    \midrule
+    AMI (IHM+SDM) $0$~dB              &   996 & 77.784 & \textbf{75.518} & $\boldsymbol{-2.266}$ & $\boldsymbol{-2.91}$ \\
+    Common Voice (en) $0$~dB          &   500 & 31.617 & 31.936 & $+0.319$ & $+1.01$ \\
+    GigaSpeech (test) $0$~dB          &   391 & 20.939 & \textbf{20.875} & $-0.064$ & $-0.30$ \\
+    LibriSpeech (clean+other) $0$~dB  & 1{,}000 & 18.471 & 18.584 & $+0.113$ & $+0.61$ \\
+    People's Speech $0$~dB            &   500 & 31.687 & 31.771 & $+0.084$ & $+0.26$ \\
+    TEDLIUM (release 1) $0$~dB        &   500 & 14.849 & \textbf{14.291} & $-0.558$ & $-3.76$ \\
+    \midrule
+    \textbf{Weighted aggregate}       & \textbf{3{,}887} & \textbf{36.843} & \textbf{36.265} & $\boldsymbol{-0.578}$ & $\boldsymbol{-1.57}$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\subsection{Ablation Study}
+\label{sec:ablation}
+
+We ablate the core design choices of \method{}: the dynamic halting policy, the three stabilization mechanisms in Section~\ref{sec:stability}, and the size of the activation set. Unless stated otherwise, ablation tables use independently retrained same-protocol checkpoints; their purpose is to test mechanisms rather than to replace the canonical main estimate in Table~\ref{tab:main}.
+
+\textbf{Compute allocation.}\quad Table~\ref{tab:halt_dist} reports the deployed step distribution. For FLEURS and VoxPopuli, these numbers come from the canonical \texttt{activation\_500\_epoch10.pth} checkpoint. ASCEND is included only as an overlap-confounded same-protocol diagnostic. Its $5/500$ activation share is small, but the absence of speaker-disjoint enforcement means the heavier compute allocation is useful for inspecting the halting policy on accented/code-switched speech, not for claiming independent generalization.
+
+\begin{table}[th]
+  \caption{$N$-step distribution at the deployed setting $\theta{=}0.0$. FLEURS and VoxPopuli use the canonical 500-utterance checkpoint; ASCEND$^\dagger$ is an overlap-confounded same-protocol diagnostic.}
+  \label{tab:halt_dist}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l c r r r r}
+    \toprule
+    \textbf{Dataset} & \textbf{Skip ($\mathbf{N=0}$)} & \textbf{N=1} & \textbf{N=2} & \textbf{N=3} & \textbf{N=4} \\
+    \midrule
+    FLEURS (clean)      & 47.0\% & 24.9\% & 6.3\% & 4.8\% & 17.0\% \\
+    VoxPopuli (clean)   & 63.0\% & 22.0\% & 5.0\% & 2.2\% &  7.8\% \\
+    ASCEND$^\dagger$ (accented) & 22.3\% & 30.3\% & 8.2\% & 5.1\% & 34.1\% \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\textbf{Component Ablation: Stable Injection Mechanisms.}\quad
+Table~\ref{tab:component_ablation} selectively removes each stabilization mechanism in a same-protocol ablation suite. The ablations are independently retrained and demonstrate that the design is not redundant: removing the bounded delta is catastrophic, and removing either the anchor or the gate also causes large regressions.
+
+\begin{table}[th]
+  \caption{Component ablation on the three stabilization mechanisms (FLEURS \texttt{en\_us}, $\theta{=}0.0$). This is an independently retrained same-protocol ablation suite; deltas are against the frozen Baseline in the same evaluation pipeline.}
+  \label{tab:component_ablation}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l c c}
+    \toprule
+    \textbf{Variant} & \textbf{WER (\%)} & \textbf{$\Delta$WER (pp)} \\
+    \midrule
+    Full same-protocol \method{} ($N{=}4$) & \textbf{4.86} & $\boldsymbol{-0.04}$ \\
+    \quad $-$ bounded delta ($L_2$ + scale $s_k$) & 51.75 & $+46.85$ \\
+    \quad $-$ fixed-embedding anchor ($\mathbf{e}_{\texttt{LT}}$ removed) & 16.22 & $+11.33$ \\
+    \quad $-$ sigmoid gate ($g_k$ fixed at $1$) & 7.89 & $+2.99$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\textbf{Activation Set Scaling.}\quad
+Table~\ref{tab:activation_sweep} sweeps the activation-set size from $100$ to $800$ utterances in steps of $100$. The 500-utterance checkpoint is selected as the canonical main checkpoint because it gives the best mean absolute WER delta across FLEURS and VoxPopuli in this sweep. The useful range is narrow: several neighboring sizes are near-neutral or mildly regressive.
+
+\begin{table}[th]
+  \caption{Activation set scaling sweep ($\theta{=}0.0$). $\Delta$ (pp) is the absolute WER change vs.\ the Baseline; \textbf{Mean $\Delta$ (pp)} averages the two benchmarks.}
+  \label{tab:activation_sweep}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{c c c c c c}
+    \toprule
+    \textbf{Activation \#utts} & \textbf{FLEURS WER (\%)} & \textbf{$\Delta$ (pp)} & \textbf{VoxPopuli WER (\%)} & \textbf{$\Delta$ (pp)} & \textbf{Mean $\Delta$ (pp)} \\
+    \midrule
+    100 & 4.87 & $-0.03$ & 8.95 & $-0.08$ & $-0.055$ \\
+    200 & 4.91 & $+0.01$ & 9.01 & $-0.03$ & $-0.010$ \\
+    300 & 4.90 & $\phantom{-}0.00$ & 9.01 & $-0.03$ & $-0.015$ \\
+    400 & 4.91 & $+0.01$ & 9.04 & $\phantom{-}0.00$ & $+0.005$ \\
+    \textbf{500} & \textbf{4.78} & $\boldsymbol{-0.12}$ & 8.99 & $-0.04$ & $\boldsymbol{-0.084}$ \\
+    600 & 4.93 & $+0.03$ & 9.02 & $-0.02$ & $+0.005$ \\
+    700 & 4.82 & $-0.08$ & 9.04 & $\phantom{-}0.00$ & $-0.040$ \\
+    800 & 4.88 & $-0.02$ & 9.07 & $+0.04$ & $+0.010$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\subsection{Analysis}
+\label{sec:analysis}
+
+The aggregate gains are small, so we treat interpretability diagnostics carefully. The main checkpoint improves FLEURS more than VoxPopuli, while the same-protocol VoxPopuli diagnostic run shows the expected hard-tail pattern: improvements concentrate in the hardest quartile and are near-zero or mildly negative in easy bins. This supports a difficulty-conditional reading rather than a uniform accuracy-lift interpretation.
+
+\begin{table}[ht]
+  \caption{Difficulty-binned same-protocol diagnostic on VoxPopuli (\texttt{en}) at $\theta{=}0.0$ ($1{,}842$ utterances total). Utterances are partitioned into Baseline-WER quartiles.}
+  \label{tab:difficulty_bins}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l c c c c c}
+    \toprule
+    \textbf{Bin} & \textbf{\#utts} & \textbf{Baseline WER (\%)} & \textbf{\method{} WER (\%)} & \textbf{$\Delta$WER (pp)} & \textbf{Skip (\%)} \\
+    \midrule
+    Q1 (easiest)  & 460 &  0.00 &  0.06 & $+0.06$ & 51.3 \\
+    Q2            & 461 &  3.03 &  3.03 & $\phantom{-}0.00$ & 63.1 \\
+    Q3            & 460 &  8.93 & \textbf{8.91} & $-0.02$ & 64.3 \\
+    Q4 (hardest)  & 461 & 21.16 & \textbf{20.90} & $\boldsymbol{-0.25}$ & 62.0 \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\begin{table}[ht]
+  \caption{Value Head decision-quality diagnostic on VoxPopuli (\texttt{en}) at $\theta{=}0.0$. Counterfactual $\Delta$WER forces the $N{=}4$ latent path on each subset.}
+  \label{tab:gate_quality}
+  \centering
+  \resizebox{\columnwidth}{!}{
+  \begin{tabular}{l c c c}
+    \toprule
+    \textbf{Subset (at $\theta{=}0.0$)} & \textbf{\#utts} & \textbf{Actual $\Delta$WER (pp)} & \textbf{Counterfactual $\Delta$WER (pp)} \\
+    \midrule
+    Skipped ($v_0 < 0$)      & 1{,}109 & $0.00$ (by construction) & $+0.01$ \\
+    Processed ($v_0 \geq 0$) & 733 & $\boldsymbol{-0.19}$ & $-0.06$ \\
+    \bottomrule
+  \end{tabular}
+  }
+\end{table}
+
+\begin{table}[ht]
+  \caption{Qualitative examples from the VoxPopuli hard-quartile diagnostic. References are shown in lower-case unpunctuated form.}
+  \label{tab:qualitative}
+  \centering
+  \footnotesize
+  \setlength{\tabcolsep}{4pt}
+  \renewcommand{\arraystretch}{1.1}
+  \begin{tabular}{@{}p{0.12\columnwidth} p{0.26\columnwidth} p{0.26\columnwidth} p{0.26\columnwidth}@{}}
+    \toprule
+    \textbf{Source} & \textbf{Reference} & \textbf{Baseline} & \textbf{\method{}} \\
+    \midrule
+    VoxPopuli Q4 & mr president thank you for your patience and indulgence. & Thank you, Mr. President. Thank you for your patience and indulgence. & Mr. President, thank you for your patience and indulgence. \\
+    \midrule
+    VoxPopuli Q4 & madam president i wish to focus my remarks on the european neighbourhood policy in relation to the middle east peace process. & Thank you, Madame President. Commissioner, I wish to focus my remarks on the European neighbourhood policy in relation to the Middle East peace process. & Madam President, I wish to focus my remarks on the European neighbourhood policy in relation to the Middle East peace process. \\
+    \midrule
+    VoxPopuli Q4 & mr president i would like to use this opportunity to say that i withdrew my name from this report. & Thank you, Mr. President. I would like to use the opportunity to say that I withdraw my name from this report. & Mr. President, I would like to use the opportunity to say that I withdraw my name from this report. \\
+    \bottomrule
+  \end{tabular}
+\end{table}
+
+\section{Discussion}
+\label{sec:discussion}
+
+\textbf{Statistical scope.}\quad The clean main-benchmark gains in Table~\ref{tab:main} are below one tenth of a WER point on VoxPopuli and only slightly above one tenth of a point on FLEURS. With a single seed and no paired confidence interval, they are not distinguishable from evaluation noise. We therefore frame them as directional point estimates, not as statistically established improvements. ASCEND has an additional confound: although it accounts for only $5/500$ activation utterances ($1.0\%$), speaker-disjointness was not enforced, so its large CER reduction is not used as headline evidence. The remaining support for \method{} comes from the lower-risk pattern across mechanism diagnostics, noisy stress-suite results, and input-dependent compute allocation.
+
+\textbf{Where the gain comes from.}\quad The canonical main checkpoint reduces WER by $-0.124$~pp on FLEURS and $-0.043$~pp on VoxPopuli. The gains are therefore small in absolute terms, but the compute-allocation profile (Table~\ref{tab:halt_dist}) and the hard-tail diagnostic (Table~\ref{tab:difficulty_bins}) support a difficulty-conditional interpretation. On clean read-speech benchmarks, the Value Head skips roughly half or more of all utterances. The ASCEND row is compatible with this interpretation because it triggers more full-budget computation on accented/code-switched speech, but due to activation/test corpus overlap it should be read only as an in-domain diagnostic.
+
+\textbf{When dynamic halting matters.}\quad Dynamic halting is primarily a compute-allocation mechanism in this regime. At $\theta{=}0.0$, the canonical checkpoint uses $1.20$ average latent steps on FLEURS and $0.70$ on VoxPopuli, well below the full $N{=}4$ budget. This matters because the gain is not uniformly distributed: the model should spend compute where the frozen decoder leaves correctable residual errors and avoid spending it on low-yield utterances.
+
+\textbf{Minimal-data activation is narrow.}\quad The activation-set sweep (Table~\ref{tab:activation_sweep}) shows that the useful operating range is narrow. The 500-utterance checkpoint is best by mean WER delta in the sweep, but nearby settings are close and some larger settings are neutral or mildly regressive. We therefore do not claim monotonic improvement with more activation data. The claim is narrower: under conditions where standard adaptation regresses, a small activation set can produce a negative directional WER point estimate without modifying the backbone.
+
+\textbf{Failure modes and open questions.}\quad Several individual regressions merit explicit discussion. On the stress suite (Table~\ref{tab:stress_broad}), Common Voice, LibriSpeech, and People's Speech at $0$~dB all show small regressions ($\leq +0.32$~pp). This signals that the method is not uniformly beneficial across all difficulty regimes. Future work should replicate the main results with multi-seed statistical testing, rerun all diagnostics from a single frozen canonical checkpoint, and run a leave-ASCEND-out activation with speaker-disjoint evaluation before making any ASCEND generalization claim.
+
+\section{Conclusion}
+\label{sec:conclusion}
+
+We presented \method{}, a parameter-efficient method that adds continuous latent test-time scaling to a frozen ASR backbone. Two small modules, a Latent Adapter that refines a few latent prefix positions through bounded recurrent updates and a Value Head that halts the loop per utterance, add under $1\%$ trainable parameters and leave the backbone untouched. Under a deliberately small activation regime where standard adaptation methods regress, \method{} gives the only negative single-run WER point estimate among the tested methods on both clean main benchmarks, but these clean-set deltas are too small to claim statistical significance without paired multi-seed testing. Same-protocol diagnostics suggest that the method behaves like a difficulty-conditional refinement loop with a learned scheduler. The ASCEND result is intentionally excluded from headline generalization claims because ASCEND contributes to the activation mixture and speaker-disjointness was not enforced.
+
+\bibliographystyle{IEEEtran}
+\bibliography{refs}
+
+\end{document}

eval.py

@@ -0,0 +1,2337 @@
+"""
+Evaluate latent-reasoning and baseline/PEFT ASR models.
+
+Supported datasets:
+  - SpeechTest/common_voice_16_0
+  - SpeechTest/peoples_speech
+  - SpeechTest/librispeech_asr
+  - SpeechTest/fleurs
+  - SpeechTest/voxpopuli
+  - SpeechTest/gigaspeech
+  - SpeechTest/ASCEND
+  - SpeechTest/extreme_asr_pony
+  - openslr/librispeech_asr
+  - google/fleurs
+  - facebook/voxpopuli
+  - PolyAI/minds14
+  - LIUM/tedlium
+  - edinburghcstr/ami
+
+Unknown HuggingFace datasets are also accepted with generic ASR defaults:
+an `audio` column plus one of the fallback text columns.
+
+Example:
+    python eval.py \
+      --baseline-ckpt baseline_qwen_asr_best.pth \
+      --prompt-tuning-ckpt prompt_tuning_qwen_asr_best \
+      --lora-r16-ckpt lora_r16_qwen_asr_best \
+      --latent-ckpt latent_qwen_asr_best.pth \
+      --max-samples-per-config 500 \
+      --output-json cv16_eval.json
+"""
+
+import argparse
+import gc
+import itertools
+import json
+import os
+import re
+import unicodedata
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+from datasets import Audio, get_dataset_config_names, load_dataset
+from jiwer import cer, wer
+from tqdm import tqdm
+
+from qwen_asr import Qwen3ASRModel  # type: ignore
+from model import LatentQwenASR
+from utils import set_seed
+
+
+COMMONVOICE_12_LANGS = [
+    "en",
+]
+
+FLEURS_12_LANGS = [
+    "en",
+]
+
+VOXPOPULI_30_LANGS = [
+    "en",
+]
+
+QWEN_FLEURS_CORE12_LANGS = [
+    "en",
+    "zh",
+    "yue",
+    "ar",
+    "de",
+    "es",
+    "fr",
+    "it",
+    "ja",
+    "ko",
+    "pt",
+    "ru",
+]
+
+QWEN_FLEURS_EXTRA8_LANGS = [
+    "hi",
+    "id",
+    "ms",
+    "nl",
+    "pl",
+    "th",
+    "tr",
+    "vi",
+]
+
+QWEN_FLEURS_EXTRA10_LANGS = [
+    "cs",
+    "da",
+    "el",
+    "fa",
+    "fi",
+    "fil",
+    "hu",
+    "mk",
+    "ro",
+    "sv",
+]
+
+QWEN_FLEURS_30_LANGS = (
+    QWEN_FLEURS_CORE12_LANGS
+    + QWEN_FLEURS_EXTRA8_LANGS
+    + QWEN_FLEURS_EXTRA10_LANGS
+)
+
+MLS_PUBLIC7_LANGS = ["de", "nl", "es", "fr", "it", "pl", "pt"]
+
+COMMONVOICE_CONFIG_ALIASES = {
+    "zh": "zh-CN",
+    "zh-cn": "zh-CN",
+    "zh_cn": "zh-CN",
+    "zh_tw": "zh-TW",
+    "zh-tw": "zh-TW",
+}
+
+COMMONVOICE_LANGUAGE_HINTS = {
+    "en": "English",
+}
+
+GENERAL_LANGUAGE_HINTS = {
+    "ar": "Arabic",
+    "ar_eg": "Arabic",
+    "ar-eg": "Arabic",
+    "ara": "Arabic",
+    "arb": "Arabic",
+    "cs": "Czech",
+    "cs_cz": "Czech",
+    "cs-cz": "Czech",
+    "czech": "Czech",
+    "da": "Danish",
+    "da_dk": "Danish",
+    "da-dk": "Danish",
+    "danish": "Danish",
+    "en": "English",
+    "en_us": "English",
+    "en-us": "English",
+    "en_gb": "English",
+    "en-gb": "English",
+    "en_au": "English",
+    "en-au": "English",
+    "english": "English",
+    "fr": "French",
+    "fr_fr": "French",
+    "fr-fr": "French",
+    "french": "French",
+    "de": "German",
+    "de_de": "German",
+    "de-de": "German",
+    "german": "German",
+    "es": "Spanish",
+    "es_es": "Spanish",
+    "es-es": "Spanish",
+    "es_419": "Spanish",
+    "spanish": "Spanish",
+    "it": "Italian",
+    "it_it": "Italian",
+    "it-it": "Italian",
+    "italian": "Italian",
+    "pt": "Portuguese",
+    "pt_pt": "Portuguese",
+    "pt-pt": "Portuguese",
+    "pt_br": "Portuguese",
+    "pt-br": "Portuguese",
+    "portuguese": "Portuguese",
+    "nl": "Dutch",
+    "nl_nl": "Dutch",
+    "nl-nl": "Dutch",
+    "dutch": "Dutch",
+    "pl": "Polish",
+    "pl_pl": "Polish",
+    "pl-pl": "Polish",
+    "polish": "Polish",
+    "zh": "Chinese",
+    "zh_cn": "Chinese",
+    "zh-cn": "Chinese",
+    "cmn": "Chinese",
+    "cmn_hans_cn": "Chinese",
+    "cmn-hans-cn": "Chinese",
+    "yue": "Cantonese",
+    "yue_hant_hk": "Cantonese",
+    "yue-hant-hk": "Cantonese",
+    "hi": "Hindi",
+    "hi_in": "Hindi",
+    "hi-in": "Hindi",
+    "id": "Indonesian",
+    "id_id": "Indonesian",
+    "id-id": "Indonesian",
+    "ja": "Japanese",
+    "ja_jp": "Japanese",
+    "ja-jp": "Japanese",
+    "ko": "Korean",
+    "ko_kr": "Korean",
+    "ko-kr": "Korean",
+    "ms": "Malay",
+    "ms_my": "Malay",
+    "ms-my": "Malay",
+    "ru": "Russian",
+    "ru_ru": "Russian",
+    "ru-ru": "Russian",
+    "th": "Thai",
+    "th_th": "Thai",
+    "th-th": "Thai",
+    "tr": "Turkish",
+    "tr_tr": "Turkish",
+    "tr-tr": "Turkish",
+    "vi": "Vietnamese",
+    "vi_vn": "Vietnamese",
+    "vi-vn": "Vietnamese",
+    "el": "Greek",
+    "el_gr": "Greek",
+    "el-gr": "Greek",
+    "fa": "Persian",
+    "fa_ir": "Persian",
+    "fa-ir": "Persian",
+    "fi": "Finnish",
+    "fi_fi": "Finnish",
+    "fi-fi": "Finnish",
+    "fil": "Filipino",
+    "fil_ph": "Filipino",
+    "fil-ph": "Filipino",
+    "hu": "Hungarian",
+    "hu_hu": "Hungarian",
+    "hu-hu": "Hungarian",
+    "mk": "Macedonian",
+    "mk_mk": "Macedonian",
+    "mk-mk": "Macedonian",
+    "ro": "Romanian",
+    "ro_ro": "Romanian",
+    "ro-ro": "Romanian",
+    "sv": "Swedish",
+    "sv_se": "Swedish",
+    "sv-se": "Swedish",
+}
+
+FALLBACK_TEXT_COLUMNS = [
+    "sentence",
+    "text",
+    "normalized_text",
+    "raw_text",
+    "transcript",
+    "transcription",
+    "english_transcription",
+]
+
+# Language-code family aliases used when dataset config IDs differ from
+# requested language IDs (e.g., zh -> cmn_hans_cn, fil -> tl, ms -> msa).
+LANGUAGE_CODE_ALIASES = {
+    "en": ["eng"],
+    "zh": ["zho", "cmn", "cmn_hans_cn", "cmn_hans"],
+    "zh_tw": ["cmn_hant_tw", "cmn_hant", "zho_hant", "zh_hant_tw"],
+    "yue": ["yue_hant_hk", "zh_hk", "zh_yue"],
+    "ar": ["ara", "arb"],
+    "de": ["deu", "ger"],
+    "es": ["spa", "es_419"],
+    "fr": ["fra", "fre"],
+    "it": ["ita"],
+    "ja": ["jpn"],
+    "ko": ["kor"],
+    "pt": ["por"],
+    "ru": ["rus"],
+    "id": ["ind", "in"],
+    "ms": ["msa", "may", "zsm"],
+    "fil": ["tgl", "tl"],
+    "th": ["tha"],
+    "vi": ["vie"],
+    "tr": ["tur"],
+    "hi": ["hin"],
+    "nl": ["nld", "dut"],
+    "sv": ["swe"],
+    "da": ["dan"],
+    "fi": ["fin"],
+    "pl": ["pol"],
+    "cs": ["ces", "cze"],
+    "fa": ["fas", "per", "pes"],
+    "el": ["ell", "gre"],
+    "hu": ["hun"],
+    "mk": ["mkd", "mac"],
+    "ro": ["ron", "rum"],
+}
+
+DATASET_PRESETS = {
+    "SpeechTest/common_voice_16_0": {
+        "default_strategy": "fixed_languages",
+        "default_languages": COMMONVOICE_12_LANGS,
+        "config_aliases": COMMONVOICE_CONFIG_ALIASES,
+        "language_hints": COMMONVOICE_LANGUAGE_HINTS,
+        "preferred_text_columns": ["sentence"],
+    },
+    "SpeechTest/peoples_speech": {
+        "default_strategy": "all_available",
+        "config_aliases": {},
+        "language_hints": {"test": "English", "en": "English"},
+        "preferred_text_columns": ["text"],
+    },
+    "SpeechTest/librispeech_asr": {
+        "default_strategy": "all_available",
+        "config_aliases": {},
+        "language_hints": {
+            "clean": "English",
+            "other": "English",
+            "en": "English",
+        },
+        "preferred_text_columns": ["text"],
+    },
+    "SpeechTest/fleurs": {
+        "default_strategy": "fixed_languages",
+        "default_languages": FLEURS_12_LANGS,
+        "config_aliases": {},
+        "language_hints": COMMONVOICE_LANGUAGE_HINTS,
+        "preferred_text_columns": ["transcription", "raw_transcription", "text"],
+    },
+    "SpeechTest/voxpopuli": {
+        "default_strategy": "fixed_languages",
+        "default_languages": VOXPOPULI_30_LANGS,
+        "config_aliases": {},
+        "language_hints": {
+            "en": "English",
+        },
+        "preferred_text_columns": ["normalized_text", "raw_text", "text"],
+    },
+    "SpeechTest/gigaspeech": {
+        "default_strategy": "all_available",
+        "config_aliases": {},
+        "language_hints": {"test": "English", "en": "English"},
+        "preferred_text_columns": ["text"],
+    },
+    "SpeechTest/ASCEND": {
+        "default_strategy": "all_available",
+        "config_aliases": {},
+        "language_hints": {},
+        "preferred_text_columns": ["transcription", "text"],
+    },
+    "SpeechTest/extreme_asr_pony": {
+        "default_strategy": "all_available",
+        "config_aliases": {},
+        "language_hints": {},
+        "preferred_text_columns": ["text"],
+    },
+    "openslr/librispeech_asr": {
+        "default_strategy": "default_configs",
+        "default_configs": ["clean", "other"],
+        "config_aliases": {},
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["text"],
+    },
+    "google/fleurs": {
+        "default_strategy": "fixed_languages",
+        "default_languages": FLEURS_12_LANGS,
+        "config_aliases": {},
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["transcription", "raw_transcription", "text"],
+    },
+    "facebook/voxpopuli": {
+        "default_strategy": "fixed_languages",
+        "default_languages": VOXPOPULI_30_LANGS,
+        "config_aliases": {},
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["normalized_text", "raw_text", "text"],
+    },
+    "PolyAI/minds14": {
+        "default_strategy": "default_configs",
+        "default_configs": ["en-US"],
+        "config_aliases": {
+            "en": "en-US",
+            "en_us": "en-US",
+            "en-us": "en-US",
+        },
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["transcription", "english_transcription", "text"],
+    },
+    "facebook/multilingual_librispeech": {
+        "default_strategy": "fixed_languages",
+        "default_languages": MLS_PUBLIC7_LANGS,
+        "config_aliases": {
+            "de": "german",
+            "nl": "dutch",
+            "es": "spanish",
+            "fr": "french",
+            "it": "italian",
+            "pl": "polish",
+            "pt": "portuguese",
+        },
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["transcript", "text"],
+    },
+    "LIUM/tedlium": {
+        "default_strategy": "default_configs",
+        "default_configs": ["release1"],
+        "config_aliases": {
+            "r1": "release1",
+            "r2": "release2",
+            "r3": "release3",
+        },
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["text"],
+    },
+    "TwinkStart/tedlium": {
+        "default_strategy": "default_configs",
+        "default_configs": ["release1"],
+        "config_aliases": {
+            "r1": "release1",
+            "r2": "release2",
+            "r3": "release3",
+        },
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["text"],
+    },
+    "edinburghcstr/ami": {
+        "default_strategy": "default_configs",
+        "default_configs": ["ihm"],
+        "config_aliases": {},
+        "language_hints": GENERAL_LANGUAGE_HINTS,
+        "preferred_text_columns": ["text", "transcript", "sentence"],
+    },
+}
+
+
+@dataclass
+class ModelBundle:
+    model: LatentQwenASR
+    processor: any
+    checkpoint: Dict[str, any]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Evaluate five ASR settings on SpeechTest or HuggingFace ASR datasets: "
+            "base_model, baseline_ft, prompt_tuning, lora_r16, latent_reasoning."
+        )
+    )
+    parser.add_argument(
+        "--model-id",
+        type=str,
+        default=os.getenv("MODEL_ID", "Qwen/Qwen3-ASR-0.6B"),
+        help="Base Qwen3-ASR model ID.",
+    )
+    parser.add_argument(
+        "--dataset-name",
+        type=str,
+        default="SpeechTest/common_voice_16_0",
+        help="HuggingFace dataset name.",
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="test",
+        help="Dataset split to evaluate.",
+    )
+    parser.add_argument(
+        "--configs",
+        type=str,
+        default="",
+        help=(
+            "Comma-separated config names (dataset-specific). "
+            "Default: dataset preset "
+            "(fixed-language datasets use preset languages; "
+            "others use preset configs or all subsets). "
+            "Ignored when --all-configs is set."
+        ),
+    )
+    parser.add_argument(
+        "--all-configs",
+        action="store_true",
+        help="Evaluate every config in the dataset.",
+    )
+    parser.add_argument(
+        "--max-configs",
+        type=int,
+        default=0,
+        help="Limit number of configs (0 = no limit).",
+    )
+    parser.add_argument(
+        "--max-samples-per-config",
+        type=int,
+        default=0,
+        help="Maximum test samples per config (0 = all).",
+    )
+    parser.add_argument(
+        "--streaming",
+        action="store_true",
+        help=(
+            "Load datasets with HuggingFace streaming=True and iterate samples "
+            "sequentially without materializing the split on disk."
+        ),
+    )
+    parser.add_argument(
+        "--text-normalizer",
+        type=str,
+        default="english",
+        choices=["english", "basic", "simple"],
+        help=(
+            "Text normalization before WER/CER. Use 'basic' or 'simple' for "
+            "multilingual evaluations to avoid English-specific rewriting."
+        ),
+    )
+    parser.add_argument(
+        "--max-new-tokens",
+        type=int,
+        default=128,
+        help="Max new tokens for generation.",
+    )
+    parser.add_argument(
+        "--baseline-ckpt",
+        type=str,
+        default="",
+        help="Path to baseline fine-tuned checkpoint (.pth).",
+    )
+    parser.add_argument(
+        "--prompt-tuning-ckpt",
+        type=str,
+        default="",
+        help=(
+            "Path to prompt-tuning checkpoint. "
+            "Supports .pth (wrapper state_dict) or a PEFT adapter directory."
+        ),
+    )
+    parser.add_argument(
+        "--lora-r16-ckpt",
+        type=str,
+        default="",
+        help=(
+            "Path to LoRA(rank=16) checkpoint. "
+            "Supports .pth (wrapper state_dict) or a PEFT adapter directory."
+        ),
+    )
+    parser.add_argument(
+        "--latent-ckpt",
+        type=str,
+        default="",
+        help="Path to latent reasoning checkpoint (.pth).",
+    )
+    parser.add_argument(
+        "--skip-base-model",
+        action="store_true",
+        help="Skip raw pretrained model inference baseline.",
+    )
+    parser.add_argument(
+        "--skip-baseline-ft",
+        action="store_true",
+        help="Skip baseline fine-tuned model evaluation.",
+    )
+    parser.add_argument(
+        "--skip-prompt-tuning",
+        action="store_true",
+        help="Skip prompt tuning model evaluation.",
+    )
+    parser.add_argument(
+        "--skip-lora-r16",
+        action="store_true",
+        help="Skip LoRA r16 model evaluation.",
+    )
+    parser.add_argument(
+        "--n-latent",
+        type=int,
+        default=-1,
+        help="Override latent token count. If < 0, use checkpoint n_latent.",
+    )
+    parser.add_argument(
+        "--num-beams",
+        type=int,
+        default=1,
+        help="Number of beams for beam search.",
+    )
+    parser.add_argument(
+        "--dynamic-halt-threshold",
+        type=float,
+        default=0.0,
+        help="Value head threshold for early halting of latent thoughts.",
+    )
+
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="auto",
+        choices=["auto", "cuda", "cpu"],
+        help="Device to run inference.",
+    )
+    parser.add_argument(
+        "--dtype",
+        type=str,
+        default="auto",
+        choices=["auto", "float32", "float16", "bfloat16"],
+        help="Inference dtype.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed.",
+    )
+    parser.add_argument(
+        "--print-samples",
+        type=int,
+        default=2,
+        help="Number of qualitative samples to print per config.",
+    )
+    parser.add_argument(
+        "--print-gate-skips",
+        action="store_true",
+        help=(
+            "Also print latent_reasoning samples skipped by the value-head gate. "
+            "Default is off to keep large sweep logs readable."
+        ),
+    )
+    parser.add_argument(
+        "--output-json",
+        type=str,
+        default="",
+        help="If set, write detailed results to this JSON file.",
+    )
+    parser.add_argument(
+        "--no-language-hint",
+        action="store_true",
+        help="Disable language-specific prompting and use generic ASR prompt.",
+    )
+    parser.add_argument(
+        "--prompt-template",
+        type=str,
+        default="Transcribe the {language} audio into text.",
+        help=(
+            "User prompt template. Use {language} placeholder. "
+            "Ignored when --no-language-hint is set."
+        ),
+    )
+    parser.add_argument(
+        "--snr-db",
+        type=float,
+        nargs="+",
+        default=None,
+        help=(
+            "Add Gaussian noise to audio at specified SNR levels (dB). "
+            "Can specify multiple values, e.g. --snr-db 20 10 5. "
+            "Each SNR level will be evaluated as a separate row. "
+            "If not set, no noise is added."
+        ),
+    )
+    return parser.parse_args()
+
+
+def choose_device(device_arg: str) -> str:
+    if device_arg == "auto":
+        return "cuda" if torch.cuda.is_available() else "cpu"
+    if device_arg == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Requested --device cuda but CUDA is not available.")
+    return device_arg
+
+
+def choose_dtype(dtype_arg: str, device: str) -> torch.dtype:
+    if dtype_arg == "float32":
+        return torch.float32
+    if dtype_arg == "float16":
+        return torch.float16 if device == "cuda" else torch.float32
+    if dtype_arg == "bfloat16":
+        return torch.bfloat16 if device == "cuda" else torch.float32
+
+    # auto
+    if device != "cuda":
+        return torch.float32
+    major = torch.cuda.get_device_capability(0)[0]
+    if major >= 8:
+        return torch.bfloat16
+    return torch.float16
+
+
+def get_dataset_preset(dataset_name: str) -> Dict[str, any]:
+    return DATASET_PRESETS.get(dataset_name, {})
+
+
+def resolve_dataset_name(dataset_name: str) -> str:
+    key = (dataset_name or "").strip()
+    if not key:
+        raise ValueError("dataset name is empty.")
+
+    if key in DATASET_PRESETS:
+        return key
+
+    lowered = key.lower()
+    for canonical in DATASET_PRESETS:
+        if canonical.lower() == lowered:
+            return canonical
+
+    print(
+        f"[warn] dataset '{dataset_name}' has no local preset; "
+        "using generic HuggingFace ASR defaults."
+    )
+    return key
+
+
+def _map_config_alias(name: str, alias_map: Dict[str, str]) -> str:
+    n = name.strip()
+    if not n:
+        return n
+    lowered = n.lower()
+    if lowered in alias_map:
+        return alias_map[lowered]
+    return n
+
+
+def resolve_language_hint(dataset_name: str, config_name: str) -> Optional[str]:
+    preset = get_dataset_preset(dataset_name)
+    hints_raw = preset.get("language_hints", {})
+    hints = {k.lower(): v for k, v in hints_raw.items()}
+
+    lowered = config_name.lower()
+    if lowered in hints:
+        return hints[lowered]
+
+    # Generic base-language fallback (e.g. "fr_ca" -> "fr").
+    base = lowered.split("-")[0].split("_")[0]
+    for key, val in hints.items():
+        if key.split("-")[0].split("_")[0] == base:
+            return val
+    return None
+
+
+def _norm_cfg_key(v: str) -> str:
+    return (v or "").strip().lower().replace("-", "_")
+
+
+def _base_lang(v: str) -> str:
+    return _norm_cfg_key(v).split("_")[0]
+
+
+def _language_candidate_forms(lang_code: str) -> List[str]:
+    code = _norm_cfg_key(lang_code)
+    out = {
+        code,
+        code.replace("_", "-"),
+    }
+    base = _base_lang(code)
+    out.add(base)
+
+    # Common alias expansions for multilingual dataset configs.
+    if code == "zh":
+        out.update({"zh_cn", "zh-cn", "zh_hans", "zh-hans"})
+    if code in {"zh_tw", "zhtw"}:
+        out.update({"zh_tw", "zh-tw", "zh_hant", "zh-hant", "zh_hk", "zh-hk"})
+    if code == "yue":
+        out.update({"yue_hk", "yue-hk", "yue_hant_hk", "yue-hant-hk", "zh_yue", "zh-yue", "zh_hk", "zh-hk"})
+    if code == "fil":
+        out.update({"fil_ph", "fil-ph", "tl", "tl_ph", "tl-ph", "tgl", "tgl_ph", "tgl-ph"})
+
+    # Expand across ISO variants / dataset-specific aliases.
+    base_aliases = LANGUAGE_CODE_ALIASES.get(base, [])
+    for alias in base_aliases:
+        alias_norm = _norm_cfg_key(alias)
+        out.update(
+            {
+                alias_norm,
+                alias_norm.replace("_", "-"),
+                _base_lang(alias_norm),
+            }
+        )
+
+    return list(out)
+
+
+def _pick_config_for_language(lang_code: str, available_configs: List[str]) -> Optional[str]:
+    if not available_configs:
+        return None
+    infos = []
+    for cfg in available_configs:
+        norm = _norm_cfg_key(cfg)
+        infos.append((cfg, norm, _base_lang(norm)))
+
+    candidates = set(_language_candidate_forms(lang_code))
+    code_norm = _norm_cfg_key(lang_code)
+    code_base = _base_lang(code_norm)
+
+    # 1) exact-ish match against candidate forms
+    exact_hits = [t for t in infos if t[1] in candidates]
+    if exact_hits:
+        # Prefer exact code, then prefix match (e.g. en_us for en), then lexical.
+        exact_hits.sort(
+            key=lambda t: (
+                0 if t[1] == code_norm else 1,
+                0 if t[1].startswith(code_base + "_") else 1,
+                t[1],
+            )
+        )
+        return exact_hits[0][0]
+
+    # 2) base-language fallback
+    base_hits = [t for t in infos if t[2] == code_base]
+    if base_hits:
+        # For Chinese variants, bias toward region when specified.
+        def _rank(tup: Tuple[str, str, str]) -> Tuple[int, int, str]:
+            norm = tup[1]
+            if code_norm in {"zh_tw", "zhtw"}:
+                zh_tw_bias = 0 if ("_tw" in norm or "hant" in norm) else 1
+                return (zh_tw_bias, 0 if norm.startswith(code_base + "_") else 1, norm)
+            if code_norm == "zh":
+                zh_cn_bias = 0 if ("_cn" in norm or "hans" in norm) else 1
+                return (zh_cn_bias, 0 if norm == "zh" else 1, norm)
+            return (0, 0 if norm.startswith(code_base + "_") else 1, norm)
+
+        base_hits.sort(key=_rank)
+        return base_hits[0][0]
+
+    return None
+
+
+def resolve_language_configs(
+    language_codes: List[str],
+    available_configs: List[str],
+) -> Tuple[List[str], List[str], List[Tuple[str, str]]]:
+    resolved: List[str] = []
+    missing: List[str] = []
+    mapping: List[Tuple[str, str]] = []
+    used = set()
+    for code in language_codes:
+        cfg = _pick_config_for_language(code, available_configs)
+        if cfg is None:
+            missing.append(code)
+            continue
+        mapping.append((code, cfg))
+        if cfg in used:
+            continue
+        resolved.append(cfg)
+        used.add(cfg)
+    return resolved, missing, mapping
+
+
+def resolve_configs(dataset_name: str, config_arg: str, all_configs: bool, max_configs: int) -> List[str]:
+    available_configs = get_dataset_config_names(dataset_name, trust_remote_code=True)
+    available_set = set(available_configs)
+    preset = get_dataset_preset(dataset_name)
+    alias_raw = preset.get("config_aliases", {})
+    alias_map = {k.lower(): v for k, v in alias_raw.items()}
+
+    if all_configs:
+        configs = available_configs
+    else:
+        raw_configs = [x.strip() for x in config_arg.split(",") if x.strip()]
+        default_strategy = str(preset.get("default_strategy", "all_available"))
+
+        # Fixed language datasets: map language codes -> actual config names.
+        use_language_mapping = default_strategy == "fixed_languages"
+        if use_language_mapping:
+            if not raw_configs:
+                raw_configs = list(preset.get("default_languages", []))
+            mapped_langs = [_map_config_alias(x, alias_map) for x in raw_configs]
+            configs, missing_langs, mapping = resolve_language_configs(mapped_langs, available_configs)
+            if mapping:
+                mapping_str = ", ".join([f"{src}->{dst}" for src, dst in mapping])
+                print(f"[info] {dataset_name}: language->config mapping: {mapping_str}")
+            if missing_langs:
+                print(
+                    f"[warn] {dataset_name}: skip missing language configs: {missing_langs}"
+                )
+        else:
+            if not raw_configs:
+                if default_strategy == "all_available":
+                    raw_configs = available_configs.copy()
+                else:
+                    raw_configs = list(preset.get("default_configs", []))
+
+            mapped = [_map_config_alias(x, alias_map) for x in raw_configs]
+            seen = set()
+            configs = []
+            for cfg in mapped:
+                if cfg and cfg not in seen:
+                    configs.append(cfg)
+                    seen.add(cfg)
+
+            missing = [cfg for cfg in configs if cfg not in available_set]
+            if missing:
+                raise ValueError(
+                    "Unknown configs after alias mapping: "
+                    f"{missing}. Available configs include: {sorted(list(available_set))[:20]} ..."
+                )
+
+    if not configs:
+        raise ValueError("No configs resolved. Provide --configs or use --all-configs.")
+    if max_configs > 0:
+        configs = configs[:max_configs]
+    return configs
+
+
+def dataset_column_names(raw_ds: any) -> List[str]:
+    column_names = getattr(raw_ds, "column_names", None)
+    if column_names:
+        return list(column_names)
+    features = getattr(raw_ds, "features", None)
+    if features:
+        try:
+            return list(features.keys())
+        except Exception:
+            pass
+    return []
+
+
+def resolve_text_column(dataset_name: str, column_names: List[str]) -> Optional[str]:
+    preset = get_dataset_preset(dataset_name)
+    preferred = list(preset.get("preferred_text_columns", []))
+    candidates = preferred + FALLBACK_TEXT_COLUMNS
+    seen = set()
+    deduped = []
+    for c in candidates:
+        if c not in seen:
+            deduped.append(c)
+            seen.add(c)
+    for c in deduped:
+        if c in column_names:
+            return c
+    return None
+
+
+def resolve_im_start_id(tokenizer: any) -> int:
+    im_start_id = tokenizer.convert_tokens_to_ids("<|im_start|>")
+    if im_start_id is None or im_start_id == tokenizer.unk_token_id:
+        if tokenizer.bos_token_id is not None:
+            return int(tokenizer.bos_token_id)
+        if tokenizer.eos_token_id is not None:
+            return int(tokenizer.eos_token_id)
+        return 0
+    return int(im_start_id)
+
+
+def ensure_front_prompt_token(
+    asr_model: any,
+    tokenizer: any,
+    token_name: str = "<|latent|>",
+) -> int:
+    token_id = tokenizer.convert_tokens_to_ids(token_name)
+    if token_id is None or token_id == tokenizer.unk_token_id:
+        added = tokenizer.add_special_tokens({"additional_special_tokens": [token_name]})
+        if added > 0:
+            asr_model.thinker.resize_token_embeddings(len(tokenizer))
+        token_id = tokenizer.convert_tokens_to_ids(token_name)
+    if token_id is None or token_id < 0:
+        raise RuntimeError(f"Failed to resolve front prompt token id for {token_name!r}.")
+    return int(token_id)
+
+
+def extract_soft_prompt_tensor(ckpt: Dict[str, any]) -> Optional[torch.Tensor]:
+    tensor = ckpt.get("soft_prompt_embed")
+    if torch.is_tensor(tensor):
+        return tensor
+    state = ckpt.get("model_state_dict")
+    if isinstance(state, dict):
+        tensor = state.get("soft_prompt_embed")
+        if torch.is_tensor(tensor):
+            return tensor
+    return None
+
+
+def load_checkpoint(path: str) -> Dict[str, any]:
+    ckpt = torch.load(path, map_location="cpu")
+    if isinstance(ckpt, dict):
+        return ckpt
+    return {"model_state_dict": ckpt}
+
+
+def is_path_file_or_dir(path: str) -> bool:
+    return os.path.isfile(path) or os.path.isdir(path)
+
+
+def build_plain_bundle(
+    model_id: str,
+    device: str,
+    dtype: torch.dtype,
+) -> Tuple[LatentQwenASR, any]:
+    asr_wrapper = Qwen3ASRModel.from_pretrained(
+        model_id,
+        dtype=dtype,
+        device_map=device if device == "cuda" else None,
+    )
+    asr_model = asr_wrapper.model
+    processor = asr_wrapper.processor
+
+    start_id = resolve_im_start_id(processor.tokenizer)
+    model = LatentQwenASR(
+        asr_model=asr_model,
+        processor=processor,
+        n_latent=0,
+        nt_token_id=-1,
+        lang_token_id=start_id,
+        transcribe_token_id=start_id,
+        freeze_base=False,
+        use_latent=False,
+    ).to(device)
+    return model, processor
+
+
+def maybe_attach_peft_adapter(
+    model: LatentQwenASR,
+    adapter_path: str,
+    mode_name: str,
+    expected_lora_rank: Optional[int] = None,
+) -> None:
+    try:
+        from peft import PeftConfig, PeftModel
+    except Exception as e:
+        raise RuntimeError(
+            f"[{mode_name}] Loading PEFT adapter requires `peft` package: {e}"
+        ) from e
+
+    peft_cfg = PeftConfig.from_pretrained(adapter_path)
+    peft_type = str(getattr(peft_cfg, "peft_type", "unknown"))
+    print(f"[{mode_name}] adapter detected: peft_type={peft_type} path={adapter_path}")
+
+    if expected_lora_rank is not None:
+        rank = getattr(peft_cfg, "r", None)
+        if rank is None:
+            rank_pattern = getattr(peft_cfg, "rank_pattern", None)
+            if isinstance(rank_pattern, dict) and rank_pattern:
+                unique_ranks = sorted({int(v) for v in rank_pattern.values()})
+                if len(unique_ranks) == 1:
+                    rank = unique_ranks[0]
+        if rank is None:
+            print(
+                f"[warn][{mode_name}] unable to verify LoRA rank from adapter config."
+            )
+        elif int(rank) != int(expected_lora_rank):
+            print(
+                f"[warn][{mode_name}] expected LoRA rank={expected_lora_rank}, got rank={rank}."
+            )
+
+    adapted = PeftModel.from_pretrained(
+        model.thinker,
+        adapter_path,
+        is_trainable=False,
+    )
+    model.base_model.thinker = adapted
+    model.thinker = model.base_model.thinker
+
+
+def sanitize_generation_config(model: LatentQwenASR) -> None:
+    gen_cfg = getattr(model.thinker, "generation_config", None)
+    if gen_cfg is None:
+        return
+    # Keep decoding deterministic and avoid warnings from stale sampling flags.
+    if hasattr(gen_cfg, "do_sample"):
+        gen_cfg.do_sample = False
+    if hasattr(gen_cfg, "temperature"):
+        gen_cfg.temperature = 1.0
+    if hasattr(gen_cfg, "top_p"):
+        gen_cfg.top_p = 1.0
+    if hasattr(gen_cfg, "typical_p"):
+        gen_cfg.typical_p = 1.0
+
+
+def build_base_model_bundle(
+    model_id: str,
+    device: str,
+    dtype: torch.dtype,
+) -> ModelBundle:
+    print(f"\n[Load base_model] model={model_id}")
+    ckpt: Dict[str, any] = {}
+    model, processor = build_plain_bundle(
+        model_id=model_id,
+        device=device,
+        dtype=dtype,
+    )
+
+    sanitize_generation_config(model)
+    model.eval()
+    return ModelBundle(model=model, processor=processor, checkpoint=ckpt)
+
+
+def build_baseline_ft_bundle(
+    model_id: str,
+    checkpoint_path: str,
+    device: str,
+    dtype: torch.dtype,
+) -> ModelBundle:
+    print(f"\n[Load baseline_ft] model={model_id} ckpt={checkpoint_path}")
+    ckpt = load_checkpoint(checkpoint_path)
+    model, processor = build_plain_bundle(
+        model_id=model_id,
+        device=device,
+        dtype=dtype,
+    )
+
+    state = ckpt.get("model_state_dict", ckpt)
+    missing, unexpected = model.load_state_dict(state, strict=False)
+    if missing:
+        print(f"[baseline_ft] missing keys: {len(missing)}")
+    if unexpected:
+        print(f"[baseline_ft] unexpected keys: {len(unexpected)}")
+
+    sanitize_generation_config(model)
+    model.eval()
+    return ModelBundle(model=model, processor=processor, checkpoint=ckpt)
+
+
+def build_prompt_tuning_bundle(
+    model_id: str,
+    checkpoint_path: str,
+    device: str,
+    dtype: torch.dtype,
+) -> ModelBundle:
+    print(f"\n[Load prompt_tuning] model={model_id} ckpt={checkpoint_path}")
+    if os.path.isdir(checkpoint_path):
+        # Backward compatibility: old prompt-tuning PEFT adapters.
+        model, processor = build_plain_bundle(
+            model_id=model_id,
+            device=device,
+            dtype=dtype,
+        )
+        maybe_attach_peft_adapter(
+            model=model,
+            adapter_path=checkpoint_path,
+            mode_name="prompt_tuning",
+        )
+        ckpt = {
+            "adapter_path": checkpoint_path,
+            "checkpoint_type": "peft_adapter",
+        }
+    else:
+        ckpt = load_checkpoint(checkpoint_path)
+        soft_prompt = extract_soft_prompt_tensor(ckpt)
+
+        if soft_prompt is not None:
+            asr_wrapper = Qwen3ASRModel.from_pretrained(
+                model_id,
+                dtype=dtype,
+                device_map=device if device == "cuda" else None,
+            )
+            asr_model = asr_wrapper.model
+            processor = asr_wrapper.processor
+
+            nt_id = ensure_front_prompt_token(asr_model, processor.tokenizer)
+            start_id = resolve_im_start_id(processor.tokenizer)
+            n_latent = int(ckpt.get("n_latent", int(soft_prompt.size(0))))
+            if n_latent <= 0:
+                n_latent = int(soft_prompt.size(0))
+            if n_latent <= 0:
+                raise ValueError("prompt_tuning checkpoint has empty soft prompt tensor.")
+
+            model = LatentQwenASR(
+                asr_model=asr_model,
+                processor=processor,
+                n_latent=n_latent,
+                nt_token_id=nt_id,
+                lang_token_id=start_id,
+                transcribe_token_id=start_id,
+                freeze_base=False,
+                use_latent=False,
+                use_soft_prompt=True,
+                soft_prompt_init_mode="random",
+            ).to(device)
+
+            prompt = soft_prompt.detach()
+            if prompt.dim() != 2:
+                raise ValueError(
+                    f"soft_prompt_embed must be 2D [n_latent, hidden], got shape={tuple(prompt.shape)}"
+                )
+            if prompt.size(0) < n_latent:
+                reps = (n_latent + prompt.size(0) - 1) // prompt.size(0)
+                prompt = prompt.repeat((reps, 1))
+            prompt = prompt[:n_latent]
+            model.soft_prompt_embed.data.copy_(
+                prompt.to(
+                    device=model.soft_prompt_embed.device,
+                    dtype=model.soft_prompt_embed.dtype,
+                )
+            )
+            print(f"[prompt_tuning] loaded front soft prompt: n_latent={n_latent}")
+        else:
+            # Fallback for legacy `.pth` checkpoints that saved full wrapper state.
+            model, processor = build_plain_bundle(
+                model_id=model_id,
+                device=device,
+                dtype=dtype,
+            )
+            state = ckpt.get("model_state_dict", ckpt)
+            missing, unexpected = model.load_state_dict(state, strict=False)
+            if missing:
+                print(f"[prompt_tuning] missing keys: {len(missing)}")
+            if unexpected:
+                print(f"[prompt_tuning] unexpected keys: {len(unexpected)}")
+
+    sanitize_generation_config(model)
+    model.eval()
+    return ModelBundle(model=model, processor=processor, checkpoint=ckpt)
+
+
+def build_lora_r16_bundle(
+    model_id: str,
+    checkpoint_path: str,
+    device: str,
+    dtype: torch.dtype,
+) -> ModelBundle:
+    print(f"\n[Load lora_r16] model={model_id} ckpt={checkpoint_path}")
+    model, processor = build_plain_bundle(
+        model_id=model_id,
+        device=device,
+        dtype=dtype,
+    )
+
+    if os.path.isdir(checkpoint_path):
+        maybe_attach_peft_adapter(
+            model=model,
+            adapter_path=checkpoint_path,
+            mode_name="lora_r16",
+            expected_lora_rank=None,
+        )
+        ckpt = {
+            "adapter_path": checkpoint_path,
+            "checkpoint_type": "peft_adapter",
+        }
+    else:
+        ckpt = load_checkpoint(checkpoint_path)
+        state = ckpt.get("model_state_dict", ckpt)
+        missing, unexpected = model.load_state_dict(state, strict=False)
+        if missing:
+            print(f"[lora_r16] missing keys: {len(missing)}")
+        if unexpected:
+            print(f"[lora_r16] unexpected keys: {len(unexpected)}")
+
+    sanitize_generation_config(model)
+    model.eval()
+    return ModelBundle(model=model, processor=processor, checkpoint=ckpt)
+
+
+def build_latent_bundle(
+    model_id: str,
+    checkpoint_path: str,
+    n_latent_override: int,
+    device: str,
+    dtype: torch.dtype,
+) -> ModelBundle:
+    print(f"\n[Load latent_reasoning] model={model_id} ckpt={checkpoint_path}")
+    ckpt = load_checkpoint(checkpoint_path)
+
+    n_latent = int(ckpt.get("n_latent", 4))
+    if n_latent_override >= 0:
+        n_latent = int(n_latent_override)
+    if n_latent <= 0:
+        raise ValueError(f"Invalid latent token count: {n_latent}")
+
+    asr_wrapper = Qwen3ASRModel.from_pretrained(
+        model_id,
+        dtype=dtype,
+        device_map=device if device == "cuda" else None,
+    )
+    asr_model = asr_wrapper.model
+    processor = asr_wrapper.processor
+
+    token_id = ensure_front_prompt_token(asr_model, processor.tokenizer)
+
+    start_id = resolve_im_start_id(processor.tokenizer)
+    model = LatentQwenASR(
+        asr_model=asr_model,
+        processor=processor,
+        n_latent=n_latent,
+        nt_token_id=int(token_id),
+        lang_token_id=start_id,
+        transcribe_token_id=start_id,
+        freeze_base=False,
+        use_latent=True,
+        latent_use_bounded_delta=bool(ckpt.get("latent_use_bounded_delta", True)),
+        latent_use_injection_gate=bool(ckpt.get("latent_use_injection_gate", True)),
+        latent_use_embedding_anchor=bool(ckpt.get("latent_use_embedding_anchor", True)),
+    ).to(device)
+
+    # Prefer latent-adapter payload format from train.py.
+    if "init_proj" in ckpt:
+        model.init_proj.load_state_dict(ckpt["init_proj"], strict=True)
+        model.delta_proj.load_state_dict(ckpt["delta_proj"], strict=True)
+        model.step_proj.load_state_dict(ckpt["step_proj"], strict=True)
+        if "step_embed" in ckpt:
+            model.step_embed.data.copy_(
+                ckpt["step_embed"].to(
+                    device=model.step_embed.device,
+                    dtype=model.step_embed.dtype,
+                )
+            )
+        if "log_scale" in ckpt:
+            model.log_scale.data.copy_(
+                ckpt["log_scale"].to(
+                    device=model.log_scale.device,
+                    dtype=model.log_scale.dtype,
+                )
+            )
+        if "value_head" in ckpt:
+            model.value_head.load_state_dict(ckpt["value_head"], strict=True)
+        if "injection_gate" in ckpt:
+            model.injection_gate.load_state_dict(ckpt["injection_gate"], strict=True)
+    else:
+        # Fallback: checkpoint may contain full wrapper state_dict.
+        state = ckpt.get("model_state_dict", ckpt)
+        missing, unexpected = model.load_state_dict(state, strict=False)
+        if missing:
+            print(f"[latent_reasoning] missing keys: {len(missing)}")
+        if unexpected:
+            print(f"[latent_reasoning] unexpected keys: {len(unexpected)}")
+
+    sanitize_generation_config(model)
+    model.eval()
+    return ModelBundle(model=model, processor=processor, checkpoint=ckpt)
+
+
+_global_normalizer = None
+_global_normalizer_kind = "english"
+
+
+def configure_text_normalizer(kind: str) -> None:
+    global _global_normalizer, _global_normalizer_kind
+    kind = (kind or "english").strip().lower()
+    if kind not in {"english", "basic", "simple"}:
+        raise ValueError(f"Unknown text normalizer: {kind}")
+    if kind != _global_normalizer_kind:
+        _global_normalizer = None
+    _global_normalizer_kind = kind
+
+
+def simple_text_normalize(text: str) -> str:
+    text = unicodedata.normalize("NFKC", text or "")
+    text = text.lower()
+    text = "".join(
+        " " if unicodedata.category(ch).startswith("P") else ch
+        for ch in text
+    )
+    return re.sub(r"\s+", " ", text).strip()
+
+
+class _SimpleTextNormalizer:
+    def __call__(self, text: str) -> str:
+        return simple_text_normalize(text)
+
+
+def build_text_normalizer(kind: str):
+    if kind == "simple":
+        return _SimpleTextNormalizer()
+
+    if kind == "basic":
+        try:
+            from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+            return BasicTextNormalizer()
+        except Exception:
+            return _SimpleTextNormalizer()
+
+    try:
+        # We use the standard Whisper English normalizer for English-heavy legacy runs.
+        from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+        import json, urllib.request, os
+
+        mapping_path = os.path.join(os.path.dirname(__file__), "english_normalizer.json")
+        if not os.path.exists(mapping_path):
+            url = "https://raw.githubusercontent.com/huggingface/transformers/main/src/transformers/models/whisper/english_normalizer.json"
+            req = urllib.request.Request(url)
+            with urllib.request.urlopen(req) as response:
+                data = json.loads(response.read().decode("utf-8"))
+            with open(mapping_path, "w") as f:
+                json.dump(data, f)
+        else:
+            with open(mapping_path, "r") as f:
+                data = json.load(f)
+        return EnglishTextNormalizer(data)
+    except Exception:
+        try:
+            from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+            return BasicTextNormalizer()
+        except Exception:
+            return _SimpleTextNormalizer()
+
+def normalize_text(text: str) -> str:
+    global _global_normalizer
+    if _global_normalizer is None:
+        _global_normalizer = build_text_normalizer(_global_normalizer_kind)
+    normalized = _global_normalizer(text)
+    
+    if isinstance(normalized, str):
+        if _global_normalizer_kind == "english":
+            # LibriSpeech specific normalizations: expand common contractions
+            # that Whisper leaves as "m" or "re".
+            contractions = {
+                r"\bi m\b": "i am",
+                r"\byou re\b": "you are",
+                r"\bwe re\b": "we are",
+                r"\bthey re\b": "they are",
+                r"\bhe s\b": "he is",
+                r"\bshe s\b": "she is",
+                r"\bit s\b": "it is",
+                r"\bthat s\b": "that is",
+                r"\bwho s\b": "who is",
+                r"\bwhat s\b": "what is",
+                r"\bthere s\b": "there is",
+                r"\bhere s\b": "here is",
+                r"\bwhere s\b": "where is",
+                r"\blet s\b": "let us",
+                r"\bhow s\b": "how is",
+                # Standard possessive stripping (boy's -> boy s -> boys)
+                r"\b s\b": "s",
+            }
+            for pat, repl in contractions.items():
+                normalized = re.sub(pat, repl, normalized)
+            
+        return re.sub(r"\s+", " ", normalized).strip()
+    return ""
+
+def clean_prediction(text: str) -> str:
+    text = text or ""
+    text = re.sub(r"language\s+\w+<asr_text>", "", text, flags=re.IGNORECASE)
+    if "<asr_text>" in text:
+        text = text.split("<asr_text>", 1)[-1]
+    return text.strip()
+
+
+@torch.no_grad()
+def add_noise_at_snr(waveform: np.ndarray, snr_db: float) -> np.ndarray:
+    """Add Gaussian noise to a waveform at a target Signal-to-Noise Ratio (dB).
+    
+    SNR_dB = 10 * log10(P_signal / P_noise)
+    => P_noise = P_signal / 10^(SNR_dB / 10)
+    => std_noise = sqrt(P_noise)
+    """
+    signal_power = np.mean(waveform ** 2)
+    if signal_power < 1e-10:  # silence guard
+        return waveform
+    noise_power = signal_power / (10.0 ** (snr_db / 10.0))
+    noise = np.random.normal(0, np.sqrt(noise_power), waveform.shape)
+    return (waveform + noise).astype(waveform.dtype)
+
+
+def evaluate_config(
+    model: LatentQwenASR,
+    processor: any,
+    dataset_name: str,
+    config_name: str,
+    split: str,
+    use_baseline: bool,
+    mode_name: str,
+    max_samples: int,
+    max_new_tokens: int,
+    print_samples: int,
+    language_hint: Optional[str],
+    prompt_template: str,
+    disable_language_hint: bool,
+    num_beams: int = 1,
+    dynamic_halt_threshold: float = 0.0,
+    snr_db: Optional[float] = None,
+    print_gate_skips: bool = False,
+    streaming: bool = False,
+) -> Dict[str, any]:
+    raw_ds = load_dataset(
+        dataset_name,
+        config_name,
+        split=split,
+        trust_remote_code=True,
+        streaming=streaming,
+    )
+    known_total: Optional[int]
+    try:
+        known_total = len(raw_ds)
+    except TypeError:
+        known_total = None
+    total = known_total if known_total is not None else 0
+    if max_samples > 0:
+        total = min(total, max_samples) if known_total is not None else max_samples
+    column_names = dataset_column_names(raw_ds)
+    text_column = resolve_text_column(dataset_name, column_names)
+    audio_column = "audio" if "audio" in column_names else None
+
+    if audio_column is None and not streaming:
+        raise ValueError(
+            f"Dataset {dataset_name}/{config_name} does not have an 'audio' column. "
+            f"Columns: {column_names}"
+        )
+    target_sampling_rate = int(getattr(processor.feature_extractor, "sampling_rate", 0) or 0)
+    if target_sampling_rate > 0 and audio_column is not None:
+        raw_ds = raw_ds.cast_column(audio_column, Audio(sampling_rate=target_sampling_rate))
+
+    preds: List[str] = []
+    refs: List[str] = []
+    shown = 0
+    skipped = 0
+    reasoned = 0
+
+    # Value Head aggregate statistics collectors
+    all_v_preds: List[List[float]] = []   # per-sample list of v_pred values
+    all_deq_iters: List[int] = []          # per-sample thinking steps taken
+    all_gates: List[float] = []            # per-sample gate values
+    all_scales: List[List[float]] = []     # per-sample scale values
+    n_skipped_by_gate = 0                  # count of N=0 (gate skip)
+
+    effective_language_hint = None if disable_language_hint else language_hint
+    if effective_language_hint:
+        try:
+            prompt_text = prompt_template.format(language=effective_language_hint)
+        except Exception:
+            prompt_text = f"Transcribe the {effective_language_hint} audio into text."
+    else:
+        prompt_text = "Transcribe the audio into text."
+
+    sample_iter = iter(raw_ds)
+    if max_samples > 0:
+        sample_iter = itertools.islice(sample_iter, max_samples)
+    pbar = tqdm(sample_iter, total=total if total > 0 else None, desc=f"{config_name}:{mode_name}", leave=False)
+    seen = 0
+    for i, sample in enumerate(pbar):
+        seen += 1
+
+        if (text_column is None or audio_column is None) and isinstance(sample, dict):
+            sample_columns = list(sample.keys())
+            if text_column is None:
+                text_column = resolve_text_column(dataset_name, sample_columns)
+            if audio_column is None and "audio" in sample_columns:
+                audio_column = "audio"
+
+        if audio_column is None:
+            skipped += 1
+            continue
+
+        if text_column is not None:
+            ref = sample.get(text_column, "")
+        else:
+            ref = ""
+            for cand in FALLBACK_TEXT_COLUMNS:
+                v = sample.get(cand, "")
+                if isinstance(v, str) and v.strip():
+                    ref = v
+                    break
+        if not isinstance(ref, str) or not ref.strip():
+            skipped += 1
+            continue
+
+        audio = sample.get(audio_column)
+        if not isinstance(audio, dict) or "array" not in audio or "sampling_rate" not in audio:
+            skipped += 1
+            continue
+
+        audio_array = np.array(audio["array"], dtype=np.float64)
+        if snr_db is not None:
+            audio_array = add_noise_at_snr(audio_array, snr_db)
+
+        target_dtype = model.thinker.dtype if hasattr(model.thinker, "dtype") else torch.float32
+        feat_out = processor.feature_extractor(
+            audio_array,
+            sampling_rate=audio["sampling_rate"],
+            return_attention_mask=True,
+        )
+        feats = torch.tensor(feat_out.input_features[0], dtype=target_dtype, device=model.base_model.device).unsqueeze(0)
+        n_frames = feats.size(-1)
+        
+        if getattr(feat_out, "attention_mask", None) is not None:
+            # Coerce mask to match the Mel frame length (same logic as data.py)
+            raw_mask = feat_out.attention_mask[0]
+            if not isinstance(raw_mask, (list, torch.Tensor)):
+                raw_mask = list(raw_mask)
+            if isinstance(raw_mask, torch.Tensor):
+                raw_mask = raw_mask.long()
+            else:
+                raw_mask = torch.tensor(raw_mask, dtype=torch.long)
+            # Pad or truncate to n_frames
+            if raw_mask.size(-1) < n_frames:
+                raw_mask = torch.cat([raw_mask, torch.zeros(n_frames - raw_mask.size(-1), dtype=torch.long)])
+            else:
+                raw_mask = raw_mask[:n_frames]
+            feature_attention_mask = raw_mask.to(device=model.base_model.device).unsqueeze(0)
+        else:
+            feature_attention_mask = torch.ones((1, n_frames), dtype=torch.long, device=model.base_model.device)
+
+        # Guard: if effective feature length is too short for audio tower, skip sample
+        effective_len = feature_attention_mask.sum().item()
+        if effective_len < 10:
+            skipped += 1
+            continue
+
+        gen_kwargs = {
+            "feature_attention_mask": feature_attention_mask,
+            "max_new_tokens": max_new_tokens,
+            "use_baseline": use_baseline,
+            "return_thoughts": False,
+            "return_stats": True,
+            "do_sample": False,
+            "eos_token_id": [151645, 151643],
+            "num_beams": num_beams,
+            "language_hint": effective_language_hint,
+            "prompt_text": prompt_text,
+            "dynamic_halt_threshold": dynamic_halt_threshold,
+        }
+
+        gen_output = model.generate(feats, **gen_kwargs)
+        if isinstance(gen_output, tuple):
+            gen_ids = gen_output[0]
+            stats = gen_output[1] if isinstance(gen_output[1], dict) else (gen_output[2] if len(gen_output)>2 and isinstance(gen_output[2], dict) else {})
+        else:
+            gen_ids = gen_output
+            stats = {}
+
+        ids = gen_ids[0]
+        eos_id = processor.tokenizer.eos_token_id
+        if eos_id is not None and (ids == eos_id).any():
+            eos_pos = (ids == eos_id).nonzero(as_tuple=True)[0][0]
+            ids = ids[:eos_pos]
+
+        pred_raw = processor.tokenizer.decode(ids, skip_special_tokens=True)
+        pred = clean_prediction(pred_raw)
+
+        pred_norm = normalize_text(pred)
+        ref_norm = normalize_text(ref)
+        if not ref_norm:
+            skipped += 1
+            continue
+
+        preds.append(pred_norm)
+        refs.append(ref_norm)
+
+        # Always print if it was skipped (N=0 from Gate) OR if under the print limit
+        is_skipped_lr = stats.get("skipped", False)
+        
+        if mode_name == "latent_reasoning":
+            if not is_skipped_lr:
+                reasoned += 1
+
+        if shown < print_samples or (print_gate_skips and is_skipped_lr):
+            if not is_skipped_lr:
+                shown += 1
+            print(f"\n[{config_name} | {mode_name} | sample {shown if not is_skipped_lr else 'SKIPPED'}]")
+            print(f"  Ref : {ref.strip()}")
+            print(f"  Pred: {pred}")
+            if "v_preds" in stats and stats["v_preds"] is not None:
+                v_vals = stats["v_preds"][0].tolist()
+                v_str = " | ".join([f"{v:.4f}" for v in v_vals])
+                iters_t = stats.get("deq_iters", None)
+                deq_iters = int(iters_t.item()) if iters_t is not None and hasattr(iters_t, "item") else -1
+                if is_skipped_lr:
+                    print(f"  v_preds: [{v_str}] -> SKIPPED (N=0)")
+                else:
+                    print(f"  v_preds: [{v_str}] -> {deq_iters} step(s)")
+
+        # --- Collect Value Head stats for aggregate summary ---
+        if mode_name == "latent_reasoning":
+            iters_t = stats.get("deq_iters", None)
+            deq_n = int(iters_t.item()) if iters_t is not None and hasattr(iters_t, "item") else 0
+            all_deq_iters.append(deq_n)
+            if is_skipped_lr:
+                n_skipped_by_gate += 1
+            if "v_preds" in stats and stats["v_preds"] is not None:
+                all_v_preds.append(stats["v_preds"][0].tolist())
+            if "gate" in stats and stats["gate"] is not None:
+                g = stats["gate"]
+                all_gates.append(float(g[0].item()) if hasattr(g, "item") or g.dim() > 0 else float(g))
+            if "scales" in stats and stats["scales"] is not None:
+                s = stats["scales"]
+                all_scales.append(s.tolist() if hasattr(s, "tolist") else list(s))
+
+    # --- Print Value Head aggregate summary ---
+    if mode_name == "latent_reasoning" and all_deq_iters:
+        import collections
+        n_total_eval = len(all_deq_iters)
+        n_dist = collections.Counter(all_deq_iters)
+        print(f"\n{'='*60}")
+        print(f"[Value-Head Summary] {config_name} | {mode_name}")
+        print(f"{'='*60}")
+        print(f"  Total samples evaluated : {n_total_eval}")
+        print(f"  Skipped by gate (N=0)   : {n_skipped_by_gate} ({100*n_skipped_by_gate/max(1,n_total_eval):.1f}%)")
+        print(f"  Reasoned (N>0)          : {n_total_eval - n_skipped_by_gate} ({100*(n_total_eval - n_skipped_by_gate)/max(1,n_total_eval):.1f}%)")
+        print(f"  --- N-step distribution ---")
+        for k in sorted(n_dist.keys()):
+            pct = 100 * n_dist[k] / n_total_eval
+            bar = '█' * int(pct / 2)
+            print(f"    N={k}: {n_dist[k]:5d} ({pct:5.1f}%) {bar}")
+        if all_v_preds:
+            flat_v = [v for vs in all_v_preds for v in vs]
+            if flat_v:
+                import numpy as _np
+                v_arr = _np.array(flat_v)
+                print(f"  --- v_pred statistics (all steps, all samples) ---")
+                print(f"    count : {len(v_arr)}")
+                print(f"    mean  : {v_arr.mean():.4f}")
+                print(f"    std   : {v_arr.std():.4f}")
+                print(f"    min   : {v_arr.min():.4f}")
+                print(f"    max   : {v_arr.max():.4f}")
+                print(f"    median: {float(_np.median(v_arr)):.4f}")
+                # Histogram buckets
+                edges = [-1.0, -0.8, -0.5, -0.2, 0.0, 0.2, 0.5, 0.8, 1.0]
+                print(f"  --- v_pred histogram ---")
+                for j in range(len(edges) - 1):
+                    lo, hi = edges[j], edges[j + 1]
+                    cnt = int(((v_arr >= lo) & (v_arr < hi)).sum())
+                    pct = 100 * cnt / len(v_arr)
+                    bar = '▓' * int(pct / 2)
+                    print(f"    [{lo:+.1f}, {hi:+.1f}): {cnt:5d} ({pct:5.1f}%) {bar}")
+                # Also count == 1.0
+                cnt_one = int((v_arr >= 0.8).sum())
+                # First-step v_pred (initial gate signal)
+                first_v = [vs[0] for vs in all_v_preds if vs]
+                if first_v:
+                    fv = _np.array(first_v)
+                    print(f"  --- v_pred[0] (initial gate signal) ---")
+                    print(f"    mean  : {fv.mean():.4f}")
+                    print(f"    std   : {fv.std():.4f}")
+                    print(f"    < 0   : {int((fv < 0).sum()):5d} ({100*(fv < 0).mean():.1f}%)")
+                    print(f"    >= 0  : {int((fv >= 0).sum()):5d} ({100*(fv >= 0).mean():.1f}%)")
+        if all_gates:
+            import numpy as _np
+            g_arr = _np.array(all_gates)
+            print(f"  --- Gate confidence (mapped to [0,1]) ---")
+            print(f"    mean  : {g_arr.mean():.4f}")
+            print(f"    std   : {g_arr.std():.4f}")
+            print(f"    min   : {g_arr.min():.4f}")
+            print(f"    max   : {g_arr.max():.4f}")
+        if all_scales:
+            import numpy as _np
+            s_arr = _np.array(all_scales)
+            if s_arr.ndim == 2:
+                print(f"  --- Delta scales per step ---")
+                for si in range(s_arr.shape[1]):
+                    col = s_arr[:, si]
+                    print(f"    step {si}: mean={col.mean():.4f} std={col.std():.4f}")
+            elif s_arr.ndim == 1:
+                print(f"  --- Delta scales ---")
+                print(f"    mean={s_arr.mean():.4f} std={s_arr.std():.4f}")
+        print(f"{'='*60}\n")
+
+    if not refs:
+        return {
+            "config": config_name,
+            "mode": mode_name,
+            "language_hint": effective_language_hint,
+            "text_column": text_column,
+            "samples_total": total if total > 0 else seen,
+            "samples_used": 0,
+            "samples_skipped": skipped,
+            "samples_reasoned": reasoned,
+            "wer": 1.0,
+            "cer": 1.0,
+        }
+
+    return {
+        "config": config_name,
+        "mode": mode_name,
+        "language_hint": effective_language_hint,
+        "text_column": text_column,
+        "samples_total": total if total > 0 else seen,
+        "samples_used": len(refs),
+        "samples_skipped": skipped,
+        "samples_reasoned": reasoned,
+        "wer": float(wer(refs, preds)),
+        "cer": float(cer(refs, preds)),
+    }
+
+
+def weighted_avg(rows: List[Dict[str, any]], metric_key: str) -> Optional[float]:
+    numer = 0.0
+    denom = 0
+    for row in rows:
+        n = int(row.get("samples_used", 0))
+        if n <= 0:
+            continue
+        m = row.get(metric_key)
+        if m is None:
+            continue
+        numer += float(m) * n
+        denom += n
+    if denom == 0:
+        return None
+    return numer / float(denom)
+
+
+def print_summary_table(rows: List[Dict[str, any]]) -> None:
+    header = (
+        f"{'Config':<12} {'N':>7} "
+        f"{'Raw-WER':>10} {'FT-WER':>10} {'PT-WER':>10} {'LoRA-WER':>10} {'Lat-WER':>10} "
+        f"{'Raw-CER':>10} {'FT-CER':>10} {'PT-CER':>10} {'LoRA-CER':>10} {'Lat-CER':>10}"
+    )
+    print("\n" + header)
+    print("-" * len(header))
+
+    for row in rows:
+        cfg = row["config"]
+        n = row.get("samples_used", 0)
+        raw_wer = row.get("base_model_wer")
+        ft_wer = row.get("baseline_ft_wer")
+        pt_wer = row.get("prompt_tuning_wer")
+        lora_wer = row.get("lora_r16_wer")
+        lat_wer = row.get("latent_reasoning_wer")
+        raw_cer = row.get("base_model_cer")
+        ft_cer = row.get("baseline_ft_cer")
+        pt_cer = row.get("prompt_tuning_cer")
+        lora_cer = row.get("lora_r16_cer")
+        lat_cer = row.get("latent_reasoning_cer")
+
+        print(
+            f"{cfg:<12} {n:>7d} "
+            f"{(f'{raw_wer:.4f}' if raw_wer is not None else '-'):>10} "
+            f"{(f'{ft_wer:.4f}' if ft_wer is not None else '-'):>10} "
+            f"{(f'{pt_wer:.4f}' if pt_wer is not None else '-'):>10} "
+            f"{(f'{lora_wer:.4f}' if lora_wer is not None else '-'):>10} "
+            f"{(f'{lat_wer:.4f}' if lat_wer is not None else '-'):>10} "
+            f"{(f'{raw_cer:.4f}' if raw_cer is not None else '-'):>10} "
+            f"{(f'{ft_cer:.4f}' if ft_cer is not None else '-'):>10} "
+            f"{(f'{pt_cer:.4f}' if pt_cer is not None else '-'):>10} "
+            f"{(f'{lora_cer:.4f}' if lora_cer is not None else '-'):>10} "
+            f"{(f'{lat_cer:.4f}' if lat_cer is not None else '-'):>10}"
+        )
+
+
+def release_model(bundle: Optional[ModelBundle]) -> None:
+    if bundle is None:
+        return
+    del bundle.model
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+def main() -> None:
+    args = parse_args()
+    set_seed(args.seed)
+    configure_text_normalizer(args.text_normalizer)
+
+    args.baseline_ckpt = (args.baseline_ckpt or "").strip()
+    args.prompt_tuning_ckpt = (args.prompt_tuning_ckpt or "").strip()
+    args.lora_r16_ckpt = (args.lora_r16_ckpt or "").strip()
+    args.latent_ckpt = (args.latent_ckpt or "").strip()
+    run_base_model = not bool(args.skip_base_model)
+    run_baseline_ft = bool(args.baseline_ckpt) and not bool(args.skip_baseline_ft)
+    run_prompt_tuning = bool(args.prompt_tuning_ckpt) and not bool(args.skip_prompt_tuning)
+    run_lora_r16 = bool(args.lora_r16_ckpt) and not bool(args.skip_lora_r16)
+    run_latent_reasoning = bool(args.latent_ckpt)
+    if not (
+        run_base_model
+        or run_baseline_ft
+        or run_prompt_tuning
+        or run_lora_r16
+        or run_latent_reasoning
+    ):
+        raise ValueError(
+            "No evaluation mode enabled. Provide at least one of --baseline-ckpt, "
+            "--prompt-tuning-ckpt, --lora-r16-ckpt, --latent-ckpt, "
+            "or remove --skip-base-model."
+        )
+    if run_baseline_ft and not os.path.isfile(args.baseline_ckpt):
+        raise FileNotFoundError(
+            f"--baseline-ckpt expects a .pth file, got: {args.baseline_ckpt}"
+        )
+    if run_latent_reasoning and not os.path.isfile(args.latent_ckpt):
+        raise FileNotFoundError(
+            f"--latent-ckpt expects a .pth file, got: {args.latent_ckpt}"
+        )
+    if run_prompt_tuning and not is_path_file_or_dir(args.prompt_tuning_ckpt):
+        raise FileNotFoundError(
+            f"--prompt-tuning-ckpt path not found: {args.prompt_tuning_ckpt}"
+        )
+    if run_lora_r16 and not is_path_file_or_dir(args.lora_r16_ckpt):
+        raise FileNotFoundError(
+            f"--lora-r16-ckpt path not found: {args.lora_r16_ckpt}"
+        )
+
+    dataset_name = resolve_dataset_name(args.dataset_name)
+    device = choose_device(args.device)
+    dtype = choose_dtype(args.dtype, device)
+    configs = resolve_configs(dataset_name, args.configs, args.all_configs, args.max_configs)
+
+    print("=== Evaluation Setup ===")
+    print(f"Device: {device}")
+    print(f"Dtype : {dtype}")
+    print(f"Model : {args.model_id}")
+    print(f"Data  : {dataset_name} ({args.split})")
+    print(f"Configs ({len(configs)}): {configs}")
+    print(f"Max samples/config: {'all' if args.max_samples_per_config <= 0 else args.max_samples_per_config}")
+    print(f"Streaming:            {'yes' if args.streaming else 'no'}")
+    print(f"Text normalizer:      {args.text_normalizer}")
+    print(f"Run base_model:       {'yes' if run_base_model else 'no'}")
+    print(f"Run baseline_ft:      {'yes' if run_baseline_ft else 'no'}")
+    print(f"Run prompt_tuning:    {'yes' if run_prompt_tuning else 'no'}")
+    print(f"Run lora_r16:         {'yes' if run_lora_r16 else 'no'}")
+    print(f"Run latent_reasoning: {'yes' if run_latent_reasoning else 'no'}")
+    print(f"Language hint: {'off' if args.no_language_hint else 'on'}")
+    if not args.no_language_hint:
+        print(f"Prompt template: {args.prompt_template}")
+    print(f"Num beams:            {args.num_beams}")
+    print(f"Print gate skips:     {'yes' if args.print_gate_skips else 'no'}")
+
+    base_model_rows: Dict[str, Dict[str, any]] = {}
+    baseline_ft_rows: Dict[str, Dict[str, any]] = {}
+    prompt_tuning_rows: Dict[str, Dict[str, any]] = {}
+    lora_r16_rows: Dict[str, Dict[str, any]] = {}
+    latent_reasoning_rows: Dict[str, Dict[str, any]] = {}
+
+    base_model_bundle: Optional[ModelBundle] = None
+    baseline_ft_bundle: Optional[ModelBundle] = None
+    prompt_tuning_bundle: Optional[ModelBundle] = None
+    lora_r16_bundle: Optional[ModelBundle] = None
+    latent_reasoning_bundle: Optional[ModelBundle] = None
+
+    if run_base_model:
+        try:
+            base_model_bundle = build_base_model_bundle(
+                model_id=args.model_id,
+                device=device,
+                dtype=dtype,
+            )
+            for cfg in configs:
+                language_hint = resolve_language_hint(dataset_name, cfg)
+                out = evaluate_config(
+                    model=base_model_bundle.model,
+                    processor=base_model_bundle.processor,
+                    dataset_name=dataset_name,
+                    config_name=cfg,
+                    split=args.split,
+                    use_baseline=True,
+                    mode_name="base_model",
+                    max_samples=args.max_samples_per_config,
+                    max_new_tokens=args.max_new_tokens,
+                    print_samples=args.print_samples,
+                    language_hint=language_hint,
+                    prompt_template=args.prompt_template,
+                    disable_language_hint=args.no_language_hint,
+                    num_beams=args.num_beams,
+                    dynamic_halt_threshold=args.dynamic_halt_threshold,
+                    snr_db=args.snr_db[0] if args.snr_db else None,
+                    print_gate_skips=args.print_gate_skips,
+                    streaming=args.streaming,
+                )
+                base_model_rows[cfg] = out
+                print(
+                    f"[BaseModel][{cfg}] "
+                    f"lang={out.get('language_hint') or 'auto'} "
+                    f"text_col={out.get('text_column') or '-'} "
+                    f"WER={out['wer']:.4f} CER={out['cer']:.4f} "
+                    f"n={out['samples_used']} skip={out['samples_skipped']}"
+                )
+        finally:
+            release_model(base_model_bundle)
+    else:
+        print("\n[Skip] base_model evaluation skipped (--skip-base-model).")
+
+    if run_baseline_ft:
+        try:
+            baseline_ft_bundle = build_baseline_ft_bundle(
+                model_id=args.model_id,
+                checkpoint_path=args.baseline_ckpt,
+                device=device,
+                dtype=dtype,
+            )
+            for cfg in configs:
+                language_hint = resolve_language_hint(dataset_name, cfg)
+                out = evaluate_config(
+                    model=baseline_ft_bundle.model,
+                    processor=baseline_ft_bundle.processor,
+                    dataset_name=dataset_name,
+                    config_name=cfg,
+                    split=args.split,
+                    use_baseline=True,
+                    mode_name="baseline_ft",
+                    max_samples=args.max_samples_per_config,
+                    max_new_tokens=args.max_new_tokens,
+                    print_samples=args.print_samples,
+                    language_hint=language_hint,
+                    prompt_template=args.prompt_template,
+                    disable_language_hint=args.no_language_hint,
+                    num_beams=args.num_beams,
+                    dynamic_halt_threshold=args.dynamic_halt_threshold,
+                    snr_db=args.snr_db[0] if args.snr_db else None,
+                    print_gate_skips=args.print_gate_skips,
+                    streaming=args.streaming,
+                )
+                baseline_ft_rows[cfg] = out
+                print(
+                    f"[BaselineFT][{cfg}] "
+                    f"lang={out.get('language_hint') or 'auto'} "
+                    f"text_col={out.get('text_column') or '-'} "
+                    f"WER={out['wer']:.4f} CER={out['cer']:.4f} "
+                    f"n={out['samples_used']} skip={out['samples_skipped']}"
+                )
+        finally:
+            release_model(baseline_ft_bundle)
+    else:
+        print("\n[Skip] baseline_ft evaluation skipped (no --baseline-ckpt).")
+
+    if run_prompt_tuning:
+        try:
+            prompt_tuning_bundle = build_prompt_tuning_bundle(
+                model_id=args.model_id,
+                checkpoint_path=args.prompt_tuning_ckpt,
+                device=device,
+                dtype=dtype,
+            )
+            for cfg in configs:
+                language_hint = resolve_language_hint(dataset_name, cfg)
+                out = evaluate_config(
+                    model=prompt_tuning_bundle.model,
+                    processor=prompt_tuning_bundle.processor,
+                    dataset_name=dataset_name,
+                    config_name=cfg,
+                    split=args.split,
+                    use_baseline=False,
+                    mode_name="prompt_tuning",
+                    max_samples=args.max_samples_per_config,
+                    max_new_tokens=args.max_new_tokens,
+                    print_samples=args.print_samples,
+                    language_hint=language_hint,
+                    prompt_template=args.prompt_template,
+                    disable_language_hint=args.no_language_hint,
+                    num_beams=args.num_beams,
+                    dynamic_halt_threshold=args.dynamic_halt_threshold,
+                    snr_db=args.snr_db[0] if args.snr_db else None,
+                    print_gate_skips=args.print_gate_skips,
+                    streaming=args.streaming,
+                )
+                prompt_tuning_rows[cfg] = out
+                print(
+                    f"[PromptTuning][{cfg}] "
+                    f"text_col={out.get('text_column') or '-'} "
+                    f"WER={out['wer']:.4f} CER={out['cer']:.4f} "
+                    f"n={out['samples_used']} skip={out['samples_skipped']}"
+                )
+        finally:
+            release_model(prompt_tuning_bundle)
+    else:
+        print("\n[Skip] prompt_tuning evaluation skipped (no --prompt-tuning-ckpt).")
+
+    if run_lora_r16:
+        try:
+            lora_r16_bundle = build_lora_r16_bundle(
+                model_id=args.model_id,
+                checkpoint_path=args.lora_r16_ckpt,
+                device=device,
+                dtype=dtype,
+            )
+            for cfg in configs:
+                language_hint = resolve_language_hint(dataset_name, cfg)
+                out = evaluate_config(
+                    model=lora_r16_bundle.model,
+                    processor=lora_r16_bundle.processor,
+                    dataset_name=dataset_name,
+                    config_name=cfg,
+                    split=args.split,
+                    use_baseline=True,
+                    mode_name="lora_r16",
+                    max_samples=args.max_samples_per_config,
+                    max_new_tokens=args.max_new_tokens,
+                    print_samples=args.print_samples,
+                    language_hint=language_hint,
+                    prompt_template=args.prompt_template,
+                    disable_language_hint=args.no_language_hint,
+                    num_beams=args.num_beams,
+                    dynamic_halt_threshold=args.dynamic_halt_threshold,
+                    snr_db=args.snr_db[0] if args.snr_db else None,
+                    print_gate_skips=args.print_gate_skips,
+                    streaming=args.streaming,
+                )
+                lora_r16_rows[cfg] = out
+                print(
+                    f"[LoRA-R16][{cfg}] "
+                    f"text_col={out.get('text_column') or '-'} "
+                    f"WER={out['wer']:.4f} CER={out['cer']:.4f} "
+                    f"n={out['samples_used']} skip={out['samples_skipped']}"
+                )
+        finally:
+            release_model(lora_r16_bundle)
+    else:
+        print("\n[Skip] lora_r16 evaluation skipped (no --lora-r16-ckpt).")
+
+    if run_latent_reasoning:
+        try:
+            latent_reasoning_bundle = build_latent_bundle(
+                model_id=args.model_id,
+                checkpoint_path=args.latent_ckpt,
+                n_latent_override=args.n_latent,
+                device=device,
+                dtype=dtype,
+            )
+            for cfg in configs:
+                language_hint = resolve_language_hint(dataset_name, cfg)
+                out = evaluate_config(
+                    model=latent_reasoning_bundle.model,
+                    processor=latent_reasoning_bundle.processor,
+                    dataset_name=dataset_name,
+                    config_name=cfg,
+                    split=args.split,
+                    use_baseline=False,
+                    mode_name="latent_reasoning",
+                    max_samples=args.max_samples_per_config,
+                    max_new_tokens=args.max_new_tokens,
+                    print_samples=args.print_samples,
+                    language_hint=language_hint,
+                    prompt_template=args.prompt_template,
+                    disable_language_hint=args.no_language_hint,
+                    num_beams=args.num_beams,
+                    dynamic_halt_threshold=args.dynamic_halt_threshold,
+                    snr_db=args.snr_db[0] if args.snr_db else None,
+                    print_gate_skips=args.print_gate_skips,
+                    streaming=args.streaming,
+                )
+                latent_reasoning_rows[cfg] = out
+                n_used = out['samples_used']
+                n_reasoned = out.get('samples_reasoned', 0)
+                reason_pct = (n_reasoned / n_used * 100) if n_used > 0 else 0.0
+                print(
+                    f"[LatentReasoning][{cfg}] "
+                    f"lang={out.get('language_hint') or 'auto'} "
+                    f"text_col={out.get('text_column') or '-'} "
+                    f"WER={out['wer']:.4f} CER={out['cer']:.4f} "
+                    f"n={n_used} skip={out['samples_skipped']} "
+                    f"reasoned={n_reasoned}/{n_used} ({reason_pct:.1f}%)"
+                )
+        finally:
+            release_model(latent_reasoning_bundle)
+    else:
+        print("\n[Skip] latent_reasoning evaluation skipped (no --latent-ckpt).")
+
+    merged_rows: List[Dict[str, any]] = []
+    for cfg in configs:
+        base = base_model_rows.get(cfg, {})
+        ft = baseline_ft_rows.get(cfg, {})
+        prompt = prompt_tuning_rows.get(cfg, {})
+        lora = lora_r16_rows.get(cfg, {})
+        lat = latent_reasoning_rows.get(cfg, {})
+        text_col = (
+            base.get("text_column")
+            or ft.get("text_column")
+            or prompt.get("text_column")
+            or lora.get("text_column")
+            or lat.get("text_column")
+        )
+        row = {
+            "config": cfg,
+            "samples_total": int(
+                max(
+                    base.get("samples_total", 0),
+                    ft.get("samples_total", 0),
+                    prompt.get("samples_total", 0),
+                    lora.get("samples_total", 0),
+                    lat.get("samples_total", 0),
+                )
+            ),
+            "samples_used": int(
+                max(
+                    base.get("samples_used", 0),
+                    ft.get("samples_used", 0),
+                    prompt.get("samples_used", 0),
+                    lora.get("samples_used", 0),
+                    lat.get("samples_used", 0),
+                )
+            ),
+            "text_column": text_col,
+            "base_model_wer": base.get("wer"),
+            "base_model_cer": base.get("cer"),
+            "baseline_ft_wer": ft.get("wer"),
+            "baseline_ft_cer": ft.get("cer"),
+            "prompt_tuning_wer": prompt.get("wer"),
+            "prompt_tuning_cer": prompt.get("cer"),
+            "lora_r16_wer": lora.get("wer"),
+            "lora_r16_cer": lora.get("cer"),
+            "latent_reasoning_wer": lat.get("wer"),
+            "latent_reasoning_cer": lat.get("cer"),
+            "baseline_ft_vs_base_model_wer": None
+            if base.get("wer") is None or ft.get("wer") is None
+            else float(base["wer"] - ft["wer"]),
+            "baseline_ft_vs_base_model_cer": None
+            if base.get("cer") is None or ft.get("cer") is None
+            else float(base["cer"] - ft["cer"]),
+            "prompt_tuning_vs_base_model_wer": None
+            if base.get("wer") is None or prompt.get("wer") is None
+            else float(base["wer"] - prompt["wer"]),
+            "prompt_tuning_vs_base_model_cer": None
+            if base.get("cer") is None or prompt.get("cer") is None
+            else float(base["cer"] - prompt["cer"]),
+            "lora_r16_vs_base_model_wer": None
+            if base.get("wer") is None or lora.get("wer") is None
+            else float(base["wer"] - lora["wer"]),
+            "lora_r16_vs_base_model_cer": None
+            if base.get("cer") is None or lora.get("cer") is None
+            else float(base["cer"] - lora["cer"]),
+            "latent_reasoning_vs_base_model_wer": None
+            if base.get("wer") is None or lat.get("wer") is None
+            else float(base["wer"] - lat["wer"]),
+            "latent_reasoning_vs_base_model_cer": None
+            if base.get("cer") is None or lat.get("cer") is None
+            else float(base["cer"] - lat["cer"]),
+            "latent_reasoning_vs_baseline_ft_wer": None
+            if ft.get("wer") is None or lat.get("wer") is None
+            else float(ft["wer"] - lat["wer"]),
+            "latent_reasoning_vs_baseline_ft_cer": None
+            if ft.get("cer") is None or lat.get("cer") is None
+            else float(ft["cer"] - lat["cer"]),
+            "latent_reasoning_vs_prompt_tuning_wer": None
+            if prompt.get("wer") is None or lat.get("wer") is None
+            else float(prompt["wer"] - lat["wer"]),
+            "latent_reasoning_vs_prompt_tuning_cer": None
+            if prompt.get("cer") is None or lat.get("cer") is None
+            else float(prompt["cer"] - lat["cer"]),
+            "latent_reasoning_vs_lora_r16_wer": None
+            if lora.get("wer") is None or lat.get("wer") is None
+            else float(lora["wer"] - lat["wer"]),
+            "latent_reasoning_vs_lora_r16_cer": None
+            if lora.get("cer") is None or lat.get("cer") is None
+            else float(lora["cer"] - lat["cer"]),
+        }
+        merged_rows.append(row)
+
+    print_summary_table(merged_rows)
+
+    base_list = [base_model_rows[c] for c in configs if c in base_model_rows]
+    ft_list = [baseline_ft_rows[c] for c in configs if c in baseline_ft_rows]
+    prompt_list = [prompt_tuning_rows[c] for c in configs if c in prompt_tuning_rows]
+    lora_list = [lora_r16_rows[c] for c in configs if c in lora_r16_rows]
+    lat_list = [latent_reasoning_rows[c] for c in configs if c in latent_reasoning_rows]
+    summary = {
+        "base_model_weighted_wer": weighted_avg(base_list, "wer"),
+        "base_model_weighted_cer": weighted_avg(base_list, "cer"),
+        "baseline_ft_weighted_wer": weighted_avg(ft_list, "wer"),
+        "baseline_ft_weighted_cer": weighted_avg(ft_list, "cer"),
+        "prompt_tuning_weighted_wer": weighted_avg(prompt_list, "wer"),
+        "prompt_tuning_weighted_cer": weighted_avg(prompt_list, "cer"),
+        "lora_r16_weighted_wer": weighted_avg(lora_list, "wer"),
+        "lora_r16_weighted_cer": weighted_avg(lora_list, "cer"),
+        "latent_reasoning_weighted_wer": weighted_avg(lat_list, "wer"),
+        "latent_reasoning_weighted_cer": weighted_avg(lat_list, "cer"),
+    }
+    if summary["base_model_weighted_wer"] is not None and summary["baseline_ft_weighted_wer"] is not None:
+        summary["baseline_ft_vs_base_model_weighted_wer"] = (
+            summary["base_model_weighted_wer"] - summary["baseline_ft_weighted_wer"]
+        )
+    else:
+        summary["baseline_ft_vs_base_model_weighted_wer"] = None
+    if summary["base_model_weighted_cer"] is not None and summary["baseline_ft_weighted_cer"] is not None:
+        summary["baseline_ft_vs_base_model_weighted_cer"] = (
+            summary["base_model_weighted_cer"] - summary["baseline_ft_weighted_cer"]
+        )
+    else:
+        summary["baseline_ft_vs_base_model_weighted_cer"] = None
+
+    if summary["base_model_weighted_wer"] is not None and summary["latent_reasoning_weighted_wer"] is not None:
+        summary["latent_reasoning_vs_base_model_weighted_wer"] = (
+            summary["base_model_weighted_wer"] - summary["latent_reasoning_weighted_wer"]
+        )
+    else:
+        summary["latent_reasoning_vs_base_model_weighted_wer"] = None
+    if summary["base_model_weighted_cer"] is not None and summary["latent_reasoning_weighted_cer"] is not None:
+        summary["latent_reasoning_vs_base_model_weighted_cer"] = (
+            summary["base_model_weighted_cer"] - summary["latent_reasoning_weighted_cer"]
+        )
+    else:
+        summary["latent_reasoning_vs_base_model_weighted_cer"] = None
+
+    if summary["baseline_ft_weighted_wer"] is not None and summary["latent_reasoning_weighted_wer"] is not None:
+        summary["latent_reasoning_vs_baseline_ft_weighted_wer"] = (
+            summary["baseline_ft_weighted_wer"] - summary["latent_reasoning_weighted_wer"]
+        )
+    else:
+        summary["latent_reasoning_vs_baseline_ft_weighted_wer"] = None
+    if summary["baseline_ft_weighted_cer"] is not None and summary["latent_reasoning_weighted_cer"] is not None:
+        summary["latent_reasoning_vs_baseline_ft_weighted_cer"] = (
+            summary["baseline_ft_weighted_cer"] - summary["latent_reasoning_weighted_cer"]
+        )
+    else:
+        summary["latent_reasoning_vs_baseline_ft_weighted_cer"] = None
+
+    if summary["base_model_weighted_wer"] is not None and summary["prompt_tuning_weighted_wer"] is not None:
+        summary["prompt_tuning_vs_base_model_weighted_wer"] = (
+            summary["base_model_weighted_wer"] - summary["prompt_tuning_weighted_wer"]
+        )
+    else:
+        summary["prompt_tuning_vs_base_model_weighted_wer"] = None
+    if summary["base_model_weighted_cer"] is not None and summary["prompt_tuning_weighted_cer"] is not None:
+        summary["prompt_tuning_vs_base_model_weighted_cer"] = (
+            summary["base_model_weighted_cer"] - summary["prompt_tuning_weighted_cer"]
+        )
+    else:
+        summary["prompt_tuning_vs_base_model_weighted_cer"] = None
+
+    if summary["base_model_weighted_wer"] is not None and summary["lora_r16_weighted_wer"] is not None:
+        summary["lora_r16_vs_base_model_weighted_wer"] = (
+            summary["base_model_weighted_wer"] - summary["lora_r16_weighted_wer"]
+        )
+    else:
+        summary["lora_r16_vs_base_model_weighted_wer"] = None
+    if summary["base_model_weighted_cer"] is not None and summary["lora_r16_weighted_cer"] is not None:
+        summary["lora_r16_vs_base_model_weighted_cer"] = (
+            summary["base_model_weighted_cer"] - summary["lora_r16_weighted_cer"]
+        )
+    else:
+        summary["lora_r16_vs_base_model_weighted_cer"] = None
+
+    if summary["prompt_tuning_weighted_wer"] is not None and summary["latent_reasoning_weighted_wer"] is not None:
+        summary["latent_reasoning_vs_prompt_tuning_weighted_wer"] = (
+            summary["prompt_tuning_weighted_wer"] - summary["latent_reasoning_weighted_wer"]
+        )
+    else:
+        summary["latent_reasoning_vs_prompt_tuning_weighted_wer"] = None
+    if summary["prompt_tuning_weighted_cer"] is not None and summary["latent_reasoning_weighted_cer"] is not None:
+        summary["latent_reasoning_vs_prompt_tuning_weighted_cer"] = (
+            summary["prompt_tuning_weighted_cer"] - summary["latent_reasoning_weighted_cer"]
+        )
+    else:
+        summary["latent_reasoning_vs_prompt_tuning_weighted_cer"] = None
+
+    if summary["lora_r16_weighted_wer"] is not None and summary["latent_reasoning_weighted_wer"] is not None:
+        summary["latent_reasoning_vs_lora_r16_weighted_wer"] = (
+            summary["lora_r16_weighted_wer"] - summary["latent_reasoning_weighted_wer"]
+        )
+    else:
+        summary["latent_reasoning_vs_lora_r16_weighted_wer"] = None
+    if summary["lora_r16_weighted_cer"] is not None and summary["latent_reasoning_weighted_cer"] is not None:
+        summary["latent_reasoning_vs_lora_r16_weighted_cer"] = (
+            summary["lora_r16_weighted_cer"] - summary["latent_reasoning_weighted_cer"]
+        )
+    else:
+        summary["latent_reasoning_vs_lora_r16_weighted_cer"] = None
+
+    print("\n=== Weighted Summary ===")
+    for k, v in summary.items():
+        if v is None:
+            print(f"{k}: -")
+        else:
+            print(f"{k}: {v:.6f}")
+
+    if args.output_json:
+        payload = {
+            "model_id": args.model_id,
+            "dataset_name": dataset_name,
+            "dataset_name_input": args.dataset_name,
+            "split": args.split,
+            "configs": configs,
+            "streaming": args.streaming,
+            "text_normalizer": args.text_normalizer,
+            "base_model_enabled": run_base_model,
+            "baseline_checkpoint": args.baseline_ckpt,
+            "prompt_tuning_checkpoint": args.prompt_tuning_ckpt,
+            "lora_r16_checkpoint": args.lora_r16_ckpt,
+            "latent_reasoning_checkpoint": args.latent_ckpt,
+            "latent_checkpoint": args.latent_ckpt,
+            "rows": merged_rows,
+            "summary": summary,
+        }
+        with open(args.output_json, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        print(f"\nSaved JSON: {args.output_json}")
+
+
+if __name__ == "__main__":
+    main()

examples/transcribe_file.py

@@ -0,0 +1,85 @@
+"""Transcribe one audio file with the released LatentASR adapter."""
+
+from __future__ import annotations
+
+import argparse
+
+import torch
+from datasets import Audio
+
+from eval import build_latent_bundle, choose_device, choose_dtype, clean_prediction
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Transcribe one audio file with LatentASR.")
+    parser.add_argument("audio", help="Path to an audio file.")
+    parser.add_argument("--model-id", default="Qwen/Qwen3-ASR-0.6B")
+    parser.add_argument("--latent-ckpt", default="checkpoints/latentASR_adapter.pth")
+    parser.add_argument("--theta", type=float, default=0.0, help="Dynamic halting threshold.")
+    parser.add_argument("--max-new-tokens", type=int, default=128)
+    parser.add_argument("--device", default="auto", choices=["auto", "cuda", "cpu"])
+    parser.add_argument("--dtype", default="auto", choices=["auto", "float32", "float16", "bfloat16"])
+    parser.add_argument("--language", default="English")
+    return parser.parse_args()
+
+
+@torch.no_grad()
+def main() -> None:
+    args = parse_args()
+    device = choose_device(args.device)
+    dtype = choose_dtype(args.dtype, device)
+    bundle = build_latent_bundle(
+        model_id=args.model_id,
+        checkpoint_path=args.latent_ckpt,
+        n_latent_override=-1,
+        device=device,
+        dtype=dtype,
+    )
+    model = bundle.model
+    processor = bundle.processor
+
+    target_sr = int(getattr(processor.feature_extractor, "sampling_rate", 16000) or 16000)
+    audio = Audio(sampling_rate=target_sr).decode_example({"path": args.audio})
+    feat_out = processor.feature_extractor(
+        audio["array"],
+        sampling_rate=audio["sampling_rate"],
+        return_attention_mask=True,
+    )
+    target_dtype = model.thinker.dtype if hasattr(model.thinker, "dtype") else torch.float32
+    feats = torch.tensor(
+        feat_out.input_features[0],
+        dtype=target_dtype,
+        device=model.base_model.device,
+    ).unsqueeze(0)
+    n_frames = feats.size(-1)
+    if getattr(feat_out, "attention_mask", None) is not None:
+        mask = torch.tensor(feat_out.attention_mask[0], dtype=torch.long)
+        if mask.size(-1) < n_frames:
+            mask = torch.cat([mask, torch.zeros(n_frames - mask.size(-1), dtype=torch.long)])
+        else:
+            mask = mask[:n_frames]
+        feature_attention_mask = mask.to(device=model.base_model.device).unsqueeze(0)
+    else:
+        feature_attention_mask = torch.ones((1, n_frames), dtype=torch.long, device=model.base_model.device)
+
+    gen_ids, stats = model.generate(
+        feats,
+        feature_attention_mask=feature_attention_mask,
+        max_new_tokens=args.max_new_tokens,
+        use_baseline=False,
+        return_stats=True,
+        do_sample=False,
+        eos_token_id=model.stop_ids,
+        num_beams=1,
+        language_hint=args.language,
+        dynamic_halt_threshold=args.theta,
+    )
+    text = clean_prediction(processor.tokenizer.decode(gen_ids[0], skip_special_tokens=True))
+    steps = int(stats.get("deq_iters", torch.tensor(0)).item()) if isinstance(stats, dict) else -1
+    print(text)
+    print(f"[latent_steps={steps} theta={args.theta}]")
+
+
+if __name__ == "__main__":
+    main()
+

experiments/README.md

@@ -0,0 +1,28 @@
+# Experiment Runners
+
+This directory contains the maintained entrypoints for LatentASR experiments.
+All runners default to Qwen/Qwen3-ASR-0.6B and `./latent_qwen_asr_best.pth`.
+The checkpoint itself is intentionally ignored by Git.
+
+## Runners
+
+- `run_english_clean_and_noise.sh`: English clean suite plus optional SNR noise sweeps.
+- `run_multilingual_streaming.sh`: FLEURS 30 and MLS public7 streaming evaluation.
+- `run_threshold_sweep.sh`: Value-head halting threshold sweep.
+- `run_all_training_modes.sh`: Sequential baseline, prompt tuning, LoRA, and LatentASR training.
+- `run_legacy_generalization.sh`: older SpeechTest generalization/noise runner kept for reproducibility.
+
+Root-level scripts with the old names are thin compatibility wrappers around
+these maintained files.
+
+## Common Environment Variables
+
+- `LATENT_CKPT`: latent adapter checkpoint path.
+- `MODEL_ID`: HuggingFace model ID.
+- `PYTHON_BIN`: Python executable override.
+- `MAX_SAMPLES_PER_CONFIG`: per-config cap; `0` means full split.
+- `OUT_DIR`: output directory.
+- `RESUME=1`: skip JSON outputs that already exist.
+
+Full experimental JSON/log outputs are written under `eval_runs/` and are not
+committed to Git.

experiments/eval_paper_tbd_checkpoints.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Evaluate checkpoints produced by run_paper_tbd_retrain.sh for the TBD paper
+# tables. This script intentionally does not override --n-latent; eval.py reads
+# the latent budget from each checkpoint, which is required for the N sweep.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+MODEL_ID="${MODEL_ID:-Qwen/Qwen3-ASR-0.6B}"
+CKPT_ROOT="${CKPT_ROOT:-${ROOT_DIR}/eval_runs/paper_tbd_retrain_20260518/checkpoints}"
+BASELINE_DIR="${BASELINE_DIR:-${ROOT_DIR}/eval_runs/hf_asr_showcase_full_20260503_152506}"
+N4_CKPT="${N4_CKPT:-}"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+OUT_DIR="${OUT_DIR:-${ROOT_DIR}/eval_runs/paper_tbd_eval_${TIMESTAMP}}"
+LOG_DIR="${OUT_DIR}/logs"
+mkdir -p "${LOG_DIR}"
+
+MAX_SAMPLES_PER_CONFIG="${MAX_SAMPLES_PER_CONFIG:-0}"
+MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-128}"
+PRINT_SAMPLES="${PRINT_SAMPLES:-0}"
+STREAMING="${STREAMING:-1}"
+RESUME="${RESUME:-1}"
+
+# Optional filters are regexes over the variant/dataset/theta tags.
+VARIANT_FILTER="${VARIANT_FILTER:-}"
+DATASET_FILTER="${DATASET_FILTER:-}"
+THETA_FILTER="${THETA_FILTER:-}"
+
+run_eval() {
+  local variant="$1"
+  local ckpt="$2"
+  local dataset_tag="$3"
+  local dataset_name="$4"
+  local configs="$5"
+  local theta_label="$6"
+  local theta_value="$7"
+
+  if [[ -n "${VARIANT_FILTER}" && ! "${variant}" =~ ${VARIANT_FILTER} ]]; then
+    return 0
+  fi
+  if [[ -n "${DATASET_FILTER}" && ! "${dataset_tag}" =~ ${DATASET_FILTER} ]]; then
+    return 0
+  fi
+  if [[ -n "${THETA_FILTER}" && ! "${theta_label}" =~ ${THETA_FILTER} ]]; then
+    return 0
+  fi
+
+  latent_asr_require_file "${ckpt}" "checkpoint for ${variant}"
+
+  local json_out="${OUT_DIR}/${variant}_${dataset_tag}_theta_${theta_label}.json"
+  local log_out="${LOG_DIR}/${variant}_${dataset_tag}_theta_${theta_label}.log"
+  if [[ "${RESUME}" == "1" && -f "${json_out}" ]]; then
+    echo "[skip] existing ${json_out}"
+    return 0
+  fi
+
+  local args=(
+    --model-id "${MODEL_ID}"
+    --dataset-name "${dataset_name}"
+    --configs "${configs}"
+    --split test
+    --output-json "${json_out}"
+    --max-samples-per-config "${MAX_SAMPLES_PER_CONFIG}"
+    --max-new-tokens "${MAX_NEW_TOKENS}"
+    --latent-ckpt "${ckpt}"
+    --num-beams 1
+    --dynamic-halt-threshold "${theta_value}"
+    --print-samples "${PRINT_SAMPLES}"
+    --skip-base-model
+    --skip-baseline-ft
+    --skip-prompt-tuning
+    --skip-lora-r16
+  )
+  if [[ "${STREAMING}" == "1" ]]; then
+    args+=(--streaming)
+  fi
+
+  echo "------------------------------------------------------------"
+  echo "Variant   : ${variant}"
+  echo "Dataset   : ${dataset_tag} (${dataset_name}/${configs})"
+  echo "Theta     : ${theta_label} (${theta_value})"
+  echo "Checkpoint: ${ckpt}"
+  echo "JSON      : ${json_out}"
+  echo "LOG       : ${log_out}"
+  "${PYTHON_BIN}" eval.py "${args[@]}" 2>&1 | tee "${log_out}"
+}
+
+ckpt_epoch10() {
+  local variant="$1"
+  printf '%s/%s/%s_epoch10.pth' "${CKPT_ROOT}" "${variant}" "${variant}"
+}
+if [[ -z "${N4_CKPT}" ]]; then
+  N4_CKPT="$(ckpt_epoch10 n4)"
+fi
+
+echo "============================================================"
+echo "LatentASR TBD Paper Evaluation"
+echo "============================================================"
+echo "Root dir       : ${ROOT_DIR}"
+echo "Checkpoint dir : ${CKPT_ROOT}"
+echo "Output dir     : ${OUT_DIR}"
+echo "Baseline dir   : ${BASELINE_DIR}"
+echo "N=4 ckpt       : ${N4_CKPT}"
+echo "Python         : ${PYTHON_BIN}"
+echo "Streaming      : ${STREAMING}"
+echo "Max/config     : ${MAX_SAMPLES_PER_CONFIG}"
+echo "Variant filter : ${VARIANT_FILTER:-(none)}"
+echo "Dataset filter : ${DATASET_FILTER:-(none)}"
+echo "Theta filter   : ${THETA_FILTER:-(none)}"
+echo "============================================================"
+
+# Component ablation: FLEURS only, deployed threshold.
+for variant in component_no_bounded component_no_gate component_no_anchor; do
+  run_eval "${variant}" "$(ckpt_epoch10 "${variant}")" \
+    fleurs google/fleurs en_us zero 0.0
+done
+
+# N sweep: FLEURS and VoxPopuli, deployed threshold.
+for variant in n1 n2 n8; do
+  ckpt="$(ckpt_epoch10 "${variant}")"
+  run_eval "${variant}" "${ckpt}" fleurs google/fleurs en_us zero 0.0
+  run_eval "${variant}" "${ckpt}" voxpopuli facebook/voxpopuli en zero 0.0
+done
+run_eval n4 "${N4_CKPT}" fleurs google/fleurs en_us zero 0.0
+run_eval n4 "${N4_CKPT}" voxpopuli facebook/voxpopuli en zero 0.0
+
+# Forced-negative ablation: FLEURS threshold sweep.
+for spec in full:-2.0 neg0p2:-0.2 zero:0.0 pos0p2:0.2 pos0p5:0.5; do
+  IFS=':' read -r theta_label theta_value <<< "${spec}"
+  run_eval pneg0 "$(ckpt_epoch10 pneg0)" \
+    fleurs google/fleurs en_us "${theta_label}" "${theta_value}"
+done
+
+# Activation set scaling.
+for variant in \
+  activation_100 \
+  activation_200 \
+  activation_300 \
+  activation_400 \
+  activation_500 \
+  activation_600 \
+  activation_700 \
+  activation_800
+do
+  ckpt="$(ckpt_epoch10 "${variant}")"
+  run_eval "${variant}" "${ckpt}" fleurs google/fleurs en_us zero 0.0
+  run_eval "${variant}" "${ckpt}" voxpopuli facebook/voxpopuli en zero 0.0
+done
+
+"${PYTHON_BIN}" scripts/summarize_paper_tbd.py "${OUT_DIR}" --baseline-dir "${BASELINE_DIR}"
+
+echo "Outputs: ${OUT_DIR}"

experiments/lib/common.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+
+# Shared shell helpers for LatentASR experiment runners.
+# This file is sourced by scripts under experiments/.
+
+latent_asr_repo_root() {
+  local script_dir="$1"
+  cd "${script_dir}/.." && pwd
+}
+
+latent_asr_python_bin() {
+  local requested="${1:-}"
+  if [[ -n "${requested}" ]]; then
+    printf '%s\n' "${requested}"
+  elif [[ -x "/user_data/miniconda3/envs/py311/bin/python" ]]; then
+    printf '%s\n' "/user_data/miniconda3/envs/py311/bin/python"
+  else
+    printf '%s\n' "python"
+  fi
+}
+
+latent_asr_require_file() {
+  local path="$1"
+  local label="$2"
+  if [[ ! -f "${path}" ]]; then
+    echo "[error] ${label} not found: ${path}" >&2
+    exit 1
+  fi
+}
+
+latent_asr_print_kv() {
+  local key="$1"
+  local value="$2"
+  printf '%-16s: %s\n' "${key}" "${value}"
+}

experiments/run_all_training_modes.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# ==============================================================================
+# run_all_modes.sh — 依序跑 LoRA、Prompt Tuning、Baseline Fine-tune、Latent Reasoning
+#
+# 每個 mode 獨立訓練，checkpoint 存在各自的目錄。
+# 用法：
+#   bash run_all_modes.sh              # 用預設設定
+#   NUM_EPOCHS=5 bash run_all_modes.sh  # 自訂 epoch 數
+# ==============================================================================
+set -euo pipefail
+
+# ---------- 共用設定（可透過環境變數覆蓋）----------
+export MODEL_ID="${MODEL_ID:-Qwen/Qwen3-ASR-0.6B}"
+export DATASET_NAME="${DATASET_NAME:-SpeechTest/extreme_asr_pony}"
+export DATASET_CONFIG="${DATASET_CONFIG:-default}"
+export BATCH_SIZE="${BATCH_SIZE:-4}"
+export GRAD_ACCUM_STEPS="${GRAD_ACCUM_STEPS:-4}"
+export NUM_EPOCHS="${NUM_EPOCHS:-10}"
+export EVAL_SAMPLES="${EVAL_SAMPLES:-1000}"
+export PRETRAIN_EVAL_SAMPLES="${PRETRAIN_EVAL_SAMPLES:-10}"
+export TRAIN_MAX_SAMPLES="${TRAIN_MAX_SAMPLES:-500}"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+TRAIN_PY="${ROOT_DIR}/train.py"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+LOG_DIR="${ROOT_DIR}/logs/${TIMESTAMP}"
+mkdir -p "${LOG_DIR}"
+
+echo "=============================================="
+echo " Sequential Training — ${TIMESTAMP}"
+echo "  Model:   ${MODEL_ID}"
+echo "  Dataset:  ${DATASET_NAME} / ${DATASET_CONFIG}"
+echo "  Epochs:  ${NUM_EPOCHS}"
+echo "  Train max: ${TRAIN_MAX_SAMPLES}"
+echo "  Logs:    ${LOG_DIR}"
+echo "=============================================="
+
+# ---------- 1. LoRA (rank=16) ----------
+echo ""
+echo ">>> [1/4] Training: lora_r16"
+echo "----------------------------------------------"
+export TRAIN_MODE=lora_r16
+LOG_FILE="${LOG_DIR}/lora_r16.log"
+
+"${PYTHON_BIN}" "${TRAIN_PY}" 2>&1 | tee "${LOG_FILE}"
+LORA_EXIT=$?
+
+if [ ${LORA_EXIT} -ne 0 ]; then
+    echo "[FAIL] lora_r16 exited with code ${LORA_EXIT}"
+else
+    echo "[DONE] lora_r16 completed successfully"
+fi
+
+# ---------- 2. Prompt Tuning ----------
+echo ""
+echo ">>> [2/4] Training: prompt_tuning"
+echo "----------------------------------------------"
+export TRAIN_MODE=prompt_tuning
+LOG_FILE="${LOG_DIR}/prompt_tuning.log"
+
+"${PYTHON_BIN}" "${TRAIN_PY}" 2>&1 | tee "${LOG_FILE}"
+PT_EXIT=$?
+
+if [ ${PT_EXIT} -ne 0 ]; then
+    echo "[FAIL] prompt_tuning exited with code ${PT_EXIT}"
+else
+    echo "[DONE] prompt_tuning completed successfully"
+fi
+
+# ---------- 3. Baseline Fine-tune ----------
+echo ""
+echo ">>> [3/4] Training: baseline (full fine-tune)"
+echo "----------------------------------------------"
+export TRAIN_MODE=baseline
+LOG_FILE="${LOG_DIR}/baseline.log"
+
+"${PYTHON_BIN}" "${TRAIN_PY}" 2>&1 | tee "${LOG_FILE}"
+BL_EXIT=$?
+
+if [ ${BL_EXIT} -ne 0 ]; then
+    echo "[FAIL] baseline exited with code ${BL_EXIT}"
+else
+    echo "[DONE] baseline completed successfully"
+fi
+
+# ---------- 4. Latent Reasoning ----------
+echo ""
+echo ">>> [4/4] Training: latent (latent reasoning)"
+echo "----------------------------------------------"
+export TRAIN_MODE=latent
+LOG_FILE="${LOG_DIR}/latent.log"
+
+"${PYTHON_BIN}" "${TRAIN_PY}" 2>&1 | tee "${LOG_FILE}"
+LR_EXIT=$?
+
+if [ ${LR_EXIT} -ne 0 ]; then
+    echo "[FAIL] latent exited with code ${LR_EXIT}"
+else
+    echo "[DONE] latent completed successfully"
+fi
+
+# ---------- Summary ----------
+echo ""
+echo "=============================================="
+echo " Training Summary"
+echo "=============================================="
+echo "  lora_r16:      exit=${LORA_EXIT:-skipped}"
+echo "  prompt_tuning: exit=${PT_EXIT:-skipped}"
+echo "  baseline:      exit=${BL_EXIT}"
+echo "  latent:        exit=${LR_EXIT}"
+echo "  Logs: ${LOG_DIR}/"
+echo "=============================================="
+
+# Print best WER from each log if available
+for mode in lora_r16 prompt_tuning baseline latent; do
+    logf="${LOG_DIR}/${mode}.log"
+    if [ -f "${logf}" ]; then
+        best=$(grep -i "best.*wer" "${logf}" | tail -1 || true)
+        if [ -n "${best}" ]; then
+            echo "  ${mode}: ${best}"
+        fi
+    fi
+done

experiments/run_english_clean_and_noise.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Run a small-to-medium HuggingFace ASR showcase for latent reasoning.
+#
+# Goal:
+#   1. Start with small, recognizable HF ASR datasets.
+#   2. Compare raw base_model vs latent_reasoning only.
+#   3. Include optional noisy SNR stress cases where LR benefits are easier to see.
+#
+# Fast discovery:
+#   ./run_lr_hf_asr_showcase.sh
+#
+# Full confirmation after finding promising cases:
+#   MAX_SAMPLES_PER_CONFIG=0 SNR_DB_LEVELS="5 0" ./run_lr_hf_asr_showcase.sh
+#
+# Filter cases:
+#   CASE_FILTER='fleurs|tedlium' ./run_lr_hf_asr_showcase.sh
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+
+LATENT_CKPT="${LATENT_CKPT:-./latent_qwen_asr_best.pth}"
+MODEL_ID="${MODEL_ID:-Qwen/Qwen3-ASR-0.6B}"
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+DYNAMIC_HALT_THRESHOLD="${DYNAMIC_HALT_THRESHOLD:-0.0}"
+MAX_SAMPLES_PER_CONFIG="${MAX_SAMPLES_PER_CONFIG:-500}"
+MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-128}"
+PRINT_SAMPLES="${PRINT_SAMPLES:-0}"
+RUN_CLEAN="${RUN_CLEAN:-1}"
+SNR_DB_LEVELS="${SNR_DB_LEVELS-10 5 0}"
+CASE_FILTER="${CASE_FILTER:-}"
+RESUME="${RESUME:-1}"
+SNR_LEVEL_ARRAY=()
+if [[ -n "${SNR_DB_LEVELS}" ]]; then
+  read -r -a SNR_LEVEL_ARRAY <<< "${SNR_DB_LEVELS}"
+fi
+
+latent_asr_require_file "${LATENT_CKPT}" "latent checkpoint"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+OUT_DIR="${OUT_DIR:-${ROOT_DIR}/eval_runs/hf_asr_showcase_${TIMESTAMP}}"
+LOG_DIR="${OUT_DIR}/logs"
+mkdir -p "${LOG_DIR}"
+
+# Format: tag|dataset|configs|split
+# Ordered roughly small/quick first, then broader canonical benchmarks.
+HF_ASR_CASES=(
+  "fleurs_en_us|google/fleurs|en_us|test"
+  "minds14_en_us|PolyAI/minds14|en-US|train"
+  "tedlium_release1|TwinkStart/tedlium|release1|test"
+  "voxpopuli_en|facebook/voxpopuli|en|test"
+  "librispeech_clean_other|openslr/librispeech_asr|clean,other|test"
+)
+
+EXTRA_ARGS=("$@")
+
+run_case() {
+  local tag="$1"
+  local dataset="$2"
+  local configs="$3"
+  local split="$4"
+  local condition="$5"
+  local snr="$6"
+
+  local json_out="${OUT_DIR}/${tag}_${condition}.json"
+  local log_out="${LOG_DIR}/${tag}_${condition}.log"
+
+  if [[ "${RESUME}" == "1" && -f "${json_out}" ]]; then
+    echo "[skip] existing ${json_out}"
+    return 0
+  fi
+
+  local args=(
+    --model-id "${MODEL_ID}"
+    --dataset-name "${dataset}"
+    --configs "${configs}"
+    --split "${split}"
+    --output-json "${json_out}"
+    --max-samples-per-config "${MAX_SAMPLES_PER_CONFIG}"
+    --max-new-tokens "${MAX_NEW_TOKENS}"
+    --latent-ckpt "${LATENT_CKPT}"
+    --n-latent 4
+    --num-beams 1
+    --dynamic-halt-threshold "${DYNAMIC_HALT_THRESHOLD}"
+    --print-samples "${PRINT_SAMPLES}"
+    --skip-baseline-ft
+    --skip-prompt-tuning
+    --skip-lora-r16
+  )
+
+  if [[ -n "${snr}" ]]; then
+    args+=(--snr-db "${snr}")
+  fi
+
+  echo "------------------------------------------------------------"
+  echo "Case      : ${tag}"
+  echo "Dataset   : ${dataset}"
+  echo "Configs   : ${configs}"
+  echo "Split     : ${split}"
+  echo "Condition : ${condition}"
+  echo "JSON      : ${json_out}"
+  echo "LOG       : ${log_out}"
+
+  "${PYTHON_BIN}" eval.py "${args[@]}" "${EXTRA_ARGS[@]}" 2>&1 | tee "${log_out}"
+}
+
+echo "============================================================"
+echo "Latent Reasoning HuggingFace ASR Showcase"
+echo "============================================================"
+echo "Root dir       : ${ROOT_DIR}"
+echo "Output dir     : ${OUT_DIR}"
+echo "Python         : ${PYTHON_BIN}"
+echo "Model          : ${MODEL_ID}"
+echo "Latent ckpt    : ${LATENT_CKPT}"
+echo "Halt threshold : ${DYNAMIC_HALT_THRESHOLD}"
+echo "Max/config     : ${MAX_SAMPLES_PER_CONFIG}"
+echo "Clean pass     : ${RUN_CLEAN}"
+echo "SNR levels     : ${SNR_DB_LEVELS:-(none)}"
+echo "Case filter    : ${CASE_FILTER:-(none)}"
+echo "Extra args     : ${EXTRA_ARGS[*]:-(none)}"
+echo "============================================================"
+
+SUCCESS=()
+FAILED=()
+
+for entry in "${HF_ASR_CASES[@]}"; do
+  IFS='|' read -r TAG DATASET CONFIGS SPLIT <<< "${entry}"
+
+  if [[ -n "${CASE_FILTER}" && ! "${TAG}" =~ ${CASE_FILTER} ]]; then
+    continue
+  fi
+
+  if [[ "${RUN_CLEAN}" == "1" ]]; then
+    if run_case "${TAG}" "${DATASET}" "${CONFIGS}" "${SPLIT}" "clean" ""; then
+      SUCCESS+=("${TAG}:clean")
+    else
+      FAILED+=("${TAG}:clean")
+    fi
+  fi
+
+  for SNR in "${SNR_LEVEL_ARRAY[@]}"; do
+    CONDITION="snr${SNR}db"
+    if run_case "${TAG}" "${DATASET}" "${CONFIGS}" "${SPLIT}" "${CONDITION}" "${SNR}"; then
+      SUCCESS+=("${TAG}:${CONDITION}")
+    else
+      FAILED+=("${TAG}:${CONDITION}")
+    fi
+  done
+done
+
+echo ""
+echo "============================================================"
+echo "Showcase Summary"
+echo "============================================================"
+echo "Succeeded (${#SUCCESS[@]}):"
+for item in "${SUCCESS[@]}"; do
+  echo "  - ${item}"
+done
+echo "Failed (${#FAILED[@]}):"
+for item in "${FAILED[@]}"; do
+  echo "  - ${item}"
+done
+
+"${PYTHON_BIN}" scripts/summarize_lr_showcase.py "${OUT_DIR}"
+echo "Outputs: ${OUT_DIR}"
+echo "============================================================"

experiments/run_multilingual_streaming.sh

@@ -0,0 +1,152 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Multilingual ASR evaluation aligned with Qwen3-ASR public benchmark families.
+#
+# This runner always passes --streaming so HuggingFace datasets are read lazily
+# instead of materializing full audio splits under the local cache.
+#
+# Default run:
+#   ./run_lr_multilingual_asr_streaming.sh
+#
+# Run every configured case:
+#   CASE_FILTER='' ./run_lr_multilingual_asr_streaming.sh
+#
+# Quick smoke test:
+#   MAX_SAMPLES_PER_CONFIG=20 CASE_FILTER='fleurs_core12' ./run_lr_multilingual_asr_streaming.sh
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+
+LATENT_CKPT="${LATENT_CKPT:-./latent_qwen_asr_best.pth}"
+MODEL_ID="${MODEL_ID:-Qwen/Qwen3-ASR-0.6B}"
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+
+DYNAMIC_HALT_THRESHOLD="${DYNAMIC_HALT_THRESHOLD:-0.0}"
+MAX_SAMPLES_PER_CONFIG="${MAX_SAMPLES_PER_CONFIG:-0}"
+MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-128}"
+PRINT_SAMPLES="${PRINT_SAMPLES:-0}"
+TEXT_NORMALIZER="${TEXT_NORMALIZER:-basic}"
+RESUME="${RESUME:-1}"
+
+# Default to the 30-language FLEURS grouping from the Qwen3-ASR card.
+# Set CASE_FILTER='' to also run the public MLS case below.
+CASE_FILTER="${CASE_FILTER:-fleurs_core12|fleurs_extra8|fleurs_extra10}"
+
+latent_asr_require_file "${LATENT_CKPT}" "latent checkpoint"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+OUT_DIR="${OUT_DIR:-${ROOT_DIR}/eval_runs/multilingual_asr_streaming_${TIMESTAMP}}"
+LOG_DIR="${OUT_DIR}/logs"
+mkdir -p "${LOG_DIR}"
+
+# Format: tag|dataset|configs|split
+# Qwen3-ASR public multilingual ASR benchmark families include FLEURS,
+# CommonVoice, MLS, and MLC-SLM. FLEURS is the broadest open HF target here.
+# HuggingFace facebook/multilingual_librispeech currently exposes seven
+# non-English MLS configs; English is covered separately by LibriSpeech runs.
+MULTILINGUAL_CASES=(
+  "fleurs_core12|google/fleurs|en,zh,yue,ar,de,es,fr,it,ja,ko,pt,ru|test"
+  "fleurs_extra8|google/fleurs|hi,id,ms,nl,pl,th,tr,vi|test"
+  "fleurs_extra10|google/fleurs|cs,da,el,fa,fi,fil,hu,mk,ro,sv|test"
+  "mls_public7|facebook/multilingual_librispeech|de,nl,es,fr,it,pl,pt|test"
+)
+
+EXTRA_ARGS=("$@")
+
+run_case() {
+  local tag="$1"
+  local dataset="$2"
+  local configs="$3"
+  local split="$4"
+
+  local json_out="${OUT_DIR}/${tag}_streaming_clean.json"
+  local log_out="${LOG_DIR}/${tag}_streaming_clean.log"
+
+  if [[ "${RESUME}" == "1" && -f "${json_out}" ]]; then
+    echo "[skip] existing ${json_out}"
+    return 0
+  fi
+
+  local args=(
+    --model-id "${MODEL_ID}"
+    --dataset-name "${dataset}"
+    --configs "${configs}"
+    --split "${split}"
+    --output-json "${json_out}"
+    --max-samples-per-config "${MAX_SAMPLES_PER_CONFIG}"
+    --max-new-tokens "${MAX_NEW_TOKENS}"
+    --latent-ckpt "${LATENT_CKPT}"
+    --n-latent 4
+    --num-beams 1
+    --dynamic-halt-threshold "${DYNAMIC_HALT_THRESHOLD}"
+    --print-samples "${PRINT_SAMPLES}"
+    --text-normalizer "${TEXT_NORMALIZER}"
+    --streaming
+    --skip-baseline-ft
+    --skip-prompt-tuning
+    --skip-lora-r16
+  )
+
+  echo "------------------------------------------------------------"
+  echo "Case      : ${tag}"
+  echo "Dataset   : ${dataset}"
+  echo "Configs   : ${configs}"
+  echo "Split     : ${split}"
+  echo "Streaming : yes"
+  echo "JSON      : ${json_out}"
+  echo "LOG       : ${log_out}"
+
+  "${PYTHON_BIN}" eval.py "${args[@]}" "${EXTRA_ARGS[@]}" 2>&1 | tee "${log_out}"
+}
+
+echo "============================================================"
+echo "Latent Reasoning Multilingual ASR Streaming"
+echo "============================================================"
+echo "Root dir        : ${ROOT_DIR}"
+echo "Output dir      : ${OUT_DIR}"
+echo "Python          : ${PYTHON_BIN}"
+echo "Model           : ${MODEL_ID}"
+echo "Latent ckpt     : ${LATENT_CKPT}"
+echo "Halt threshold  : ${DYNAMIC_HALT_THRESHOLD}"
+echo "Max/config      : ${MAX_SAMPLES_PER_CONFIG} (0 = full split)"
+echo "Text normalizer : ${TEXT_NORMALIZER}"
+echo "Case filter     : ${CASE_FILTER:-(none)}"
+echo "Extra args      : ${EXTRA_ARGS[*]:-(none)}"
+echo "============================================================"
+
+SUCCESS=()
+FAILED=()
+
+for entry in "${MULTILINGUAL_CASES[@]}"; do
+  IFS='|' read -r TAG DATASET CONFIGS SPLIT <<< "${entry}"
+
+  if [[ -n "${CASE_FILTER}" && ! "${TAG}" =~ ${CASE_FILTER} ]]; then
+    continue
+  fi
+
+  if run_case "${TAG}" "${DATASET}" "${CONFIGS}" "${SPLIT}"; then
+    SUCCESS+=("${TAG}:streaming_clean")
+  else
+    FAILED+=("${TAG}:streaming_clean")
+  fi
+done
+
+echo ""
+echo "============================================================"
+echo "Multilingual Streaming Summary"
+echo "============================================================"
+echo "Succeeded (${#SUCCESS[@]}):"
+for item in "${SUCCESS[@]}"; do
+  echo "  - ${item}"
+done
+echo "Failed (${#FAILED[@]}):"
+for item in "${FAILED[@]}"; do
+  echo "  - ${item}"
+done
+
+"${PYTHON_BIN}" scripts/summarize_lr_showcase.py "${OUT_DIR}"
+echo "Outputs: ${OUT_DIR}"
+echo "============================================================"

experiments/run_paper_tbd_retrain.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Retrain LatentASR variants needed by the paper TBD ablations.
+# This runner intentionally saves per-epoch checkpoints. Downstream evaluation
+# should use *_epoch10.pth for same-schedule comparisons unless noted otherwise.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+OUT_DIR="${OUT_DIR:-${ROOT_DIR}/eval_runs/paper_tbd_retrain_${TIMESTAMP}}"
+LOG_DIR="${OUT_DIR}/logs"
+CKPT_DIR="${OUT_DIR}/checkpoints"
+mkdir -p "${LOG_DIR}" "${CKPT_DIR}"
+
+NUM_EPOCHS="${NUM_EPOCHS:-10}"
+BATCH_SIZE="${BATCH_SIZE:-16}"
+GRAD_ACCUM_STEPS="${GRAD_ACCUM_STEPS:-1}"
+EVAL_SAMPLES="${EVAL_SAMPLES:-1}"
+PRETRAIN_EVAL_SAMPLES="${PRETRAIN_EVAL_SAMPLES:-0}"
+VARIANT_FILTER="${VARIANT_FILTER:-}"
+DEFAULT_TRAIN_MAX="${DEFAULT_TRAIN_MAX:-0}"
+
+# name|n_latent|train_max|p_neg|bounded|gate|anchor
+VARIANTS=(
+  "component_no_bounded|4|${DEFAULT_TRAIN_MAX}|0.3|0|1|1"
+  "component_no_gate|4|${DEFAULT_TRAIN_MAX}|0.3|1|0|1"
+  "component_no_anchor|4|${DEFAULT_TRAIN_MAX}|0.3|1|1|0"
+  "n1|1|${DEFAULT_TRAIN_MAX}|0.3|1|1|1"
+  "n2|2|${DEFAULT_TRAIN_MAX}|0.3|1|1|1"
+  "n4|4|${DEFAULT_TRAIN_MAX}|0.3|1|1|1"
+  "n8|8|${DEFAULT_TRAIN_MAX}|0.3|1|1|1"
+  "pneg0|4|${DEFAULT_TRAIN_MAX}|0.0|1|1|1"
+  "activation_100|4|100|0.3|1|1|1"
+  "activation_200|4|200|0.3|1|1|1"
+  "activation_300|4|300|0.3|1|1|1"
+  "activation_400|4|400|0.3|1|1|1"
+  "activation_500|4|500|0.3|1|1|1"
+  "activation_600|4|600|0.3|1|1|1"
+  "activation_700|4|700|0.3|1|1|1"
+  "activation_800|4|800|0.3|1|1|1"
+)
+
+echo "============================================================"
+echo "LatentASR paper TBD retraining"
+echo "============================================================"
+latent_asr_print_kv "Root" "${ROOT_DIR}"
+latent_asr_print_kv "Output" "${OUT_DIR}"
+latent_asr_print_kv "Python" "${PYTHON_BIN}"
+latent_asr_print_kv "Epochs" "${NUM_EPOCHS}"
+latent_asr_print_kv "Batch" "${BATCH_SIZE}"
+latent_asr_print_kv "Grad accum" "${GRAD_ACCUM_STEPS}"
+latent_asr_print_kv "Eval samples" "${EVAL_SAMPLES}"
+latent_asr_print_kv "Variant filter" "${VARIANT_FILTER:-(none)}"
+latent_asr_print_kv "Default train max" "${DEFAULT_TRAIN_MAX} (0 = full 811-sample activation set)"
+echo "============================================================"
+
+for spec in "${VARIANTS[@]}"; do
+  IFS='|' read -r name n_latent train_max p_neg bounded gate anchor <<< "${spec}"
+  if [[ -n "${VARIANT_FILTER}" && ! "${name}" =~ ${VARIANT_FILTER} ]]; then
+    continue
+  fi
+
+  variant_dir="${CKPT_DIR}/${name}"
+  mkdir -p "${variant_dir}"
+  prefix="${variant_dir}/${name}"
+  final_ckpt="${prefix}_epoch${NUM_EPOCHS}.pth"
+  log_path="${LOG_DIR}/${name}.log"
+
+  if [[ -f "${final_ckpt}" ]]; then
+    echo "[skip] ${name}: found ${final_ckpt}"
+    continue
+  fi
+
+  echo ""
+  echo "------------------------------------------------------------"
+  echo "Variant   : ${name}"
+  echo "N         : ${n_latent}"
+  echo "train_max : ${train_max:-0} (0 = full 811-sample activation set)"
+  echo "p_neg     : ${p_neg}"
+  echo "bounded   : ${bounded}"
+  echo "gate      : ${gate}"
+  echo "anchor    : ${anchor}"
+  echo "log       : ${log_path}"
+  echo "------------------------------------------------------------"
+
+  env \
+    PYTHONUNBUFFERED=1 \
+    TOKENIZERS_PARALLELISM=false \
+    TRAIN_MODE=latent \
+    N_LATENT="${n_latent}" \
+    TRAIN_MAX_SAMPLES="${train_max}" \
+    VALUE_FORCED_NEG_PROB="${p_neg}" \
+    LATENT_USE_BOUNDED_DELTA="${bounded}" \
+    LATENT_USE_INJECTION_GATE="${gate}" \
+    LATENT_USE_EMBEDDING_ANCHOR="${anchor}" \
+    NUM_EPOCHS="${NUM_EPOCHS}" \
+    BATCH_SIZE="${BATCH_SIZE}" \
+    GRAD_ACCUM_STEPS="${GRAD_ACCUM_STEPS}" \
+    EVAL_SAMPLES="${EVAL_SAMPLES}" \
+    PRETRAIN_EVAL_SAMPLES="${PRETRAIN_EVAL_SAMPLES}" \
+    LOG_EVERY=25 \
+    GRAD_LOG_EVERY=100 \
+    CHECKPOINT_PREFIX="${prefix}" \
+    "${PYTHON_BIN}" train.py 2>&1 | tee "${log_path}"
+done
+
+echo "Outputs: ${OUT_DIR}"

experiments/run_threshold_sweep.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Threshold sweep for the LatentASR value-head halting policy.
+# Clean audio only, full splits by default, and HuggingFace streaming enabled
+# so audio is not materialized under the workspace.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+ROOT_DIR="$(latent_asr_repo_root "${SCRIPT_DIR}")"
+cd "${ROOT_DIR}"
+
+LATENT_CKPT="${LATENT_CKPT:-./latent_qwen_asr_best.pth}"
+MODEL_ID="${MODEL_ID:-Qwen/Qwen3-ASR-0.6B}"
+PYTHON_BIN="$(latent_asr_python_bin "${PYTHON_BIN:-}")"
+
+MAX_SAMPLES_PER_CONFIG="${MAX_SAMPLES_PER_CONFIG:-0}"
+MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-128}"
+PRINT_SAMPLES="${PRINT_SAMPLES:-0}"
+STREAMING="${STREAMING:-1}"
+RUN_BASE="${RUN_BASE:-0}"
+CASE_FILTER="${CASE_FILTER:-fleurs_en_us|voxpopuli_en}"
+THRESHOLD_SPECS="${THRESHOLD_SPECS:-full:-2.0 neg0p2:-0.2 zero:0.0 pos0p2:0.2 pos0p5:0.5}"
+RESUME="${RESUME:-1}"
+
+latent_asr_require_file "${LATENT_CKPT}" "latent checkpoint"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+OUT_DIR="${OUT_DIR:-${ROOT_DIR}/eval_runs/threshold_sweep_${TIMESTAMP}}"
+LOG_DIR="${OUT_DIR}/logs"
+mkdir -p "${LOG_DIR}"
+
+# Format: tag|dataset|configs|split
+CASES=(
+  "fleurs_en_us|google/fleurs|en_us|test"
+  "voxpopuli_en|facebook/voxpopuli|en|test"
+)
+
+EXTRA_ARGS=("$@")
+
+run_case() {
+  local theta_label="$1"
+  local theta_value="$2"
+  local tag="$3"
+  local dataset="$4"
+  local configs="$5"
+  local split="$6"
+
+  local json_out="${OUT_DIR}/${tag}_theta_${theta_label}.json"
+  local log_out="${LOG_DIR}/${tag}_theta_${theta_label}.log"
+
+  if [[ "${RESUME}" == "1" && -f "${json_out}" ]]; then
+    echo "[skip] existing ${json_out}"
+    return 0
+  fi
+
+  local args=(
+    --model-id "${MODEL_ID}"
+    --dataset-name "${dataset}"
+    --configs "${configs}"
+    --split "${split}"
+    --output-json "${json_out}"
+    --max-samples-per-config "${MAX_SAMPLES_PER_CONFIG}"
+    --max-new-tokens "${MAX_NEW_TOKENS}"
+    --latent-ckpt "${LATENT_CKPT}"
+    --n-latent 4
+    --num-beams 1
+    --dynamic-halt-threshold "${theta_value}"
+    --print-samples "${PRINT_SAMPLES}"
+    --skip-baseline-ft
+    --skip-prompt-tuning
+    --skip-lora-r16
+  )
+
+  if [[ "${RUN_BASE}" != "1" ]]; then
+    args+=(--skip-base-model)
+  fi
+  if [[ "${STREAMING}" == "1" ]]; then
+    args+=(--streaming)
+  fi
+
+  echo "------------------------------------------------------------"
+  echo "Case      : ${tag}"
+  echo "Dataset   : ${dataset}"
+  echo "Configs   : ${configs}"
+  echo "Split     : ${split}"
+  echo "Theta     : ${theta_label} (${theta_value})"
+  echo "Streaming : ${STREAMING}"
+  echo "Run base  : ${RUN_BASE}"
+  echo "JSON      : ${json_out}"
+  echo "LOG       : ${log_out}"
+
+  "${PYTHON_BIN}" eval.py "${args[@]}" "${EXTRA_ARGS[@]}" 2>&1 | tee "${log_out}"
+}
+
+echo "============================================================"
+echo "LatentASR Threshold Sweep"
+echo "============================================================"
+echo "Root dir      : ${ROOT_DIR}"
+echo "Output dir    : ${OUT_DIR}"
+echo "Python        : ${PYTHON_BIN}"
+echo "Model         : ${MODEL_ID}"
+echo "Latent ckpt   : ${LATENT_CKPT}"
+echo "Max/config    : ${MAX_SAMPLES_PER_CONFIG} (0 = full split)"
+echo "Streaming     : ${STREAMING}"
+echo "Run base      : ${RUN_BASE}"
+echo "Case filter   : ${CASE_FILTER:-(none)}"
+echo "Thresholds    : ${THRESHOLD_SPECS}"
+echo "Extra args    : ${EXTRA_ARGS[*]:-(none)}"
+echo "============================================================"
+
+SUCCESS=()
+FAILED=()
+
+for spec in ${THRESHOLD_SPECS}; do
+  IFS=':' read -r THETA_LABEL THETA_VALUE <<< "${spec}"
+  for entry in "${CASES[@]}"; do
+    IFS='|' read -r TAG DATASET CONFIGS SPLIT <<< "${entry}"
+    if [[ -n "${CASE_FILTER}" && ! "${TAG}" =~ ${CASE_FILTER} ]]; then
+      continue
+    fi
+    if run_case "${THETA_LABEL}" "${THETA_VALUE}" "${TAG}" "${DATASET}" "${CONFIGS}" "${SPLIT}"; then
+      SUCCESS+=("${TAG}:${THETA_LABEL}")
+    else
+      FAILED+=("${TAG}:${THETA_LABEL}")
+    fi
+  done
+done
+
+"${PYTHON_BIN}" scripts/summarize_threshold_sweep.py "${OUT_DIR}"
+
+echo ""
+echo "============================================================"
+echo "Threshold Sweep Summary"
+echo "============================================================"
+echo "Succeeded (${#SUCCESS[@]}):"
+for item in "${SUCCESS[@]}"; do
+  echo "  - ${item}"
+done
+echo "Failed (${#FAILED[@]}):"
+for item in "${FAILED[@]}"; do
+  echo "  - ${item}"
+done
+echo "Outputs: ${OUT_DIR}"
+echo "============================================================"

hf_upload/README.md

@@ -0,0 +1,11 @@
+# HF Upload Helper
+
+Run from the repository root:
+
+```bash
+python hf_upload/upload_to_hf.py --repo-id voidful/latentASR
+```
+
+The script uploads the entire project folder, including the released adapter
+checkpoint and documentation, to a Hugging Face model repository.
+

hf_upload/upload_to_hf.py

@@ -0,0 +1,54 @@
+"""Upload the latentASR project and adapter checkpoint to Hugging Face Hub."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Upload latentASR to Hugging Face Hub.")
+    parser.add_argument("--repo-id", default="voidful/latentASR")
+    parser.add_argument("--private", action="store_true")
+    parser.add_argument("--revision", default=None)
+    parser.add_argument(
+        "--commit-message",
+        default="Release latentASR adapter, code, docs, and reproducibility artifacts",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    project_root = Path(__file__).resolve().parents[1]
+    api = HfApi()
+    api.create_repo(
+        repo_id=args.repo_id,
+        repo_type="model",
+        private=args.private,
+        exist_ok=True,
+    )
+    api.upload_folder(
+        repo_id=args.repo_id,
+        repo_type="model",
+        folder_path=str(project_root),
+        revision=args.revision,
+        commit_message=args.commit_message,
+        ignore_patterns=[
+            ".git/*",
+            "__pycache__/*",
+            "*.pyc",
+            ".pytest_cache/*",
+            "eval_runs/*",
+            "logs/*",
+            "wandb/*",
+        ],
+    )
+    print(f"Uploaded {project_root} to https://huggingface.co/{args.repo_id}")
+
+
+if __name__ == "__main__":
+    main()
+

losses.py

@@ -0,0 +1,66 @@
+"""Loss functions for latent-reasoning ASR training."""
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _fmt(x: torch.Tensor) -> str:
+    """Format a one-dimensional tensor for logging."""
+    return " | ".join([f"d{k}:{x[k].item():.3f}" for k in range(x.numel())])
+
+
+def contrastive_loss(view_a: torch.Tensor, view_b: torch.Tensor, temperature: float) -> torch.Tensor:
+    """InfoNCE contrastive loss over batch (symmetric)."""
+    assert view_a.dim() == 2 and view_b.dim() == 2, "contrastive_loss expects (B, D) inputs"
+    B = view_a.size(0)
+    if B <= 1:
+        return view_a.new_tensor(0.0)
+    z1 = F.normalize(view_a, dim=-1)
+    z2 = F.normalize(view_b, dim=-1)
+    logits = torch.matmul(z1, z2.t()) / float(temperature)
+    labels = torch.arange(B, device=view_a.device)
+    loss_a = F.cross_entropy(logits, labels)
+    loss_b = F.cross_entropy(logits.t(), labels)
+    return 0.5 * (loss_a + loss_b)
+
+
+def trajectory_regularization_loss(thoughts: torch.Tensor, alpha: float = 0.5) -> torch.Tensor:
+    """Trajectory regularization loss.
+
+    Encodes the intuition that the latent reasoning trajectory should:
+    1. Stay anchored to the initial acoustic state h_0 (semantic grounding)
+    2. Evolve smoothly between consecutive steps (temporal coherence)
+
+    Args:
+        thoughts: shape (B, N, D), where thoughts[:, 0, :] is the initial state h_0
+        alpha: weight balancing anchor vs smoothness (default: 0.5)
+
+    Returns:
+        Scalar loss combining anchor and smoothness terms
+    """
+    N = thoughts.size(1)
+    # Guard: empty trajectory (e.g. n_latent=0) – return 0.
+    if N == 0:
+        return thoughts.new_tensor(0.0)
+
+    # Extract initial acoustic anchor h_0
+    h_0 = thoughts[:, 0:1, :]  # shape: (B, 1, D)
+
+    # 1. Acoustic Anchor Loss (distance of all states from h_0)
+    anchor_loss = (thoughts - h_0).pow(2).sum(dim=-1).mean()
+
+    # 2. Step-wise Smoothness Loss (distance between adjacent states).
+    # When N==1 (e.g. DEQ single fixed-point), there are no consecutive pairs,
+    # so smooth_loss is zero – avoids mean() on an empty tensor returning NaN.
+    if N > 1:
+        diffs = thoughts[:, 1:, :] - thoughts[:, :-1, :]  # shape: (B, N-1, D)
+        smooth_loss = diffs.pow(2).sum(dim=-1).mean()
+    else:
+        smooth_loss = thoughts.new_tensor(0.0)
+
+    # Combine final regularization loss
+    total_trajectory_loss = alpha * anchor_loss + (1.0 - alpha) * smooth_loss
+    return total_trajectory_loss

model.py

@@ -0,0 +1,1972 @@
+"""LatentQwenASR model for lr_whisper.
+
+The ``LatentQwenASR`` class wraps a frozen Qwen3-ASR base model and adds a
+small controller network that emits per-step delta vectors (latent tokens).
+"""
+
+import math
+import re
+import string
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from tqdm import tqdm
+from jiwer import wer
+
+from data import build_audio_token_seq, _coerce_feat_attention_mask
+
+def _detach_kv(kv_tuple: Any) -> Any:
+    """Detach past_key_values to prevent excessive BPTT exploding gradients."""
+    if kv_tuple is None:
+        return None
+    # If it's a raw tuple (older transformers standard)
+    if isinstance(kv_tuple, tuple):
+        return tuple(tuple(t.detach() for t in layer) for layer in kv_tuple)
+
+    # Transformers >= 4.38 uses Cache objects like DynamicCache
+    if hasattr(kv_tuple, "to_legacy_cache"):
+        legacy_tuple = kv_tuple.to_legacy_cache()
+        detached_tuple = tuple(tuple(t.detach() for t in layer) for layer in legacy_tuple)
+        return type(kv_tuple).from_legacy_cache(detached_tuple)
+
+    # Fallback to cloning attributes if the specific class doesn't match
+    import copy
+    new_cache = copy.copy(kv_tuple)
+    if hasattr(new_cache, "key_cache"):
+        new_cache.key_cache = [k.detach() for k in getattr(kv_tuple, "key_cache", [])]
+        new_cache.value_cache = [v.detach() for v in getattr(kv_tuple, "value_cache", [])]
+    return new_cache
+
+
+class LatentQwenASR(nn.Module):
+    """Wrapper around Qwen3-ASR that supports latent prompt injection.
+
+    The class keeps the underlying ASR model frozen and introduces a small
+    controller network that emits delta vectors for each latent token.  These
+    deltas are normalised and scaled, then added to the token embeddings at
+    the NT-token positions.  During training, the deltas are inserted into the
+    decoder embeddings at the appropriate positions; during generation, they
+    are applied just before decoding.
+
+    Design note - float32 parameters
+    -----------------------------------
+    ``log_scale`` is kept in **float32** even when the rest of the model is in bfloat16
+    to preserve gradient precision for the per-step scales.
+    """
+
+    @staticmethod
+    def _resolve_text_model(thinker: nn.Module) -> nn.Module:
+        """Resolve the inner text decoder module across wrapped backends (e.g. PEFT)."""
+        queue: List[object] = [thinker]
+        seen: set = set()
+        while queue:
+            node = queue.pop(0)
+            if node is None:
+                continue
+            node_id = id(node)
+            if node_id in seen:
+                continue
+            seen.add(node_id)
+            emb = getattr(node, "embed_tokens", None)
+            if isinstance(emb, nn.Module):
+                return node
+            for attr in ("model", "base_model", "module"):
+                child = getattr(node, attr, None)
+                if child is not None and child is not node:
+                    queue.append(child)
+        raise AttributeError(
+            "Unable to resolve text decoder with `embed_tokens` from thinker module."
+        )
+
+    @staticmethod
+    def _resolve_embed_tokens(text_model: nn.Module) -> nn.Module:
+        emb = getattr(text_model, "embed_tokens", None)
+        if isinstance(emb, nn.Module):
+            return emb
+        if hasattr(text_model, "get_input_embeddings"):
+            emb = text_model.get_input_embeddings()
+            if isinstance(emb, nn.Module):
+                return emb
+        raise AttributeError("Unable to resolve input embedding module.")
+
+    def __init__(
+        self,
+        asr_model: nn.Module,
+        processor: Any,
+        n_latent: int,
+        nt_token_id: int,
+        lang_token_id: int,
+        transcribe_token_id: int,
+        freeze_base: bool = True,
+        use_latent: bool = True,
+        use_soft_prompt: bool = False,
+        soft_prompt_init_mode: str = "text",
+        soft_prompt_init_text: str = "",
+        user_prompt_text: str = "Transcribe the audio into text.",
+
+        delta_tanh_c: float = 5.0,
+        scale_max: float = 3.0,
+        scale_init: float = 0.2,
+        thought_mode: str = "prefix",
+        thought_group_size: int = 1,
+        halt_threshold: float = 0.0,
+        latent_drop_prob: float = 0.0,
+        latent_input_noise_std: float = 0.0,
+        latent_use_bounded_delta: bool = True,
+        latent_use_injection_gate: bool = True,
+        latent_use_embedding_anchor: bool = True,
+        freeze_audio_stack: bool = True,
+    ) -> None:
+        super().__init__()
+        self.base_model = asr_model
+        self.processor = processor
+        self.config = getattr(asr_model, "config", None)
+        self.n_latent = int(n_latent)
+        self.use_latent = bool(use_latent and self.n_latent > 0)
+        self.nt_token_id = int(nt_token_id)
+        self.use_soft_prompt = bool(
+            use_soft_prompt
+            and (not self.use_latent)
+            and self.n_latent > 0
+            and self.nt_token_id >= 0
+        )
+        self.soft_prompt_init_mode = (soft_prompt_init_mode or "text").strip().lower()
+        self.soft_prompt_init_text = soft_prompt_init_text or ""
+        self.lang_token_id = int(lang_token_id)
+        self.transcribe_token_id = int(transcribe_token_id)
+
+        # Hyperparams stored from constructor args (originally read from env globals).
+
+        self.delta_tanh_c = float(delta_tanh_c)
+        self.halt_threshold = float(halt_threshold)
+        self.latent_drop_prob = float(latent_drop_prob)
+        self.latent_input_noise_std = float(latent_input_noise_std)
+        self.latent_use_bounded_delta = bool(latent_use_bounded_delta)
+        self.latent_use_injection_gate = bool(latent_use_injection_gate)
+        self.latent_use_embedding_anchor = bool(latent_use_embedding_anchor)
+        self.freeze_audio_stack = bool(freeze_audio_stack)
+
+        # Qwen3-ASR audio token ID
+        _audio_tok = None
+        if self.config and hasattr(self.config, "audio_token_id") and self.config.audio_token_id is not None:
+            _audio_tok = int(self.config.audio_token_id)
+        if _audio_tok is None:
+            _thinker_cfg = getattr(self.base_model, "config", None) or getattr(
+                getattr(self.base_model, "thinker", None), "config", None
+            )
+            if _thinker_cfg is not None and hasattr(_thinker_cfg, "audio_token_id") and _thinker_cfg.audio_token_id is not None:
+                _audio_tok = int(_thinker_cfg.audio_token_id)
+        if _audio_tok is None:
+            for _name in ("<|AUDIO|>", "<|audio|>", "<|audio_content|>", "<|audio_pad|>"):
+                target_tok = self.processor.tokenizer if hasattr(self.processor, "tokenizer") else self.processor
+                if hasattr(target_tok, "convert_tokens_to_ids"):
+                    _try = target_tok.convert_tokens_to_ids(_name)
+                    unk_id = getattr(target_tok, "unk_token_id", None)
+                    if _try is not None and _try != unk_id:
+                        _audio_tok = int(_try)
+                        break
+        if _audio_tok is None:
+            _audio_tok = getattr(self.processor, "audio_token_id", None)
+        if _audio_tok is None:
+            _audio_tok = 151646  # last-resort fallback
+        self.audio_token_id = _audio_tok
+        
+        target_tok = self.processor.tokenizer if hasattr(self.processor, "tokenizer") else self.processor
+        _decoded = target_tok.convert_ids_to_tokens(self.audio_token_id) if hasattr(target_tok, "convert_ids_to_tokens") else str(self.audio_token_id)
+        print(f"[init] audio_token_id={self.audio_token_id} decodes_to={_decoded!r}")
+
+        # Freeze all parameters in the underlying model for latent-adapter training.
+        if freeze_base:
+            for p in self.base_model.parameters():
+                p.requires_grad = False
+
+        if self.freeze_audio_stack:
+            audio_tower = getattr(self.base_model, "thinker", self.base_model)
+            audio_tower = getattr(audio_tower, "audio_tower", None)
+            if audio_tower is not None:
+                n_frozen = 0
+                for p in audio_tower.parameters():
+                    if p.requires_grad:
+                        p.requires_grad = False
+                        n_frozen += 1
+                if n_frozen > 0:
+                    print(f"[init] Froze {n_frozen} audio_tower parameters.")
+            # Also freeze multi_modal_projector (audio-to-text projection).
+            projector = getattr(getattr(self.base_model, "thinker", self.base_model), "multi_modal_projector", None)
+            if projector is not None:
+                n_frozen_proj = 0
+                for p in projector.parameters():
+                    if p.requires_grad:
+                        p.requires_grad = False
+                        n_frozen_proj += 1
+                if n_frozen_proj > 0:
+                    print(f"[init] Froze {n_frozen_proj} multi_modal_projector parameters.")
+
+        self.thinker = self.base_model.thinker
+        self.text_model = self._resolve_text_model(self.thinker)
+        self.embed_tokens = self._resolve_embed_tokens(self.text_model)
+
+        if self.config and hasattr(self.config, "text_config"):
+            d = self.config.text_config.hidden_size
+        elif self.config and hasattr(self.config, "hidden_size"):
+            d = self.config.hidden_size
+        else:
+            if hasattr(self.embed_tokens, "embedding_dim"):
+                d = int(self.embed_tokens.embedding_dim)
+            else:
+                d = int(self.embed_tokens.weight.size(-1))
+
+        print(f"[LatentQwenASR] Using hidden_size={d}")
+
+        target_dtype = self.thinker.dtype if hasattr(self.thinker, "dtype") else torch.float32
+
+        self.init_proj = nn.Linear(d, d, bias=True).to(dtype=target_dtype)
+        self.delta_proj = nn.Linear(d, d, bias=True).to(dtype=target_dtype)
+
+        self.step_embed = nn.Parameter(torch.zeros(self.n_latent, d, dtype=target_dtype))
+        nn.init.normal_(self.step_embed, mean=0.0, std=0.02)
+        self.step_proj = nn.Linear(d, d, bias=False).to(dtype=target_dtype)
+        self.scale_max = float(scale_max)
+
+
+
+        scale_init_val = float(scale_init)
+        if scale_init_val <= 0:
+            scale_init_val = 1.0
+        scale_init_unconstrained = math.log(math.expm1(scale_init_val))
+        self.log_scale = nn.Parameter(
+            torch.full((self.n_latent,), float(scale_init_unconstrained), dtype=torch.float32)
+        )
+
+        # Stability: LayerNorm for the recurrent thought loop
+        self.thought_ln = nn.LayerNorm(d, elementwise_affine=False).to(dtype=target_dtype)
+
+        # Thought Quality Analyzer (Value Head) predicting expected CE error
+        self.value_head = nn.Linear(d, 1).to(dtype=target_dtype)
+
+        # Soft Gated Injection (Scheme 4)
+        self.injection_gate = nn.Sequential(
+            nn.Linear(d * 2, d),
+            nn.Sigmoid()
+        ).to(dtype=target_dtype)
+        # Initialize gate weights to 0 so sigmoid(0) = 0.5 (neutral start)
+        nn.init.zeros_(self.injection_gate[0].weight)
+        nn.init.zeros_(self.injection_gate[0].bias)
+        self._hidden_size = d
+
+        # Front-token prompt tuning
+        self.soft_prompt_embed = nn.Parameter(
+            torch.zeros(self.n_latent, d, dtype=target_dtype),
+            requires_grad=self.use_soft_prompt,
+        )
+        if self.use_soft_prompt:
+            init_prompt = None
+            if self.soft_prompt_init_mode == "text" and self.soft_prompt_init_text.strip():
+                init_ids = self.processor.tokenizer.encode(
+                    self.soft_prompt_init_text.strip(),
+                    add_special_tokens=False,
+                )
+                if init_ids:
+                    with torch.no_grad():
+                        emb_device = self.embed_tokens.weight.device
+                        init_ids_t = torch.tensor(init_ids, dtype=torch.long, device=emb_device)
+                        base = self.embed_tokens(init_ids_t).detach()
+                    if base.numel() > 0:
+                        if base.size(0) < self.n_latent:
+                            reps = (self.n_latent + base.size(0) - 1) // base.size(0)
+                            base = base.repeat((reps, 1))
+                        init_prompt = base[: self.n_latent]
+            if init_prompt is None:
+                init_prompt = torch.empty((self.n_latent, d), dtype=target_dtype)
+                nn.init.normal_(init_prompt, mean=0.0, std=0.02)
+            self.soft_prompt_embed.data.copy_(
+                init_prompt.to(device=self.soft_prompt_embed.device, dtype=self.soft_prompt_embed.dtype)
+            )
+        else:
+            self.soft_prompt_embed.requires_grad = False
+
+        # Cast trainable modules to backbone dtype
+        target_dtype = self.base_model.dtype if hasattr(self.base_model, "dtype") else torch.float32
+        self.init_proj.to(target_dtype)
+        self.delta_proj.to(target_dtype)
+        self.step_embed.data = self.step_embed.data.to(target_dtype)
+        self.step_proj.to(target_dtype)
+        self.soft_prompt_embed.data = self.soft_prompt_embed.data.to(target_dtype)
+        # log_scale intentionally stays float32 for per-step scale gradient precision.
+
+        # Qwen3-ASR Special Audio Tokens
+        self.audio_bos_token_id = self.processor.tokenizer.convert_tokens_to_ids("<|audio_start|>")
+        self.audio_eos_token_id = self.processor.tokenizer.convert_tokens_to_ids("<|audio_end|>")
+        if self.audio_bos_token_id is None:
+            self.audio_bos_token_id = self.processor.tokenizer.bos_token_id
+        if self.audio_eos_token_id is None:
+            self.audio_eos_token_id = self.processor.tokenizer.eos_token_id
+
+        # Chat-template token pieces
+        self.im_start_id = self.processor.tokenizer.convert_tokens_to_ids("<|im_start|>")
+        if self.im_start_id is None or self.im_start_id == self.processor.tokenizer.unk_token_id:
+            self.im_start_id = self.lang_token_id
+        _im_end_id = self.processor.tokenizer.convert_tokens_to_ids("<|im_end|>")
+        if _im_end_id is None or _im_end_id == self.processor.tokenizer.unk_token_id:
+            _im_end_id = self.processor.tokenizer.eos_token_id
+        self.im_end_id = _im_end_id
+        # Unified stop-token set for generation AND eval truncation.
+        _stop_ids = {int(self.im_end_id)}
+        _eot_id = self.processor.tokenizer.convert_tokens_to_ids("<|endoftext|>")
+        if _eot_id is not None and _eot_id != self.processor.tokenizer.unk_token_id:
+            _stop_ids.add(int(_eot_id))
+        if self.processor.tokenizer.eos_token_id is not None:
+            _stop_ids.add(int(self.processor.tokenizer.eos_token_id))
+        self.stop_ids = sorted(_stop_ids)
+        self.user_nl_ids = self.processor.tokenizer.encode("user\n", add_special_tokens=False)
+        self.asst_nl_ids = self.processor.tokenizer.encode("assistant\n", add_special_tokens=False)
+        self.asr_prefix_ids = self.processor.tokenizer.encode("language English<asr_text>", add_special_tokens=False)
+        self.nl_ids = self.processor.tokenizer.encode("\n", add_special_tokens=False)
+        self.user_prompt_text = user_prompt_text
+        if self.user_prompt_text:
+            self.user_prompt_ids = self.processor.tokenizer.encode(
+                self.user_prompt_text, add_special_tokens=False
+            )
+        else:
+            self.user_prompt_ids = []
+        self._warned_generate_fallback = False
+        self.thought_mode = thought_mode.strip().lower()
+        self.thought_group_size = max(1, int(thought_group_size))
+        print(
+            "[latent-ablation] "
+            f"bounded_delta={self.latent_use_bounded_delta} "
+            f"injection_gate={self.latent_use_injection_gate} "
+            f"embedding_anchor={self.latent_use_embedding_anchor}"
+        )
+
+        # In non-latent modes, keep latent controller out of optimization.
+        if not self.use_latent:
+            for p in self.init_proj.parameters():
+                p.requires_grad = False
+            for p in self.delta_proj.parameters():
+                p.requires_grad = False
+            for p in self.step_proj.parameters():
+                p.requires_grad = False
+            for p in self.thought_ln.parameters():
+                p.requires_grad = False
+            self.step_embed.requires_grad = False
+
+            self.log_scale.requires_grad = False
+        if not self.use_soft_prompt:
+            self.soft_prompt_embed.requires_grad = False
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _build_chat_template_tensors(
+        self,
+        device: torch.device,
+        language: str = "English",
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Build shared chat-template pieces for train/eval consistency."""
+        system_nl_ids = self.processor.tokenizer.encode("system\n", add_special_tokens=False)
+        system_turn = torch.tensor(
+            [self.im_start_id] + system_nl_ids + [self.im_end_id] + self.nl_ids,
+            dtype=torch.long,
+            device=device,
+        )
+        user_prefix = torch.tensor(
+            [self.im_start_id] + self.user_nl_ids,
+            dtype=torch.long,
+            device=device,
+        )
+        if self.user_prompt_ids:
+            user_prompt = torch.tensor(self.user_prompt_ids, dtype=torch.long, device=device)
+        else:
+            user_prompt = torch.empty((0,), dtype=torch.long, device=device)
+        user_suffix = torch.tensor(
+            [self.im_end_id] + self.nl_ids,
+            dtype=torch.long,
+            device=device,
+        )
+        asr_prefix_ids = self.processor.tokenizer.encode(f"language {language}<asr_text>", add_special_tokens=False)
+        assistant_prefix = torch.tensor(
+            [self.im_start_id] + self.asst_nl_ids + asr_prefix_ids,
+            dtype=torch.long,
+            device=device,
+        )
+        return system_turn, user_prefix, user_prompt, user_suffix, assistant_prefix
+
+    def _build_full_sequence(
+        self,
+        audio_toks: torch.Tensor,
+        text_all: torch.Tensor,
+        system_turn: torch.Tensor,
+        user_prefix: torch.Tensor,
+        user_prompt: torch.Tensor,
+        user_suffix: torch.Tensor,
+        label_pad: int = -100,
+        n_extra_mask: int = 0,
+        mask_all_nt: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Build full input_ids and aligned labels for one sample.
+
+        The sequence layout is::
+
+            [system_turn, user_prefix, audio_toks, user_prompt,
+             user_suffix, text_all]
+
+        Labels clone input_ids, then mask everything up to (and including)
+        the assistant control tokens, plus an optional ``n_extra_mask``
+        additional positions (e.g. NT tokens in latent prefix mode).
+
+        When ``mask_all_nt=True``, all NT-token positions anywhere in the
+        sequence are additionally masked.  Use this for interleaved mode where
+        NT tokens are scattered throughout the assistant turn.
+
+        Args:
+            audio_toks: 1-D token tensor for the audio segment.
+            text_all: 1-D token tensor for the target text (assistant turn).
+            system_turn: Shared system-turn token tensor.
+            user_prefix: Shared user-prefix token tensor.
+            user_prompt: Shared user-prompt token tensor.
+            user_suffix: Shared user-suffix token tensor.
+            label_pad: Padding value for ignored label positions.
+            n_extra_mask: Number of additional positions after the assistant
+                prefix to mask (set to ``self.n_latent`` for latent prefix
+                mode, 0 for native/baseline/interleaved).
+            mask_all_nt: If True, additionally mask every NT-token position
+                in the full sequence (for interleaved thought mode).
+
+        Returns:
+            ``(full_ids, full_labels)`` - 1-D LongTensors.
+        """
+        full_ids = torch.cat(
+            [system_turn, user_prefix, audio_toks, user_prompt, user_suffix, text_all]
+        )
+        n_prefix = (
+            system_turn.size(0)
+            + user_prefix.size(0)
+            + audio_toks.size(0)
+            + user_prompt.size(0)
+            + user_suffix.size(0)
+        )
+        # Mask: <|im_start|> + "assistant\n" + n_extra_mask (e.g. NT tokens)
+        n_asst_control = 1 + len(self.asst_nl_ids) + n_extra_mask
+        n_total_mask = n_prefix + n_asst_control
+        full_labels = full_ids.clone()
+        full_labels[:n_total_mask] = label_pad
+        if mask_all_nt and self.nt_token_id >= 0:
+            full_labels[full_ids == self.nt_token_id] = label_pad
+        return full_ids, full_labels
+
+    def _inject_latent_deltas(
+        self,
+        inputs_embeds: torch.Tensor,
+        input_ids: torch.LongTensor,
+        deltas: torch.Tensor,
+    ) -> torch.Tensor:
+        """Inject latent delta embeddings at NT-token positions.
+
+        Replaces the NT-token positions in *inputs_embeds* with::
+
+            base_nt_embedding + delta
+
+        Deltas are always injected at full strength.  The Value Head controls
+        hard routing (N=0 skip / early halt) instead of soft scaling.
+        """
+        B = inputs_embeds.size(0)
+        K = deltas.size(1)
+        device = inputs_embeds.device
+        nt_mask = (input_ids == self.nt_token_id)
+        nt_counts = nt_mask.sum(dim=1)
+
+        max_nt = int(nt_counts.max().item())
+        if K == 1 and max_nt > 1:
+            deltas = deltas.expand(B, max_nt, -1)
+            K = max_nt
+
+        assert (nt_counts == K).all(), (
+            f"NT token count mismatch! {nt_counts} vs expected {K}"
+        )
+        nt_token_ids = torch.full(
+            (B, K), self.nt_token_id, dtype=torch.long, device=device
+        )
+        base_nt = self.embed_tokens(nt_token_ids).to(dtype=inputs_embeds.dtype)
+        delta_scaled = deltas.float().to(dtype=inputs_embeds.dtype)
+
+        if self.latent_use_injection_gate:
+            gate_input = torch.cat([base_nt, delta_scaled], dim=-1)
+            gating_weight = self.injection_gate(gate_input)
+        else:
+            gating_weight = torch.ones_like(delta_scaled)
+        gated_delta = delta_scaled * gating_weight
+        if self.latent_use_embedding_anchor:
+            nt_embeds = base_nt + gated_delta
+        else:
+            nt_embeds = gated_delta
+        batch_idx, seq_idx = torch.nonzero(nt_mask, as_tuple=True)
+        result = inputs_embeds.clone()
+        result[batch_idx, seq_idx, :] = nt_embeds.to(dtype=inputs_embeds.dtype).view(-1, self._hidden_size)
+        return result
+
+    def _bounded_delta_from_raw(
+        self,
+        delta_raw: torch.Tensor,
+        step_idx: int,
+        scales: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """Convert a raw projected state into the configured latent delta."""
+        if not self.latent_use_bounded_delta:
+            return delta_raw
+        if scales is None:
+            scales = self.step_scales()
+        delta_raw_f32 = delta_raw.float()
+        norm_val = delta_raw_f32.norm(dim=-1, keepdim=True)
+        delta_dir = (delta_raw_f32 / (norm_val + 1e-6)).to(dtype=delta_raw.dtype)
+        scale = scales[min(int(step_idx), scales.size(0) - 1)]
+        return delta_dir * scale
+
+    def _compute_prefix_state(
+        self,
+        inputs_embeds: torch.Tensor,
+        input_ids: torch.LongTensor,
+        strict: bool = True,
+        language: str = "English",
+    ) -> Tuple[torch.Tensor, object, torch.LongTensor]:
+        """Compute prefix state and KV cache up to the first NT token."""
+        B, _, _ = inputs_embeds.shape
+        device = inputs_embeds.device
+        text_model = self.text_model
+
+        nt_mask = (input_ids == self.nt_token_id)
+        nt_counts = nt_mask.sum(dim=1)
+        if strict:
+            assert (nt_counts == self.n_latent).all(), (
+                f"NT token count mismatch! {nt_counts} vs {self.n_latent}"
+            )
+
+        first_nt = nt_mask.float().argmax(dim=1)
+        if strict:
+            asr_prefix_ids = self.processor.tokenizer.encode(
+                f"language {language}<asr_text>", add_special_tokens=False
+            )
+            expected = torch.tensor(
+                [self.im_start_id] + self.asst_nl_ids + asr_prefix_ids, dtype=torch.long, device=device
+            )
+            exp_len = expected.numel()
+            for i in range(B):
+                idx = int(first_nt[i].item())
+                start = idx - exp_len
+                assert start >= 0, (
+                    f"Prompt too short to contain assistant prefix (idx={idx}, exp_len={exp_len})."
+                )
+                actual = input_ids[i, start:idx]
+                assert torch.equal(actual, expected), (
+                    "Assistant prefix mismatch before NT. "
+                    f"expected={expected.tolist()} actual={actual.tolist()}"
+                )
+
+        prefix_lens = first_nt
+        if strict:
+            assert (prefix_lens > 0).all(), f"Invalid prefix length(s): {prefix_lens}"
+
+        max_prefix = int(prefix_lens.max().item())
+        prefix_embeds = inputs_embeds[:, :max_prefix, :]
+        prefix_attn = (
+            torch.arange(max_prefix, device=device).unsqueeze(0) < prefix_lens.unsqueeze(1)
+        ).long()
+        if prefix_attn.numel() > 0:
+            prefix_embeds = prefix_embeds * prefix_attn.unsqueeze(-1)
+
+        with torch.no_grad():
+            out = text_model(
+                inputs_embeds=prefix_embeds,
+                attention_mask=prefix_attn,
+                use_cache=True,
+                return_dict=True,
+            )
+        last_positions = torch.clamp(prefix_lens - 1, min=0)
+        batch_idx = torch.arange(B, device=device)
+        last = out.last_hidden_state[batch_idx, last_positions].detach()
+        return last, out.past_key_values, prefix_attn
+
+    def _embed_scale(self) -> float:
+        # Qwen3-ASR does NOT scale embeddings by sqrt(d_model).
+        return 1.0
+
+
+    def step_scales(self) -> torch.Tensor:
+        s = F.softplus(self.log_scale)
+        s = torch.clamp(s, max=self.scale_max)
+        return s[:self.n_latent]
+
+    def forced_decoder_ids_latent(self) -> List[Tuple[int, int]]:
+        ids: List[Tuple[int, int]] = [(0, self.im_start_id)]
+        cur = 1
+        for tid in self.asst_nl_ids:
+            ids.append((cur, tid))
+            cur += 1
+        for i in range(self.n_latent):
+            ids.append((cur + i, self.nt_token_id))
+        return ids
+
+    def forced_decoder_ids_baseline(self) -> List[Tuple[int, int]]:
+        ids: List[Tuple[int, int]] = [(0, self.im_start_id)]
+        cur = 1
+        for tid in self.asst_nl_ids:
+            ids.append((cur, tid))
+            cur += 1
+        return ids
+
+    def _shift_right(self, labels: torch.LongTensor) -> torch.LongTensor:
+        pad_id = self.processor.tokenizer.eos_token_id
+        decoder_input_ids = labels.new_full(labels.shape, pad_id)
+        decoder_input_ids[:, 0] = (
+            self.processor.tokenizer.bos_token_id
+            if self.processor.tokenizer.bos_token_id is not None
+            else self.lang_token_id
+        )
+        shifted = labels[:, :-1].clone()
+        shifted = shifted.masked_fill(shifted == -100, pad_id)
+        decoder_input_ids[:, 1:] = shifted
+        return decoder_input_ids
+
+    def _encode_audio(
+        self,
+        input_features: torch.FloatTensor,
+        feature_attention_mask: torch.LongTensor,
+    ) -> Tuple[torch.Tensor, List[int]]:
+        """Manually encode audio features to get their exact lengths per sample."""
+        if feature_attention_mask is not None:
+            feature_lens = torch.sum(feature_attention_mask, dim=1)
+        else:
+            feature_lens = torch.full(
+                (input_features.size(0),), input_features.size(2),
+                device=input_features.device, dtype=torch.long,
+            )
+
+        audio_features = []
+        lengths = []
+        audio_tower = self.thinker.audio_tower
+        projector = getattr(self.thinker, "multi_modal_projector", None)
+
+        for i in range(len(input_features)):
+            feat = input_features[i]
+            l = feature_lens[i]
+            inp = feat[:, :l]
+            length_tensor = l.unsqueeze(0)
+            out = audio_tower(inp, feature_lens=length_tensor).last_hidden_state
+            if projector is not None:
+                out = projector(out)
+            out = out.squeeze(0)
+            audio_features.append(out)
+            lengths.append(out.size(0))
+
+        return torch.cat(audio_features, dim=0), lengths
+
+    def _get_audio_lengths(
+        self,
+        input_features: torch.FloatTensor,
+        feature_attention_mask: torch.LongTensor,
+    ) -> List[int]:
+        """Compute audio output lengths using the exact same formula as the thinker."""
+        if feature_attention_mask is not None:
+            feature_lens = torch.sum(feature_attention_mask, dim=1)
+        else:
+            feature_lens = torch.full(
+                (input_features.size(0),), input_features.size(2),
+                device=input_features.device, dtype=torch.long,
+            )
+
+        input_lengths_leave = feature_lens % 100
+        feat_lengths = (input_lengths_leave - 1) // 2 + 1
+        output_lengths = (
+            ((feat_lengths - 1) // 2 + 1 - 1) // 2 + 1
+            + (feature_lens // 100) * 13
+        )
+        return output_lengths.tolist()
+
+    def _get_native_audio_embeds(
+        self,
+        input_ids: torch.LongTensor,
+        input_features: torch.FloatTensor,
+        feature_attention_mask: torch.LongTensor,
+        attention_mask: torch.LongTensor,
+    ) -> torch.Tensor:
+        """Capture the thinker's native audio-fused embeddings via a forward hook."""
+        captured: Dict[str, torch.Tensor] = {}
+
+        def _hook(module: nn.Module, args: Any, kwargs: Any) -> None:
+            embeds = kwargs.get("inputs_embeds", None)
+            if embeds is None and len(args) > 0:
+                embeds = args[0]
+            if embeds is not None:
+                captured["embeds"] = embeds
+            return None
+
+        hook = self.text_model.register_forward_pre_hook(_hook, with_kwargs=True)
+        try:
+            with torch.no_grad():
+                self.thinker(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    input_features=input_features,
+                    feature_attention_mask=feature_attention_mask,
+                    labels=None,
+                    return_dict=True,
+                )
+        finally:
+            hook.remove()
+
+        if "embeds" not in captured:
+            raise RuntimeError(
+                "_get_native_audio_embeds: forward hook did not capture embeddings. "
+                "The thinker's internal forward may use a different code path."
+            )
+        return captured["embeds"].detach().clone()
+
+    def _compute_continuous_thoughts(
+        self,
+        initial_state: torch.Tensor,
+        prefix_past_key_values: Optional[object] = None,
+        prefix_attention_mask: Optional[torch.LongTensor] = None,
+        halt_threshold: Optional[float] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor, Dict[str, torch.Tensor]]:
+        """Compute recurrent latent states + per-step deltas using DEQ fixed-point iteration."""
+        B = initial_state.size(0)
+        D = initial_state.size(-1)
+        device = initial_state.device
+        text_model = self.text_model
+
+        initial_norm = initial_state / (initial_state.norm(dim=-1, keepdim=True) + 1e-6)
+        h = self.init_proj(initial_norm)
+
+        # Remove random corruption as teacher forcing artificially lowers CE
+        _corrupted = False
+        
+        scales = self.step_scales()
+        thought_embeds: List[torch.Tensor] = []
+        state_embeds: List[torch.Tensor] = []
+        raw_norms: List[torch.Tensor] = []
+        scaled_norms: List[torch.Tensor] = []
+        v_preds: List[torch.Tensor] = []
+        past_kv = prefix_past_key_values
+        running_attn = prefix_attention_mask
+
+        # ---- Dynamic Causal Thinking Loop ----
+        # Instead of fixed-point iteration (which doesn't converge on frozen LLMs),
+        # we generate a sequence of thought tokens.
+        max_iter = self.n_latent
+        if halt_threshold is None:
+            halt_threshold = getattr(self, "halt_threshold", 0.0)
+
+        current_embed = h
+
+        # ---- N=0 Skip Check (Tanh) ----
+        # v_pred ∈ [-1,1]: expected delta CE (positive means LR helps).
+        # If v_pred < threshold → model is confident LR is NOT needed → skip.
+        if not self.training:
+            v_init = torch.tanh(self.value_head(h.unsqueeze(1)).squeeze(-1).squeeze(-1))  # (B,)
+            if (v_init < halt_threshold).all():
+                # Return empty deltas → generate() will remove all NT tokens
+                empty_deltas = torch.zeros(B, 0, D, device=device, dtype=h.dtype)
+                empty_states = torch.zeros(B, 0, D, device=device, dtype=h.dtype)
+                stats = {
+                    "predicted_value": v_init.detach(),
+                    "deq_iters": torch.tensor(0.0, device=device),
+                    "raw_norm_mean": torch.zeros(0, device=device),
+                    "raw_norm_std": torch.zeros(0, device=device),
+                    "scaled_norm_mean": torch.zeros(0, device=device),
+                    "scaled_norm_std": torch.zeros(0, device=device),
+                    "cos_mean": torch.zeros(0, device=device),
+                    "cos_std": torch.zeros(0, device=device),
+                    "scales": scales.detach(),
+                    "diff_norm": torch.tensor(0.0, device=device),
+                    "step_cos": torch.tensor(0.0, device=device),
+                    "v_preds": v_init.unsqueeze(1).detach(),
+                    "gate": v_init.unsqueeze(1).detach(),
+                    "skipped": True,
+                }
+                return empty_deltas, empty_states, stats
+
+        with torch.no_grad():
+            for k in range(max_iter):
+                # The input for step k is step_embed[k] projected, added to the normalized state
+                step_idx = min(k, self.step_embed.size(0) - 1)
+                step = self.step_proj(self.step_embed[step_idx]).view(1, 1, -1).expand(B, 1, -1)
+                
+                h_norm = self.thought_ln(current_embed)
+                h_input = h_norm.unsqueeze(1) + step
+
+                step_attn = None
+                if running_attn is not None:
+                    # Causal: attention mask GROWS by 1 at each step
+                    one = torch.ones((B, 1), dtype=running_attn.dtype, device=device)
+                    step_attn = torch.cat([running_attn, one], dim=1)
+
+                out = text_model(
+                    inputs_embeds=h_input,
+                    past_key_values=past_kv,
+                    attention_mask=step_attn,
+                    use_cache=True,
+                    return_dict=True,
+                )
+
+                # Next state
+                h_next = out.last_hidden_state.squeeze(1)
+                
+                # Compute delta to inject into this token's output representation
+                delta_raw = self.delta_proj(h_next)
+                delta = self._bounded_delta_from_raw(delta_raw, step_idx, scales)
+
+                # Early Halt Check (Value Head, tanh) — BEFORE committing delta
+                v_raw = self.value_head(h_next.unsqueeze(1)).squeeze(-1).squeeze(-1)  # (B,)
+                v_pred = torch.tanh(v_raw)
+
+                # Halt when v_pred drops below threshold (model says this step is harmful)
+                if not self.training:
+                    if (v_pred < halt_threshold).all():
+                        break
+
+                # Only commit the delta if we did NOT halt
+                thought_embeds.append(delta)
+                state_embeds.append(h_next)
+                raw_norms.append(delta_raw.norm(dim=-1))
+                scaled_norms.append(delta.norm(dim=-1))
+                v_preds.append(v_pred)
+
+                # Update context for the *next* iteration
+                past_kv = out.past_key_values
+                running_attn = step_attn
+                current_embed = h_next
+
+            # Grab the past_kv produced exactly prior to the final step
+            with torch.no_grad():
+                # We need to re-run up to final_step_idx-1 to get the exact past_kv?
+                # Actually, no. We can just run from initial_state and re-accumulate.
+                # BUT since max_iter <= n_latent is small (e.g. 4), we can just re-run 
+                # the *entire* sequence with gradients enabled!
+                pass
+                
+        # To make things simple and correct for training with such a small sequence (N=4),
+        # we can just re-run the FULL causal generation with gradients enabled and overwrite.
+        # This gives exact gradients through all thinking steps (BPTT).
+        if self.training:
+            thought_embeds_grad = []
+            state_embeds_grad = []
+            current_embed_grad = h  # Keep grad flow to init_proj
+            running_attn_grad = prefix_attention_mask
+            past_kv_grad = prefix_past_key_values
+            
+            # Re-run for exactly the number of steps we decided to take in the no_grad pass
+            for k in range(len(thought_embeds)):
+                step_idx = min(k, self.step_embed.size(0) - 1)
+                step = self.step_proj(self.step_embed[step_idx]).view(1, 1, -1).expand(B, 1, -1)
+                
+                h_norm = self.thought_ln(current_embed_grad)
+                h_input = h_norm.unsqueeze(1) + step
+
+                step_attn = None
+                if running_attn_grad is not None:
+                    one = torch.ones((B, 1), dtype=running_attn_grad.dtype, device=device)
+                    step_attn = torch.cat([running_attn_grad, one], dim=1)
+
+                out = text_model(
+                    inputs_embeds=h_input,
+                    past_key_values=past_kv_grad,  # Evolve KV cache like inference!
+                    attention_mask=step_attn,
+                    use_cache=True,
+                    return_dict=True,
+                )
+
+                h_next_g = out.last_hidden_state.squeeze(1)
+                
+                delta_raw_g = self.delta_proj(h_next_g)
+                delta_g = self._bounded_delta_from_raw(delta_raw_g, step_idx, scales)
+
+                thought_embeds_grad.append(delta_g)
+                state_embeds_grad.append(h_next_g)
+
+                # Detach state so CE-loss gradients don't flow back to previous steps.
+                # Each step is independently trained on its own delta (1-step truncated BPTT).
+                past_kv_grad = out.past_key_values
+                running_attn_grad = step_attn
+                current_embed_grad = h_next_g.detach()
+                
+            # Override the no_grad lists with the gradient-tracked ones
+            thought_embeds = thought_embeds_grad
+            state_embeds = state_embeds_grad
+            
+        # Stack sequences — guard against empty list when all steps halted
+        if not thought_embeds:
+            # All steps rejected by Value Head → return empty (K=0)
+            deltas = torch.zeros((B, 0, D), device=device, dtype=h.dtype)
+            states = torch.zeros((B, 0, D), device=device, dtype=h.dtype)
+            # Use initial state for value prediction
+            predicted_value = torch.tanh(self.value_head(h.unsqueeze(1)))
+            stats = {
+                "predicted_value": predicted_value.squeeze(-1).squeeze(-1),
+                "deq_iters": torch.tensor(0.0, device=device),
+                "raw_norm_mean": torch.zeros(self.n_latent, device=device),
+                "raw_norm_std": torch.zeros(self.n_latent, device=device),
+                "scaled_norm_mean": torch.zeros(self.n_latent, device=device),
+                "scaled_norm_std": torch.zeros(self.n_latent, device=device),
+                "cos_mean": torch.zeros(self.n_latent, device=device),
+                "cos_std": torch.zeros(self.n_latent, device=device),
+                "scales": scales.detach(),
+                "diff_norm": torch.tensor(0.0, device=device),
+                "step_cos": torch.tensor(0.0, device=device),
+                "v_preds": None,
+                "gate": torch.zeros((B, 1), device=device),
+                "corrupted": _corrupted,
+                "skipped": True,
+            }
+            return deltas, states, stats
+
+        deltas = torch.stack(thought_embeds, dim=1) # (B, K, D)
+        states = torch.stack(state_embeds, dim=1)   # (B, K, D)
+        
+        # predicted_value: tanh [-1, 1] estimating LR's impact on CE at
+        # every latent state. Training supervises each step because inference
+        # may halt from any of these value predictions.
+        predicted_value = torch.tanh(self.value_head(states)).squeeze(-1)  # (B, K)
+
+        # Gate: average tanh v_pred across all steps, scaled to [0, 1] for gated delta injection
+        v_preds_stacked = torch.stack(v_preds, dim=1) if v_preds else None  # (B, K)
+        if v_preds_stacked is not None:
+            gate = (v_preds_stacked.mean(dim=1, keepdim=True) + 1.0) / 2.0  # (B, 1) — mean confidence mapped to [0, 1]
+        else:
+            gate = (predicted_value.squeeze(-1) + 1.0) / 2.0  # fallback, scaled to [0, 1]
+
+        deq_iters = len(thought_embeds)
+
+        raw_tensor = torch.stack(raw_norms, dim=1)
+        scaled_tensor = torch.stack(scaled_norms, dim=1)
+        scales_val = scales.detach()
+
+        with torch.no_grad():
+            flat_states = states.view(-1, D)
+            flat_states_norm = F.normalize(flat_states, dim=-1)
+
+            word_emb_weight = self.embed_tokens.weight
+            vocab_size = word_emb_weight.size(0)
+            if vocab_size > 10000:
+                idx = torch.randperm(vocab_size, device=device)[:10000]
+                word_emb_sub = word_emb_weight[idx]
+            else:
+                word_emb_sub = word_emb_weight
+
+            word_emb_norm = F.normalize(word_emb_sub, dim=-1)
+            sim_matrix = torch.matmul(flat_states_norm, word_emb_norm.t())
+            if sim_matrix.numel() > 0:
+                max_sim, _ = sim_matrix.max(dim=-1)
+                cos_mean_val = max_sim.mean()
+                cos_std_val = max_sim.std(unbiased=False)
+            else:
+                cos_mean_val = flat_states_norm.new_tensor(0.0)
+                cos_std_val = flat_states_norm.new_tensor(0.0)
+
+        if deltas.size(1) > 1:
+            diffs = deltas[:, 1:] - deltas[:, :-1]
+            diff_norm_val = diffs.norm(dim=-1).mean()
+            step_cos_val = F.cosine_similarity(deltas[:, 1:], deltas[:, :-1], dim=-1).mean()
+        else:
+            diff_norm_val = deltas.new_tensor(0.0)
+            step_cos_val = deltas.new_tensor(0.0)
+
+        stats = {
+            "predicted_value": predicted_value,  # (B, K) for per-step MSE against per-sample target
+            "deq_iters": torch.tensor(deq_iters, dtype=torch.float32, device=device),
+            "raw_norm_mean": raw_tensor.mean(dim=0).detach() if raw_tensor.ndim > 1 else raw_tensor.detach(),
+            "raw_norm_std": raw_tensor.std(dim=0, unbiased=False).detach() if raw_tensor.ndim > 1 else raw_tensor.new_zeros(raw_tensor.size(-1)),
+            "scaled_norm_mean": scaled_tensor.mean(dim=0).detach() if scaled_tensor.ndim > 1 else scaled_tensor.detach(),
+            "scaled_norm_std": scaled_tensor.std(dim=0, unbiased=False).detach() if scaled_tensor.ndim > 1 else scaled_tensor.new_zeros(scaled_tensor.size(-1)),
+            "cos_mean": torch.full((self.n_latent,), cos_mean_val.item(), device=device),
+            "cos_std": torch.full((self.n_latent,), cos_std_val.item(), device=device),
+            "scales": scales_val,
+            "diff_norm": diff_norm_val.detach(),
+            "step_cos": step_cos_val.detach(),
+            "v_preds": v_preds_stacked.detach() if v_preds_stacked is not None else None,
+            "gate": gate.detach(),
+            "corrupted": _corrupted,
+        }
+        return deltas, states, stats
+
+    def _compute_causal_thoughts(
+        self,
+        inputs_embeds: torch.Tensor,
+        input_ids: torch.LongTensor,
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, Dict[str, torch.Tensor]]:
+        """Two-pass causal thought injection for interleaved mode.
+
+        Each NT token at position ``k`` receives a thought delta computed from
+        the hidden state at position ``k-1`` (the token immediately before it).
+        This makes each thought *causal*: it can attend to all previous context
+        including the word generated just before it, which aligns with ASR's
+        left-to-right generation structure.
+
+        Pass 1 (``no_grad``): forward the full sequence with **base** NT
+        embeddings to capture all hidden states ``h_all``.
+
+        Pass 2 (with grad): for each NT at position k, compute a delta from
+        ``h_all[:, k-1, :]`` via ``init_proj → delta_proj → normalize →
+        scale``.  Inject the modified NT embedding and return the updated
+        ``inputs_embeds``.
+
+        Args:
+            inputs_embeds: ``(B, SeqLen, D)`` embedding tensor (base NT
+                embeddings already placed at NT positions by
+                ``_get_native_audio_embeds``).
+            input_ids: ``(B, SeqLen)`` token id tensor to locate NT positions.
+
+        Returns:
+            ``(modified_embeds, deltas_padded, states_padded, stats)`` where
+            ``deltas_padded`` and ``states_padded`` have shape
+            ``(B, max_nt, D)`` (zero-padded to the batch maximum NT count).
+        """
+        B, SeqLen, D = inputs_embeds.shape
+        device = inputs_embeds.device
+
+        nt_mask = (input_ids == self.nt_token_id)  # (B, SeqLen)
+        batch_idx, nt_pos = torch.nonzero(nt_mask, as_tuple=True)
+
+        if len(nt_pos) == 0:
+            empty_d = inputs_embeds.new_zeros((B, 0, D))
+            empty_s = inputs_embeds.new_zeros((B, 0, D))
+            dummy = inputs_embeds.new_tensor(0.0)
+            stats: Dict[str, torch.Tensor] = {
+                "raw_norm_mean": inputs_embeds.new_zeros((0,)),
+                "raw_norm_std": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_mean": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_std": inputs_embeds.new_zeros((0,)),
+                "cos_mean": inputs_embeds.new_zeros((0,)),
+                "cos_std": inputs_embeds.new_zeros((0,)),
+                "scales": inputs_embeds.new_zeros((0,)),
+                "diff_norm": dummy,
+                "step_cos": dummy,
+            }
+            return inputs_embeds, empty_d, empty_s, stats
+
+        # --- Pass 1: no_grad forward to capture all hidden states ----------
+        with torch.no_grad():
+            out1 = self.text_model(
+                inputs_embeds=inputs_embeds,
+                use_cache=False,
+                return_dict=True,
+            )
+        h_all = out1.last_hidden_state  # (B, SeqLen, D) - detached in no_grad
+
+        # Context for each NT at position k is h_all[:, k-1, :]
+        ctx_pos = (nt_pos - 1).clamp(min=0)  # (N_total,)
+        contexts = h_all[batch_idx, ctx_pos]  # (N_total, D)
+
+        # --- Pass 2: generate deltas (with grad) ---------------------------
+        ctx_norm = F.normalize(contexts.float(), dim=-1).to(dtype=inputs_embeds.dtype)
+        h_proj = self.init_proj(ctx_norm)         # (N_total, D)
+        delta_raw = self.delta_proj(h_proj)       # (N_total, D)
+        if self.latent_use_bounded_delta:
+            delta_raw_f32 = delta_raw.float()
+            norm_val = delta_raw_f32.norm(dim=-1, keepdim=True)
+            delta_dir = (delta_raw_f32 / (norm_val + 1e-6)).to(dtype=delta_raw.dtype)
+            scale = self.step_scales().mean()     # scalar - shared across all positions
+            delta = delta_dir * scale             # (N_total, D)
+        else:
+            delta = delta_raw
+
+        # Build NT embeddings and inject
+        # base_nt_ids and nt_embeds are moved down to use the scaled delta
+
+
+        # --- Pack into (B, max_nt, D) for loss functions -------------------
+        nt_counts = nt_mask.sum(dim=1)  # (B,)
+        max_nt = int(nt_counts.max().item())
+        deltas_padded = inputs_embeds.new_zeros((B, max_nt, D))
+        states_padded = inputs_embeds.new_zeros((B, max_nt, D))
+        for b in range(B):
+            b_mask = (batch_idx == b)
+            cnt = int(nt_counts[b].item())
+            if cnt > 0:
+                deltas_padded[b, :cnt] = delta[b_mask]
+                states_padded[b, :cnt] = contexts[b_mask]
+
+        # --- Stats for logging (shape matches prefix-mode stats) ------------
+        with torch.no_grad():
+            delta_for_stats = delta.float()
+            raw_norms = delta_raw.norm(dim=-1)       # (N_total,)
+            scaled_norms = delta_for_stats.norm(dim=-1)
+            flat_ctx_norm = F.normalize(contexts, dim=-1)
+            word_emb = self.embed_tokens.weight
+            vocab_size = word_emb.size(0)
+            if vocab_size > 10000:
+                idx = torch.randperm(vocab_size, device=device)[:10000]
+                word_emb_sub = word_emb[idx]
+            else:
+                word_emb_sub = word_emb
+            word_emb_norm = F.normalize(word_emb_sub, dim=-1)
+            sim_matrix = torch.matmul(flat_ctx_norm.to(word_emb_norm.dtype), word_emb_norm.t())
+            max_sim, _ = sim_matrix.max(dim=-1)
+            cos_mean_val = max_sim.mean()
+            cos_std_val = max_sim.std()
+            # Compute diff_norm and step_cos across padded deltas
+            if max_nt > 1:
+                diff = deltas_padded[:, 1:, :] - deltas_padded[:, :-1, :]
+                diff_norm_val = diff.norm(dim=-1).mean()
+                step_cos_val = F.cosine_similarity(
+                    deltas_padded[:, 1:, :], deltas_padded[:, :-1, :], dim=-1
+                ).mean()
+            else:
+                diff_norm_val = deltas_padded.new_tensor(0.0)
+                step_cos_val = deltas_padded.new_tensor(0.0)
+
+        # Inject deltas into embeddings (grad-tracked for training)
+        base_nt_ids = torch.full(
+            (len(batch_idx),), self.nt_token_id, dtype=torch.long, device=device
+        )
+        base_nt = self.embed_tokens(base_nt_ids).to(dtype=inputs_embeds.dtype)
+        delta_i = delta.to(dtype=inputs_embeds.dtype)
+        if self.latent_use_injection_gate:
+            gate_input = torch.cat([base_nt, delta_i], dim=-1)
+            delta_i = delta_i * self.injection_gate(gate_input)
+        if self.latent_use_embedding_anchor:
+            nt_embeds = base_nt + delta_i
+        else:
+            nt_embeds = delta_i
+
+        result_embeds = inputs_embeds.clone()
+        result_embeds[batch_idx, nt_pos] = nt_embeds
+
+        n_out = max_nt
+        stats = {
+            "raw_norm_mean": raw_norms.mean().unsqueeze(0).expand(n_out).detach(),
+            "raw_norm_std": raw_norms.std(unbiased=False).unsqueeze(0).expand(n_out).detach(),
+            "scaled_norm_mean": scaled_norms.mean().unsqueeze(0).expand(n_out).detach(),
+            "scaled_norm_std": scaled_norms.std(unbiased=False).unsqueeze(0).expand(n_out).detach(),
+            "cos_mean": torch.full((n_out,), cos_mean_val.item(), device=device),
+            "cos_std": torch.full((n_out,), cos_std_val.item(), device=device),
+            "scales": scale.unsqueeze(0).expand(n_out).detach(),
+            "diff_norm": diff_norm_val.detach(),
+            "step_cos": step_cos_val.detach(),
+        }
+        return result_embeds, deltas_padded, states_padded, stats
+
+    @torch.no_grad()
+    def _generate_interleaved(
+        self,
+        base_embeds: torch.Tensor,
+        attention_mask: torch.LongTensor,
+        max_new_tokens: int,
+        do_sample: bool = False,
+        temperature: float = 1.0,
+    ) -> torch.LongTensor:
+        """Token-by-token generation with interleaved thought injection.
+
+        Before each group of ``self.thought_group_size`` generated word tokens,
+        a thought delta is computed from the current sequence's last hidden
+        state, and an NT token (with the modified embedding) is prepended.
+
+        NT tokens in the output are included as ``self.nt_token_id`` so that
+        callers using ``skip_special_tokens=True`` in ``tokenizer.decode`` will
+        strip them automatically (since ``<|latent|>`` is a registered special
+        token).
+
+        Args:
+            base_embeds: ``(1, SeqLen, D)`` audio-fused embeddings of the
+                prompt prefix (no NT tokens appended yet).
+            attention_mask: ``(1, SeqLen)`` attention mask for *base_embeds*.
+            max_new_tokens: Maximum number of word tokens to generate.
+            do_sample: Whether to sample instead of greedy decode.
+            temperature: Sampling temperature (ignored if ``do_sample=False``).
+
+        Returns:
+            ``(1, N_generated)`` LongTensor of token ids including interleaved
+            NT tokens and ending with the first EOS/stop token encountered.
+        """
+        eos_ids: set = set(self.stop_ids)
+        device = base_embeds.device
+        safe_temp = float(temperature) if float(temperature) > 0 else 1.0
+
+        cur_embeds = base_embeds.clone()
+        cur_attn = attention_mask.clone()
+        generated: List[torch.Tensor] = []
+        words_generated = 0
+
+        nt_id_t = torch.tensor([[self.nt_token_id]], dtype=torch.long, device=device)
+        base_nt_emb = self.embed_tokens(nt_id_t).to(dtype=cur_embeds.dtype)  # (1, 1, D)
+
+        def _append_thought() -> None:
+            """Compute a thought from the last hidden state and inject NT."""
+            nonlocal cur_embeds, cur_attn
+            # Get context = last hidden state of current sequence
+            ctx_out = self.text_model(
+                inputs_embeds=cur_embeds,
+                use_cache=False,
+                return_dict=True,
+            )
+            h_last = ctx_out.last_hidden_state[:, -1:, :]  # (1, 1, D)
+            h_norm = F.normalize(h_last.float().squeeze(1), dim=-1).to(dtype=cur_embeds.dtype)
+            h_proj = self.init_proj(h_norm)
+            delta_raw = self.delta_proj(h_proj)
+            if self.latent_use_bounded_delta:
+                delta_dir = F.normalize(delta_raw, dim=-1)
+                scale = self.step_scales().mean()
+                delta_scaled = (delta_dir * scale).float().to(dtype=cur_embeds.dtype)
+            else:
+                delta_scaled = delta_raw.float().to(dtype=cur_embeds.dtype)
+            
+            # Use Tanh Value Head for Interleaved mode as well
+            if hasattr(self, "value_head"):
+                v_raw = self.value_head(h_norm) # (1, 1)
+                v_pred = (torch.tanh(v_raw) + 1.0) / 2.0 # (1, 1) -> scaled to [0, 1]
+                halt_thresh = float(getattr(self.config, "halt_threshold", 0.0))
+                # Skip injecting NT if predicted value < threshold
+                if v_pred.squeeze().item() < halt_thresh:
+                    return
+
+            delta_i = delta_scaled.unsqueeze(1)
+            if self.latent_use_injection_gate:
+                gate_input = torch.cat([base_nt_emb.expand_as(delta_i), delta_i], dim=-1)
+                delta_i = delta_i * self.injection_gate(gate_input)
+            if self.latent_use_embedding_anchor:
+                nt_emb_mod = base_nt_emb + delta_i
+            else:
+                nt_emb_mod = delta_i
+            cur_embeds = torch.cat([cur_embeds, nt_emb_mod], dim=1)
+            cur_attn = torch.cat([cur_attn, cur_attn.new_ones((1, 1))], dim=1)
+            generated.append(nt_id_t.clone())
+
+        for _ in range(max_new_tokens + len(generated)):
+            # Inject thought before each new group of words
+            if words_generated % self.thought_group_size == 0:
+                _append_thought()
+
+            # Generate next word token
+            out = self.thinker(
+                inputs_embeds=cur_embeds,
+                attention_mask=cur_attn,
+                input_features=None,
+                use_cache=False,
+                return_dict=True,
+            )
+            next_logits = out.logits[:, -1, :]
+            if do_sample:
+                probs = F.softmax(next_logits / safe_temp, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+            else:
+                next_token = torch.argmax(next_logits, dim=-1, keepdim=True)
+
+            tok_id = int(next_token[0, 0].item())
+            generated.append(next_token)
+            if tok_id in eos_ids:
+                break
+
+            next_emb = self.embed_tokens(next_token)
+            cur_embeds = torch.cat([cur_embeds, next_emb], dim=1)
+            cur_attn = torch.cat([cur_attn, cur_attn.new_ones((1, 1))], dim=1)
+            words_generated += 1
+
+        if not generated:
+            return torch.zeros((1, 0), dtype=torch.long, device=device)
+        return torch.cat(generated, dim=1)
+
+    # ------------------------------------------------------------------
+    # Forward passes
+    # ------------------------------------------------------------------
+
+    def _forward_native(
+        self,
+        input_features: torch.FloatTensor,
+        labels: torch.LongTensor,
+        feature_attention_mask: torch.LongTensor,
+        language_hint: Optional[str] = None,
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor], torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Native thinker forward for LoRA / baseline FT."""
+        B = input_features.size(0)
+        device = input_features.device
+
+        pad_token_id = self.processor.tokenizer.pad_token_id
+        if pad_token_id is None:
+            pad_token_id = self.processor.tokenizer.eos_token_id or 151643
+
+        input_ids_list = []
+        labels_list = []
+        label_pad = -100
+
+        audio_lengths = self._get_audio_lengths(input_features, feature_attention_mask)
+        system_turn, user_prefix, user_prompt, user_suffix, _ = (
+            self._build_chat_template_tensors(device, language=language_hint or "English")
+        )
+
+        for i in range(B):
+            valid_len = (labels[i] != label_pad).sum().item()
+            text_all = labels[i, :valid_len]
+            l_audio = audio_lengths[i]
+
+            audio_toks = build_audio_token_seq(
+                self.audio_bos_token_id, self.audio_token_id, self.audio_eos_token_id,
+                l_audio, device,
+            )
+            full_ids, full_labels = self._build_full_sequence(
+                audio_toks, text_all, system_turn, user_prefix, user_prompt, user_suffix,
+                label_pad=label_pad, n_extra_mask=0,
+            )
+            input_ids_list.append(full_ids)
+            labels_list.append(full_labels)
+
+        max_len = max(x.size(0) for x in input_ids_list)
+        input_ids_batch = torch.full((B, max_len), pad_token_id, dtype=torch.long, device=device)
+        labels_batch = torch.full((B, max_len), label_pad, dtype=torch.long, device=device)
+        for i in range(B):
+            l = input_ids_list[i].size(0)
+            input_ids_batch[i, :l] = input_ids_list[i]
+            labels_batch[i, :l] = labels_list[i]
+
+        attention_mask = (input_ids_batch != pad_token_id).long()
+
+        out = self.thinker(
+            input_ids=input_ids_batch,
+            attention_mask=attention_mask,
+            input_features=input_features,
+            feature_attention_mask=feature_attention_mask,
+            labels=None,
+            return_dict=True,
+        )
+        logits = out.logits
+
+        # One-time audio diagnostic
+        if not getattr(self, "_native_diag_done", False):
+            self._native_diag_done = True
+            import sys as _s
+            _d = _s.stderr.write
+            _d(f"\n[native-diag] thinker type: {type(self.thinker).__name__}\n")
+            _d(f"[native-diag] has base_model (PEFT): {hasattr(self.thinker, 'base_model')}\n")
+            n_audio_ph = (input_ids_batch[0] == self.audio_token_id).sum().item()
+            feat_valid = (
+                feature_attention_mask[0].sum().item()
+                if feature_attention_mask is not None
+                else input_features.size(2)
+            )
+            _d(f"[native-diag] audio_token_id={self.audio_token_id} decoded={self.processor.tokenizer.convert_ids_to_tokens(self.audio_token_id)!r}\n")
+            _d(f"[native-diag] input_features: {list(input_features.shape)}, valid_mel_frames={feat_valid}\n")
+            _d(f"[native-diag] input_ids shape: {list(input_ids_batch.shape)}\n")
+            _d(f"[native-diag] input_features shape: {list(input_features.shape)}\n")
+            _d(f"[native-diag] audio placeholder tokens in input_ids[0]: {n_audio_ph}\n")
+            _d(f"[native-diag] audio_bos/eos in ids[0]: bos={int((input_ids_batch[0]==self.audio_bos_token_id).sum())} eos={int((input_ids_batch[0]==self.audio_eos_token_id).sum())}\n")
+            with torch.no_grad():
+                try:
+                    zero_feat = torch.zeros_like(input_features[:1])
+                    out_noaud = self.thinker(
+                        input_ids=input_ids_batch[:1],
+                        attention_mask=attention_mask[:1],
+                        input_features=zero_feat,
+                        feature_attention_mask=feature_attention_mask[:1] if feature_attention_mask is not None else None,
+                        labels=None,
+                        return_dict=True,
+                    )
+                    diff = (logits[0] - out_noaud.logits[0]).abs().mean().item()
+                    _d(f"[native-diag] logit diff (real vs zero audio): {diff:.6f}\n")
+                    if diff < 0.01:
+                        _d(f"[native-diag] ⚠️  AUDIO NOT BEING USED! Logits identical with zero audio.\n")
+                    else:
+                        _d(f"[native-diag] ✓ Audio IS affecting logits (diff={diff:.4f})\n")
+                except Exception as e:
+                    _d(f"[native-diag] zero-audio test failed: {e}\n")
+            tok_str = self.processor.tokenizer.decode(input_ids_batch[0, :15].tolist())
+            _d(f"[native-diag] input_ids[0][:15] decoded: {repr(tok_str)}\n")
+            _s.stderr.flush()
+
+        # Pre-shift labels for loss
+        labels_for_loss = torch.full_like(labels_batch, label_pad)
+        labels_for_loss[:, :-1] = labels_batch[:, 1:]
+
+        D = self._hidden_size
+        dummy = logits.new_tensor(0.0)
+        stats = {
+            "raw_norm_mean": logits.new_zeros((0,)),
+            "raw_norm_std": logits.new_zeros((0,)),
+            "scaled_norm_mean": logits.new_zeros((0,)),
+            "scaled_norm_std": logits.new_zeros((0,)),
+            "cos_mean": logits.new_zeros((0,)),
+            "cos_std": logits.new_zeros((0,)),
+            "scales": logits.new_zeros((0,)),
+            "diff_norm": dummy,
+            "step_cos": dummy,
+        }
+        deltas = logits.new_zeros((B, 0, D))
+        states = logits.new_zeros((B, 0, D))
+        initial_state = logits.new_zeros((B, D))
+
+        return logits, stats, deltas, states, labels_for_loss, initial_state
+
+    def forward(
+        self,
+        input_features: torch.FloatTensor,
+        labels: torch.LongTensor,
+        feature_attention_mask: Optional[torch.LongTensor] = None,
+        global_step: int = 0,
+        language_hint: Optional[str] = None,
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor], torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Forward pass for training."""
+        B = input_features.size(0)
+        device = input_features.device
+
+        if feature_attention_mask is None:
+            feature_attention_mask = torch.ones(
+                (B, input_features.size(2)), dtype=torch.long, device=device
+            )
+
+        # Fast path: use thinker's native forward for LoRA / baseline FT.
+        if not self.use_latent and not self.use_soft_prompt:
+            return self._forward_native(input_features, labels, feature_attention_mask, language_hint=language_hint)
+
+        audio_lengths = self._get_audio_lengths(input_features, feature_attention_mask)
+
+        new_input_ids_list = []
+        new_labels_list = []
+
+        label_pad = -100
+        pad_token_id = self.processor.tokenizer.pad_token_id
+        if pad_token_id is None:
+            pad_token_id = self.processor.tokenizer.eos_token_id or 151643
+
+        system_turn, user_prefix, user_prompt, user_suffix, _ = (
+            self._build_chat_template_tensors(device, language=language_hint or "English")
+        )
+
+        interleaved_mode = self.use_latent and self.thought_mode == "interleaved"
+
+        # +++ LATENT DROP +++
+        drop_latent_this_batch = False
+        if self.training and self.use_latent and not interleaved_mode:
+            drop_prob = self.latent_drop_prob
+            if drop_prob > 0.0 and torch.rand(1).item() < drop_prob:
+                drop_latent_this_batch = True
+        
+        actual_n_latent = 0 if drop_latent_this_batch else self.n_latent
+
+        for i in range(B):
+            valid_len = (labels[i] != label_pad).sum().item()
+            text_all = labels[i, :valid_len]
+            if drop_latent_this_batch:
+                text_all = text_all[text_all != self.nt_token_id]
+
+            l_audio = audio_lengths[i]
+
+            audio_toks = build_audio_token_seq(
+                self.audio_bos_token_id, self.audio_token_id, self.audio_eos_token_id,
+                l_audio, device,
+            )
+            if interleaved_mode:
+                # NT tokens are scattered throughout text_all; mask all NT positions.
+                full_ids, full_labels = self._build_full_sequence(
+                    audio_toks, text_all, system_turn, user_prefix, user_prompt, user_suffix,
+                    label_pad=label_pad, n_extra_mask=0, mask_all_nt=True,
+                )
+            else:
+                # Prefix mode: all NT tokens appear contiguously after asst_nl.
+                full_ids, full_labels = self._build_full_sequence(
+                    audio_toks, text_all, system_turn, user_prefix, user_prompt, user_suffix,
+                    label_pad=label_pad, n_extra_mask=actual_n_latent,
+                )
+            new_input_ids_list.append(full_ids)
+            new_labels_list.append(full_labels)
+
+        max_len = max(x.size(0) for x in new_input_ids_list)
+        new_input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long, device=device)
+        new_labels_raw = torch.full((B, max_len), label_pad, dtype=torch.long, device=device)
+
+        for i in range(B):
+            l = new_input_ids_list[i].size(0)
+            new_input_ids[i, :l] = new_input_ids_list[i]
+            new_labels_raw[i, :l] = new_labels_list[i]
+
+        attention_mask = (new_input_ids != pad_token_id).long()
+
+        inputs_embeds = self._get_native_audio_embeds(
+            input_ids=new_input_ids,
+            input_features=input_features,
+            feature_attention_mask=feature_attention_mask,
+            attention_mask=attention_mask,
+        )
+
+        # +++ LATENT INPUT NOISE (Value Head Regularization) +++
+        # Save pre-LR embeddings (with noise) for fair baseline CE comparison
+        pre_lr_embeds = None
+        if self.training:
+            noise_std = self.latent_input_noise_std
+            if noise_std > 0.0:
+                noise = torch.randn_like(inputs_embeds) * noise_std
+                inputs_embeds = inputs_embeds + noise
+            # Save the (possibly noisy) embeddings BEFORE LR injection
+            if self.use_latent:
+                pre_lr_embeds = inputs_embeds.detach().clone()
+
+        # Latent / soft-prompt injection
+        if self.use_latent and interleaved_mode:
+            # Interleaved: two-pass causal thought generation.
+            inputs_embeds, deltas, states, stats = self._compute_causal_thoughts(
+                inputs_embeds, new_input_ids
+            )
+            initial_state = inputs_embeds.new_zeros((B, self._hidden_size))
+        elif self.use_latent:
+            if actual_n_latent == 0:
+                initial_state = inputs_embeds.new_zeros((B, self._hidden_size))
+                deltas = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+                states = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+                stats = {
+                    "raw_norm_mean": inputs_embeds.new_zeros((0,)),
+                    "raw_norm_std": inputs_embeds.new_zeros((0,)),
+                    "scaled_norm_mean": inputs_embeds.new_zeros((0,)),
+                    "scaled_norm_std": inputs_embeds.new_zeros((0,)),
+                    "cos_mean": inputs_embeds.new_zeros((0,)),
+                    "cos_std": inputs_embeds.new_zeros((0,)),
+                    "scales": inputs_embeds.new_zeros((0,)),
+                    "diff_norm": inputs_embeds.new_tensor(0.0),
+                    "step_cos": inputs_embeds.new_tensor(0.0),
+                }
+            else:
+                # Prefix mode: recurrent thought loop from audio-prefix state.
+                initial_state, prefix_past_kv, prefix_attn = self._compute_prefix_state(
+                    inputs_embeds, new_input_ids, strict=True
+                )
+                deltas, states, stats = self._compute_continuous_thoughts(
+                    initial_state,
+                    prefix_past_key_values=prefix_past_kv,
+                    prefix_attention_mask=prefix_attn,
+                )
+                inputs_embeds = self._inject_latent_deltas(
+                    inputs_embeds, new_input_ids, deltas
+                )
+        elif self.use_soft_prompt:
+            nt_mask = (new_input_ids == self.nt_token_id)
+            nt_counts = nt_mask.sum(dim=1)
+            assert (nt_counts == self.n_latent).all(), (
+                f"NT token count mismatch! {nt_counts} vs {self.n_latent}"
+            )
+            prompt = self.soft_prompt_embed.to(dtype=inputs_embeds.dtype)
+            prompt = prompt.unsqueeze(0).expand(B, -1, -1).contiguous()
+            batch_idx, seq_idx = torch.nonzero(nt_mask, as_tuple=True)
+            prompt_embeds = inputs_embeds.clone()
+            prompt_embeds[batch_idx, seq_idx, :] = prompt.view(-1, self._hidden_size)
+            inputs_embeds = prompt_embeds
+            initial_state = inputs_embeds.new_zeros((B, self._hidden_size))
+            deltas = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+            states = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+            stats = {
+                "raw_norm_mean": inputs_embeds.new_zeros((0,)),
+                "raw_norm_std": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_mean": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_std": inputs_embeds.new_zeros((0,)),
+                "cos_mean": inputs_embeds.new_zeros((0,)),
+                "cos_std": inputs_embeds.new_zeros((0,)),
+                "scales": inputs_embeds.new_zeros((0,)),
+                "diff_norm": inputs_embeds.new_tensor(0.0),
+                "step_cos": inputs_embeds.new_tensor(0.0),
+            }
+        else:
+            initial_state = inputs_embeds.new_zeros((B, self._hidden_size))
+            deltas = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+            states = inputs_embeds.new_zeros((B, 0, self._hidden_size))
+            stats = {
+                "raw_norm_mean": inputs_embeds.new_zeros((0,)),
+                "raw_norm_std": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_mean": inputs_embeds.new_zeros((0,)),
+                "scaled_norm_std": inputs_embeds.new_zeros((0,)),
+                "cos_mean": inputs_embeds.new_zeros((0,)),
+                "cos_std": inputs_embeds.new_zeros((0,)),
+                "scales": inputs_embeds.new_zeros((0,)),
+                "diff_norm": inputs_embeds.new_tensor(0.0),
+                "step_cos": inputs_embeds.new_tensor(0.0),
+            }
+
+        out = self.thinker(
+            inputs_embeds=inputs_embeds,
+            input_ids=new_input_ids,
+            attention_mask=attention_mask,
+            input_features=None,
+            feature_attention_mask=None,
+            labels=None,
+            use_cache=False,
+            return_dict=True,
+        )
+        logits = out.logits
+
+        new_labels = torch.full_like(new_labels_raw, label_pad)
+        new_labels[:, :-1] = new_labels_raw[:, 1:]
+
+        if logits.size(1) != new_labels.size(1):
+            if logits.size(1) > new_labels.size(1):
+                shift = logits.size(1) - new_labels.size(1)
+                logits = logits[:, shift:, :]
+            else:
+                new_labels = new_labels[:, -logits.size(1):]
+
+        # ---- Baseline CE vs LR CE for Value Head MSE (Delta CE) ----
+        # Compute per-sample CE for both baseline (no LR) and LR-enhanced
+        # forward passes. The difference (baseline_ce - lr_ce) forms the
+        # continuous target for the Value Head via tanh compression.
+        if self.use_latent and self.training and deltas.size(1) > 0:
+            with torch.no_grad():
+                # Use the SAME (possibly noisy) embeddings but WITHOUT LR deltas
+                # This ensures a fair comparison: noisy-no-LR vs noisy-with-LR
+                if pre_lr_embeds is not None:
+                    baseline_embeds = pre_lr_embeds
+                else:
+                    baseline_embeds = self._get_native_audio_embeds(
+                        input_ids=new_input_ids,
+                        input_features=input_features,
+                        feature_attention_mask=feature_attention_mask,
+                        attention_mask=attention_mask,
+                    )
+                baseline_out = self.thinker(
+                    inputs_embeds=baseline_embeds,
+                    input_ids=new_input_ids,
+                    attention_mask=attention_mask,
+                    input_features=None,
+                    feature_attention_mask=None,
+                    labels=None,
+                    use_cache=False,
+                    return_dict=True,
+                )
+                baseline_logits = baseline_out.logits
+                if baseline_logits.size(1) != new_labels.size(1):
+                    if baseline_logits.size(1) > new_labels.size(1):
+                        shift = baseline_logits.size(1) - new_labels.size(1)
+                        baseline_logits = baseline_logits[:, shift:, :]
+                    else:
+                        bl_labels = new_labels[:, -baseline_logits.size(1):]
+                else:
+                    bl_labels = new_labels
+
+                # Per-SAMPLE CE: for each sample in batch, compute CE on valid tokens.
+                # This is used by train.py to form the continuous delta_ce target.
+                valid_mask = (bl_labels != -100)  # (B, T)
+                valid_per_sample = valid_mask.float().sum(dim=1).clamp(min=1)  # (B,)
+
+                # For value head accuracy: exclude asr_prefix tokens
+                # ("language", "English", "<asr_text>") which are trivially correct
+                # and dilute the real transcript accuracy signal.
+                asr_prefix_set = set(self.asr_prefix_ids)
+                asr_prefix_mask = torch.zeros_like(bl_labels, dtype=torch.bool)
+                for tid in asr_prefix_set:
+                    asr_prefix_mask |= (bl_labels == tid)
+                acc_mask = valid_mask & ~asr_prefix_mask  # exclude prefix tokens
+                acc_per_sample = acc_mask.float().sum(dim=1).clamp(min=1)
+
+                if not hasattr(self, '_acc_debug_printed'):
+                    self._acc_debug_printed = True
+                    total_tokens = bl_labels.size(1)
+                    ce_valid = valid_per_sample.mean().item()
+                    acc_valid = acc_per_sample.mean().item()
+                    sample_acc_toks = bl_labels[0][acc_mask[0]][:20].tolist()
+                    sample_decoded = self.processor.tokenizer.decode(sample_acc_toks)
+                    print(f"\n[ACC-DEBUG] total={total_tokens} ce_valid={ce_valid:.0f} acc_valid={acc_valid:.0f}")
+                    print(f"[ACC-DEBUG] first 20 acc label ids: {sample_acc_toks}")
+                    print(f"[ACC-DEBUG] decoded: {sample_decoded}")
+                if valid_mask.any():
+                    # Per-sample baseline CE (uses full valid_mask for loss)
+                    loss_fct_none = torch.nn.CrossEntropyLoss(ignore_index=-100, reduction='none')
+                    bl_ce_per_token = loss_fct_none(
+                        baseline_logits.reshape(-1, baseline_logits.size(-1)),
+                        bl_labels.reshape(-1),
+                    ).view(B, -1)  # (B, T)
+                    baseline_ce_per_sample = bl_ce_per_token.sum(dim=1) / valid_per_sample  # (B,)
+                    stats["baseline_ce"] = baseline_ce_per_sample  # (B,)
+
+                    # Per-sample LR CE (for fair Delta CE comparison)
+                    lr_logits_for_ce = logits
+                    if lr_logits_for_ce.size(1) != bl_labels.size(1):
+                        lr_logits_for_ce = lr_logits_for_ce[:, -bl_labels.size(1):, :]
+                    lr_ce_per_token = loss_fct_none(
+                        lr_logits_for_ce.reshape(-1, lr_logits_for_ce.size(-1)),
+                        bl_labels.reshape(-1),
+                    ).view(B, -1)
+                    lr_ce_per_sample = lr_ce_per_token.sum(dim=1) / valid_per_sample
+                    stats["lr_ce"] = lr_ce_per_sample # (B,)
+
+                    # Per-sample accuracy for VALUE HEAD (uses acc_mask, excludes prefix)
+                    baseline_preds = baseline_logits.argmax(dim=-1)  # (B, T)
+                    lr_preds = logits.argmax(dim=-1)                 # (B, T)
+                    if lr_preds.size(1) != bl_labels.size(1):
+                        lr_preds = lr_preds[:, -bl_labels.size(1):]
+                    baseline_correct = ((baseline_preds == bl_labels) & acc_mask).float()
+                    lr_correct = ((lr_preds == bl_labels) & acc_mask).float()
+                    baseline_acc = baseline_correct.sum(dim=1) / acc_per_sample  # (B,)
+                    lr_acc = lr_correct.sum(dim=1) / acc_per_sample              # (B,)
+                    stats["baseline_acc"] = baseline_acc
+                    stats["lr_acc"] = lr_acc
+
+                    # Error-conditional metrics for value head target (uses acc_mask)
+                    baseline_wrong = ((baseline_preds != bl_labels) & acc_mask)  # (B, T)
+                    baseline_right = ((baseline_preds == bl_labels) & acc_mask)  # (B, T)
+                    lr_fixes = ((lr_preds == bl_labels) & baseline_wrong).float().sum(dim=1)   # (B,)
+                    lr_breaks = ((lr_preds != bl_labels) & baseline_right).float().sum(dim=1)  # (B,)
+                    baseline_errors = baseline_wrong.float().sum(dim=1).clamp(min=1)           # (B,)
+                    stats["lr_fixes"] = lr_fixes
+                    stats["lr_breaks"] = lr_breaks
+                    stats["baseline_errors"] = baseline_errors
+                else:
+                    B_size = logits.size(0)
+                    stats["baseline_ce"] = logits.new_zeros(B_size)
+                    stats["baseline_acc"] = logits.new_ones(B_size)
+                    stats["lr_acc"] = logits.new_ones(B_size)
+                    stats["lr_fixes"] = logits.new_zeros(B_size)
+                    stats["lr_breaks"] = logits.new_zeros(B_size)
+                    stats["baseline_errors"] = logits.new_ones(B_size)
+
+        return logits, stats, deltas, states, new_labels, initial_state
+
+    @torch.no_grad()
+    def _generate_with_forward_fallback(
+        self,
+        start_ids: torch.LongTensor,
+        inputs_embeds: torch.FloatTensor,
+        attention_mask: torch.LongTensor,
+        max_new_tokens: int,
+        eos_token_id: Optional[Any],
+        do_sample: bool,
+        temperature: float,
+    ) -> torch.LongTensor:
+        """Fallback decoder when ``.generate(inputs_embeds=...)`` is unsupported."""
+        if eos_token_id is None:
+            eos_ids: List[int] = []
+        elif isinstance(eos_token_id, (list, tuple, set)):
+            eos_ids = [int(x) for x in eos_token_id]
+        else:
+            eos_ids = [int(eos_token_id)]
+
+        generated_tokens: List[torch.Tensor] = []
+        safe_temp = float(temperature) if float(temperature) > 0 else 1.0
+
+        cur_ids = start_ids.clone()
+        cur_embeds = inputs_embeds.clone()
+        cur_attn = attention_mask.clone()
+
+        for _ in range(int(max_new_tokens)):
+            out = self.thinker(
+                inputs_embeds=cur_embeds,
+                attention_mask=cur_attn,
+                input_features=None,
+                use_cache=False,
+                return_dict=True,
+            )
+            next_logits = out.logits[:, -1, :]
+
+            if do_sample:
+                probs = F.softmax(next_logits / safe_temp, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+            else:
+                next_token = torch.argmax(next_logits, dim=-1, keepdim=True)
+
+            generated_tokens.append(next_token)
+            if eos_ids and int(next_token[0, 0].item()) in eos_ids:
+                break
+
+            next_embed = self.embed_tokens(next_token)
+            cur_ids = torch.cat([cur_ids, next_token], dim=1)
+            cur_embeds = torch.cat([cur_embeds, next_embed], dim=1)
+            cur_attn = torch.cat(
+                [
+                    cur_attn,
+                    torch.ones(
+                        (cur_attn.size(0), 1),
+                        dtype=cur_attn.dtype,
+                        device=cur_attn.device,
+                    ),
+                ],
+                dim=1,
+            )
+
+        if not generated_tokens:
+            return start_ids.new_empty((start_ids.size(0), 0))
+        return torch.cat(generated_tokens, dim=1)
+
+    @torch.no_grad()
+    def generate(
+        self,
+        input_features: torch.FloatTensor,
+        feature_attention_mask: Optional[torch.LongTensor] = None,
+        max_new_tokens: int = 128,
+        use_baseline: bool = False,
+        return_thoughts: bool = False,
+        return_stats: bool = False,
+        language_hint: Optional[str] = None,
+        prompt_text: Optional[str] = None,
+        **gen_kwargs: Any,
+    ) -> Any:
+        """Generate a transcription with or without latent prompting."""
+        language_hint = gen_kwargs.pop("language_hint", language_hint)
+        prompt_text = gen_kwargs.pop("prompt_text", prompt_text)
+        dynamic_halt_threshold = gen_kwargs.pop("dynamic_halt_threshold", getattr(self, "halt_threshold", 0.0))
+
+        B = input_features.size(0)
+        assert B == 1, "Evaluation assumes batch size 1."
+        device = input_features.device
+
+        if feature_attention_mask is None:
+            feature_attention_mask = torch.ones(
+                (B, input_features.size(2)), dtype=torch.long, device=device
+            )
+        audio_lengths = self._get_audio_lengths(input_features, feature_attention_mask)
+
+        pad_token_id = self.processor.tokenizer.pad_token_id
+        if pad_token_id is None:
+            pad_token_id = self.processor.tokenizer.eos_token_id or 151643
+
+        l_audio = audio_lengths[0]
+        audio_toks = build_audio_token_seq(
+            self.audio_bos_token_id, self.audio_token_id, self.audio_eos_token_id,
+            l_audio, device,
+        ).unsqueeze(0)
+
+        system_turn, user_prefix, user_prompt, user_suffix, assistant_prefix = (
+            self._build_chat_template_tensors(device, language=language_hint or "English")
+        )
+        prefix = torch.cat(
+            [system_turn, user_prefix, audio_toks.squeeze(0), user_prompt, user_suffix, assistant_prefix],
+            dim=0,
+        ).unsqueeze(0)
+
+        latent_active = (not use_baseline) and self.use_latent
+        soft_prompt_active = (not use_baseline) and self.use_soft_prompt
+        interleaved_active = latent_active and self.thought_mode == "interleaved"
+
+        # For prefix mode: prepend NT tokens to the prompt.
+        # For interleaved mode: no upfront NT tokens; they are injected during generation.
+        front_prompt_active = latent_active or soft_prompt_active
+        if front_prompt_active and not interleaved_active:
+            nt_toks = torch.tensor([self.nt_token_id] * self.n_latent, device=device).unsqueeze(0)
+            start_ids = torch.cat([prefix, nt_toks], dim=1)
+        else:
+            start_ids = prefix
+
+        attention_mask = (start_ids != pad_token_id).long()
+        inputs_embeds = self._get_native_audio_embeds(
+            input_ids=start_ids,
+            input_features=input_features,
+            feature_attention_mask=feature_attention_mask,
+            attention_mask=attention_mask,
+        )
+
+        states = None
+        stats = {}
+        if interleaved_active:
+            # Interleaved generate: NT tokens injected token-by-token.
+            fallback_do_sample = bool(gen_kwargs.get("do_sample", False))
+            fallback_temperature = float(gen_kwargs.get("temperature", 1.0))
+            gen_ids = self._generate_interleaved(
+                base_embeds=inputs_embeds,
+                attention_mask=attention_mask,
+                max_new_tokens=max_new_tokens,
+                do_sample=fallback_do_sample,
+                temperature=fallback_temperature,
+            )
+            if return_thoughts:
+                return gen_ids, states
+            return gen_ids
+
+        if latent_active:
+            initial_state, prefix_past_kv, prefix_attn = self._compute_prefix_state(
+                inputs_embeds,
+                start_ids,
+                strict=True,
+                language=language_hint or "English",
+            )
+            deltas, states, stats = self._compute_continuous_thoughts(
+                initial_state,
+                prefix_past_key_values=prefix_past_kv,
+                prefix_attention_mask=prefix_attn,
+                halt_threshold=dynamic_halt_threshold,
+            )
+
+            K = deltas.size(1)
+            if K == 0:
+                # N=0 skip: remove ALL NT tokens, completely reverting to base generation.
+                remove_count = self.n_latent
+                start_ids = start_ids[:, :-remove_count]
+                inputs_embeds = inputs_embeds[:, :-remove_count, :]
+                attention_mask = attention_mask[:, :-remove_count]
+            elif K < self.n_latent:
+                # N > 0 but early halted: Remove the unneeded NT tokens instead of zero-padding them.
+                # This prevents the LLM from attending to "blank" un-updated base_nt embeddings.
+                remove_count = self.n_latent - K
+                start_ids = start_ids[:, :-remove_count]
+                inputs_embeds = inputs_embeds[:, :-remove_count, :]
+                attention_mask = attention_mask[:, :-remove_count]
+                inputs_embeds = self._inject_latent_deltas(
+                    inputs_embeds, start_ids, deltas
+                )
+            else:
+                inputs_embeds = self._inject_latent_deltas(
+                    inputs_embeds, start_ids, deltas
+                )
+        elif soft_prompt_active:
+            nt_mask = (start_ids == self.nt_token_id)
+            nt_counts = nt_mask.sum(dim=1)
+            assert (nt_counts == self.n_latent).all(), f"Gen NT count mismatch! {nt_counts}"
+            prompt = self.soft_prompt_embed.to(dtype=inputs_embeds.dtype)
+            batch_idx, seq_idx = torch.nonzero(nt_mask, as_tuple=True)
+            inputs_embeds = inputs_embeds.clone()
+            inputs_embeds[batch_idx, seq_idx, :] = prompt.view(-1, self._hidden_size)
+
+        if front_prompt_active:
+            is_nt = (start_ids == self.nt_token_id)
+            nt_counts = is_nt.sum(dim=1)
+            assert (nt_counts <= self.n_latent).all(), f"Gen NT count mismatch! {nt_counts}"
+
+        fallback_eos = gen_kwargs.get("eos_token_id", None)
+        fallback_do_sample = bool(gen_kwargs.get("do_sample", False))
+        fallback_temperature = float(gen_kwargs.get("temperature", 1.0))
+
+        try:
+            if latent_active and K == 0:
+                # N=0 skip -> we stripped the NT tokens from start_ids.
+                # Do NOT pass inputs_embeds so Qwen generates organically from text + audio ids.
+                # Must provide input_features so audio encoder handles the raw audio.
+                gen_out = self.thinker.generate(
+                    input_ids=start_ids,
+                    attention_mask=attention_mask,
+                    input_features=input_features,
+                    feature_attention_mask=feature_attention_mask,
+                    pad_token_id=pad_token_id,
+                    max_new_tokens=max_new_tokens,
+                    **gen_kwargs,
+                )
+            else:
+                gen_out = self.thinker.generate(
+                    inputs_embeds=inputs_embeds,
+                    input_ids=start_ids,
+                    attention_mask=attention_mask,
+                    input_features=None,
+                    pad_token_id=pad_token_id,
+                    max_new_tokens=max_new_tokens,
+                    **gen_kwargs,
+                )
+            start_len = start_ids.size(1)
+            gen_ids = gen_out[:, start_len:]
+        except ValueError as e:
+            msg = str(e)
+            if "inputs_embeds" not in msg:
+                raise
+            if not self._warned_generate_fallback:
+                print(
+                    "[warn] thinker.generate does not support inputs_embeds; "
+                    "using fallback decoding loop."
+                )
+                self._warned_generate_fallback = True
+            gen_ids = self._generate_with_forward_fallback(
+                start_ids=start_ids,
+                inputs_embeds=inputs_embeds,
+                attention_mask=attention_mask,
+                max_new_tokens=max_new_tokens,
+                eos_token_id=fallback_eos,
+                do_sample=fallback_do_sample,
+                temperature=fallback_temperature,
+            )
+        if return_stats:
+            if return_thoughts and latent_active:
+                return gen_ids, states, stats
+            return gen_ids, stats
+
+        if return_thoughts and latent_active:
+            return gen_ids, states
+        return gen_ids

model_metadata.json

@@ -0,0 +1,19 @@
+{
+  "project": "latentASR",
+  "model_repo": "voidful/latentASR",
+  "base_model": "Qwen/Qwen3-ASR-0.6B",
+  "checkpoint_file": "checkpoints/latentASR_adapter.pth",
+  "source_checkpoint": "activation_500_epoch10.pth",
+  "checkpoint_sha256": "f0ce39fa5e6952fced6992508f3e2b32ea8467442b545678781a0f04e64f2430",
+  "train_mode": "latent",
+  "n_latent": 4,
+  "train_max_samples": 500,
+  "adapter_parameters": 5251077,
+  "value_forced_neg_prob": 0.3,
+  "latent_use_bounded_delta": true,
+  "latent_use_injection_gate": true,
+  "latent_use_embedding_anchor": true,
+  "deployed_halt_threshold": 0.0,
+  "paper": "Listen, Think, Transcribe: Continuous Latent Test-Time Scaling for ASR"
+}
+

peft_utils.py

@@ -0,0 +1,94 @@
+"""PEFT adapter utilities for lr_whisper."""
+
+import os
+import re
+from typing import Any, Dict
+
+import torch
+import torch.nn as nn
+
+from config import TrainingConfig
+
+
+def attach_peft_adapter(
+    asr_model: nn.Module,
+    cfg: TrainingConfig,
+) -> Dict[str, Any]:
+    """Attach a LoRA PEFT adapter to *asr_model.thinker*.
+
+    Args:
+        asr_model: The base ASR model (has a ``.thinker`` attribute).
+        cfg: Training configuration providing LoRA hyperparameters.
+
+    Returns:
+        A metadata dict describing the adapter configuration.
+
+    Raises:
+        RuntimeError: If the ``peft`` package is not installed.
+        ValueError: If ``cfg.train_mode`` is not ``"lora_r16"``.
+    """
+    try:
+        from peft import LoraConfig, TaskType, get_peft_model
+    except Exception as e:
+        raise RuntimeError(
+            "PEFT mode requested but `peft` package is unavailable."
+        ) from e
+
+    if cfg.train_mode == "lora_r16":
+        rank = int(cfg.lora_rank)
+        alpha = int(cfg.lora_alpha)
+        target_modules = list(cfg.lora_target_modules)
+
+        print(
+            f"[lora] rank={rank} alpha={alpha} dropout={cfg.lora_dropout} "
+            f"target_modules={target_modules}"
+        )
+
+        if any("audio" in m for m in target_modules):
+            # User explicitly listed audio modules — respect that.
+            pass
+        else:
+            # Convert plain module names into a regex that excludes audio_tower.
+            escaped = [re.escape(m) for m in target_modules]
+            target_modules = r"^(?!.*audio_tower).*\b(" + "|".join(escaped) + r")$"
+            print(f"[lora] Using regex target_modules to exclude audio_tower: {target_modules}")
+
+        peft_cfg = LoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            r=rank,
+            lora_alpha=alpha,
+            lora_dropout=cfg.lora_dropout,
+            target_modules=target_modules,
+            bias="none",
+        )
+        asr_model.thinker = get_peft_model(asr_model.thinker, peft_cfg)
+        asr_model.thinker.print_trainable_parameters()
+        return {
+            "peft_mode": "lora_r16",
+            "rank": rank,
+            "alpha": alpha,
+            "dropout": cfg.lora_dropout,
+            "target_modules": target_modules,
+        }
+
+    raise ValueError(
+        f"attach_peft_adapter called with unsupported train_mode={cfg.train_mode!r}. "
+        "Only lora_r16 uses PEFT in this trainer."
+    )
+
+
+def save_peft_adapter_checkpoint(
+    model: nn.Module,
+    ckpt_dir: str,
+    metadata: Dict[str, Any],
+) -> None:
+    """Save a PEFT adapter checkpoint to *ckpt_dir*.
+
+    Args:
+        model: The ``LatentQwenASR`` wrapper (has ``.base_model.thinker``).
+        ckpt_dir: Directory path for the checkpoint.
+        metadata: Arbitrary metadata dict saved alongside the adapter.
+    """
+    os.makedirs(ckpt_dir, exist_ok=True)
+    model.base_model.thinker.save_pretrained(ckpt_dir, safe_serialization=False)
+    torch.save(metadata, os.path.join(ckpt_dir, "training_state.pth"))

pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "latentASR"
+version = "0.1.0"
+description = "Continuous latent test-time scaling for frozen Qwen3-ASR backbones."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [
+  { name = "LatentASR contributors" }
+]
+dependencies = [
+  "torch>=2.6",
+  "torchaudio>=2.6",
+  "transformers>=4.57",
+  "datasets>=3.6",
+  "huggingface-hub>=0.34",
+  "qwen-asr>=0.0.6",
+  "qwen-omni-utils>=0.0.8",
+  "jiwer>=4.0",
+  "peft>=0.18",
+  "numpy>=1.24",
+  "tqdm>=4.66"
+]
+
+[tool.setuptools]
+py-modules = [
+  "config",
+  "data",
+  "eval",
+  "losses",
+  "model",
+  "peft_utils",
+  "train",
+  "utils"
+]
+

requirements.txt

@@ -0,0 +1,12 @@
+torch>=2.6
+torchaudio>=2.6
+transformers>=4.57
+datasets>=3.6
+huggingface-hub>=0.34
+qwen-asr>=0.0.6
+qwen-omni-utils>=0.0.8
+jiwer>=4.0
+peft>=0.18
+numpy>=1.24
+tqdm>=4.66
+

results/paper500_ascend_20260518/ascend_clean.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "SpeechTest/ASCEND",
+  "dataset_name_input": "SpeechTest/ASCEND",
+  "split": "test",
+  "configs": [
+    "main"
+  ],
+  "streaming": false,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "main",
+      "samples_total": 1315,
+      "samples_used": 1315,
+      "text_column": "transcription",
+      "base_model_wer": 1.387989931679252,
+      "base_model_cer": 0.5780775716694773,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 1.29809421071557,
+      "latent_reasoning_cer": 0.4854733799084558,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.08989572096368215,
+      "latent_reasoning_vs_base_model_cer": 0.09260419176102147,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 1.387989931679252,
+    "base_model_weighted_cer": 0.5780775716694773,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 1.29809421071557,
+    "latent_reasoning_weighted_cer": 0.48547337990845574,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.08989572096368215,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.09260419176102153,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/fleurs_en_us_clean.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "google/fleurs",
+  "dataset_name_input": "google/fleurs",
+  "split": "test",
+  "configs": [
+    "en_us"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en_us",
+      "samples_total": 647,
+      "samples_used": 647,
+      "text_column": "transcription",
+      "base_model_wer": 0.04899930986887509,
+      "base_model_cer": 0.023260254681290355,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.048585231193926846,
+      "latent_reasoning_cer": 0.022687400794834767,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.0004140786749482414,
+      "latent_reasoning_vs_base_model_cer": 0.0005728538864555877,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.04899930986887509,
+    "base_model_weighted_cer": 0.023260254681290355,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.048585231193926846,
+    "latent_reasoning_weighted_cer": 0.022687400794834767,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.0004140786749482414,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0005728538864555877,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/fleurs_en_us_snr0db.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "google/fleurs",
+  "dataset_name_input": "google/fleurs",
+  "split": "test",
+  "configs": [
+    "en_us"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en_us",
+      "samples_total": 647,
+      "samples_used": 647,
+      "text_column": "transcription",
+      "base_model_wer": 0.2981366459627329,
+      "base_model_cer": 0.19216860999391341,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.2942028985507246,
+      "latent_reasoning_cer": 0.18863601102743732,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.003933747412008304,
+      "latent_reasoning_vs_base_model_cer": 0.0035325989664760915,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.2981366459627329,
+    "base_model_weighted_cer": 0.19216860999391341,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.2942028985507246,
+    "latent_reasoning_weighted_cer": 0.18863601102743732,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.003933747412008304,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0035325989664760915,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/minds14_en_us_clean.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "PolyAI/minds14",
+  "dataset_name_input": "PolyAI/minds14",
+  "split": "train",
+  "configs": [
+    "en-US"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en-US",
+      "samples_total": 563,
+      "samples_used": 563,
+      "text_column": "transcription",
+      "base_model_wer": 0.33701067615658364,
+      "base_model_cer": 0.2950933141919606,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.33677342823250295,
+      "latent_reasoning_cer": 0.29493949958982774,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.00023724792408069684,
+      "latent_reasoning_vs_base_model_cer": 0.00015381460213287346,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.33701067615658364,
+    "base_model_weighted_cer": 0.2950933141919606,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.33677342823250295,
+    "latent_reasoning_weighted_cer": 0.29493949958982774,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.00023724792408069684,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.00015381460213287346,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/minds14_en_us_snr0db.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "PolyAI/minds14",
+  "dataset_name_input": "PolyAI/minds14",
+  "split": "train",
+  "configs": [
+    "en-US"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en-US",
+      "samples_total": 563,
+      "samples_used": 563,
+      "text_column": "transcription",
+      "base_model_wer": 0.402491103202847,
+      "base_model_cer": 0.3330855209187859,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.4048635824436536,
+      "latent_reasoning_cer": 0.3333675143560295,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": -0.0023724792408066353,
+      "latent_reasoning_vs_base_model_cer": -0.0002819934372436106,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.402491103202847,
+    "base_model_weighted_cer": 0.3330855209187859,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.4048635824436536,
+    "latent_reasoning_weighted_cer": 0.3333675143560295,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": -0.0023724792408066353,
+    "latent_reasoning_vs_base_model_weighted_cer": -0.0002819934372436106,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/showcase_report.md

@@ -0,0 +1,33 @@
+# LR HuggingFace ASR Showcase Report
+
+- Generated UTC: 2026-05-18T20:13:39+00:00
+- Output directory: `/user_data/lr_whisper/eval_runs/paper500_english_clean_noise_20260518`
+- Delta WER is `base_model_wer - latent_reasoning_wer`; positive means LR is better.
+
+## Best LR Wins
+
+| Rank | Dataset | Configs | Condition | N | Base WER | LR WER | Delta WER | Relative | Delta CER | JSON |
+|---:|---|---|---|---:|---:|---:|---:|---:|---:|---|
+| 1 | google/fleurs | en_us | snr0db | 647 | 0.298137 | 0.294203 | 0.003934 | +1.32% | 0.003533 | `fleurs_en_us_snr0db.json` |
+| 2 | facebook/voxpopuli | en | snr0db | 1842 | 0.197111 | 0.195108 | 0.002003 | +1.02% | -0.000284 | `voxpopuli_en_snr0db.json` |
+| 3 | facebook/voxpopuli | en | clean | 1842 | 0.090375 | 0.089745 | 0.000630 | +0.70% | 0.000427 | `voxpopuli_en_clean.json` |
+| 4 | google/fleurs | en_us | clean | 647 | 0.048999 | 0.048585 | 0.000414 | +0.85% | 0.000573 | `fleurs_en_us_clean.json` |
+| 5 | PolyAI/minds14 | en-US | clean | 563 | 0.337011 | 0.336773 | 0.000237 | +0.07% | 0.000154 | `minds14_en_us_clean.json` |
+
+## All Cases
+
+| Dataset | Configs | Condition | N | Base WER | LR WER | Delta WER | Relative | Base CER | LR CER | Delta CER | JSON |
+|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---|
+| PolyAI/minds14 | en-US | clean | 563 | 0.337011 | 0.336773 | 0.000237 | +0.07% | 0.295093 | 0.294939 | 0.000154 | `minds14_en_us_clean.json` |
+| facebook/voxpopuli | en | clean | 1842 | 0.090375 | 0.089745 | 0.000630 | +0.70% | 0.059004 | 0.058576 | 0.000427 | `voxpopuli_en_clean.json` |
+| google/fleurs | en_us | clean | 647 | 0.048999 | 0.048585 | 0.000414 | +0.85% | 0.023260 | 0.022687 | 0.000573 | `fleurs_en_us_clean.json` |
+| PolyAI/minds14 | en-US | snr0db | 563 | 0.402491 | 0.404864 | -0.002372 | -0.59% | 0.333086 | 0.333368 | -0.000282 | `minds14_en_us_snr0db.json` |
+| facebook/voxpopuli | en | snr0db | 1842 | 0.197111 | 0.195108 | 0.002003 | +1.02% | 0.120512 | 0.120796 | -0.000284 | `voxpopuli_en_snr0db.json` |
+| google/fleurs | en_us | snr0db | 647 | 0.298137 | 0.294203 | 0.003934 | +1.32% | 0.192169 | 0.188636 | 0.003533 | `fleurs_en_us_snr0db.json` |
+
+## Regressions To Check
+
+| Dataset | Configs | Condition | N | Delta WER | Relative | JSON |
+|---|---|---|---:|---:|---:|---|
+| PolyAI/minds14 | en-US | snr0db | 563 | -0.002372 | -0.59% | `minds14_en_us_snr0db.json` |
+

results/paper500_english_clean_noise_20260518/voxpopuli_en_clean.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "facebook/voxpopuli",
+  "dataset_name_input": "facebook/voxpopuli",
+  "split": "test",
+  "configs": [
+    "en"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en",
+      "samples_total": 1842,
+      "samples_used": 1842,
+      "text_column": "normalized_text",
+      "base_model_wer": 0.09037513783558745,
+      "base_model_cer": 0.05900354572745667,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.08974503229290906,
+      "latent_reasoning_cer": 0.05857634964833996,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.0006301055426783941,
+      "latent_reasoning_vs_base_model_cer": 0.0004271960791167109,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.09037513783558745,
+    "base_model_weighted_cer": 0.05900354572745667,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.08974503229290906,
+    "latent_reasoning_weighted_cer": 0.05857634964833996,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.0006301055426783941,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0004271960791167109,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_english_clean_noise_20260518/voxpopuli_en_snr0db.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "facebook/voxpopuli",
+  "dataset_name_input": "facebook/voxpopuli",
+  "split": "test",
+  "configs": [
+    "en"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en",
+      "samples_total": 1842,
+      "samples_used": 1842,
+      "text_column": "normalized_text",
+      "base_model_wer": 0.19711051601143192,
+      "base_model_cer": 0.12051201391882498,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.19510768053648986,
+      "latent_reasoning_cer": 0.1207955167713297,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.0020028354749420663,
+      "latent_reasoning_vs_base_model_cer": -0.0002835028525047245,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.1971105160114319,
+    "base_model_weighted_cer": 0.12051201391882498,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.19510768053648986,
+    "latent_reasoning_weighted_cer": 0.1207955167713297,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.0020028354749420385,
+    "latent_reasoning_vs_base_model_weighted_cer": -0.0002835028525047245,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_main_eval_20260518/main_fleurs_en_us.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "google/fleurs",
+  "dataset_name_input": "google/fleurs",
+  "split": "test",
+  "configs": [
+    "en_us"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/baseline/baseline_best.pth",
+  "prompt_tuning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/prompt_tuning/prompt_tuning_best.pth",
+  "lora_r16_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/lora_r16/lora_r16_best",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en_us",
+      "samples_total": 647,
+      "samples_used": 647,
+      "text_column": "transcription",
+      "base_model_wer": 0.04899930986887509,
+      "base_model_cer": 0.023260254681290355,
+      "baseline_ft_wer": 0.05555555555555555,
+      "baseline_ft_cer": 0.024811733957107566,
+      "prompt_tuning_wer": 0.8480331262939959,
+      "prompt_tuning_cer": 0.8246828418326551,
+      "lora_r16_wer": 0.06466528640441684,
+      "lora_r16_cer": 0.02944230287262355,
+      "latent_reasoning_wer": 0.048585231193926846,
+      "latent_reasoning_cer": 0.022687400794834767,
+      "baseline_ft_vs_base_model_wer": -0.006556245686680465,
+      "baseline_ft_vs_base_model_cer": -0.0015514792758172108,
+      "prompt_tuning_vs_base_model_wer": -0.7990338164251207,
+      "prompt_tuning_vs_base_model_cer": -0.8014225871513647,
+      "lora_r16_vs_base_model_wer": -0.015665976535541748,
+      "lora_r16_vs_base_model_cer": -0.006182048191333195,
+      "latent_reasoning_vs_base_model_wer": 0.0004140786749482414,
+      "latent_reasoning_vs_base_model_cer": 0.0005728538864555877,
+      "latent_reasoning_vs_baseline_ft_wer": 0.006970324361628706,
+      "latent_reasoning_vs_baseline_ft_cer": 0.0021243331622727984,
+      "latent_reasoning_vs_prompt_tuning_wer": 0.799447895100069,
+      "latent_reasoning_vs_prompt_tuning_cer": 0.8019954410378203,
+      "latent_reasoning_vs_lora_r16_wer": 0.01608005521048999,
+      "latent_reasoning_vs_lora_r16_cer": 0.0067549020777887825
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.04899930986887509,
+    "base_model_weighted_cer": 0.023260254681290355,
+    "baseline_ft_weighted_wer": 0.05555555555555555,
+    "baseline_ft_weighted_cer": 0.02481173395710757,
+    "prompt_tuning_weighted_wer": 0.848033126293996,
+    "prompt_tuning_weighted_cer": 0.8246828418326551,
+    "lora_r16_weighted_wer": 0.06466528640441684,
+    "lora_r16_weighted_cer": 0.029442302872623553,
+    "latent_reasoning_weighted_wer": 0.048585231193926846,
+    "latent_reasoning_weighted_cer": 0.022687400794834767,
+    "baseline_ft_vs_base_model_weighted_wer": -0.006556245686680465,
+    "baseline_ft_vs_base_model_weighted_cer": -0.0015514792758172143,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.0004140786749482414,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0005728538864555877,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": 0.006970324361628706,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": 0.002124333162272802,
+    "prompt_tuning_vs_base_model_weighted_wer": -0.7990338164251208,
+    "prompt_tuning_vs_base_model_weighted_cer": -0.8014225871513647,
+    "lora_r16_vs_base_model_weighted_wer": -0.015665976535541748,
+    "lora_r16_vs_base_model_weighted_cer": -0.006182048191333198,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": 0.7994478951000691,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": 0.8019954410378203,
+    "latent_reasoning_vs_lora_r16_weighted_wer": 0.01608005521048999,
+    "latent_reasoning_vs_lora_r16_weighted_cer": 0.006754902077788786
+  }
+}

results/paper500_main_eval_20260518/main_voxpopuli_en.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "facebook/voxpopuli",
+  "dataset_name_input": "facebook/voxpopuli",
+  "split": "test",
+  "configs": [
+    "en"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/baseline/baseline_best.pth",
+  "prompt_tuning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/prompt_tuning/prompt_tuning_best.pth",
+  "lora_r16_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_main_baselines_20260518/checkpoints/lora_r16/lora_r16_best",
+  "latent_reasoning_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "/user_data/lr_whisper/eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en",
+      "samples_total": 1842,
+      "samples_used": 1842,
+      "text_column": "normalized_text",
+      "base_model_wer": 0.09037513783558745,
+      "base_model_cer": 0.05900354572745667,
+      "baseline_ft_wer": 0.09485338794248037,
+      "baseline_ft_cer": 0.061764785838838335,
+      "prompt_tuning_wer": 0.8850732497693363,
+      "prompt_tuning_cer": 0.8790103031927081,
+      "lora_r16_wer": 0.10212210545266331,
+      "lora_r16_cer": 0.06535711650413797,
+      "latent_reasoning_wer": 0.08974503229290906,
+      "latent_reasoning_cer": 0.05857634964833996,
+      "baseline_ft_vs_base_model_wer": -0.004478250106892914,
+      "baseline_ft_vs_base_model_cer": -0.002761240111381666,
+      "prompt_tuning_vs_base_model_wer": -0.7946981119337488,
+      "prompt_tuning_vs_base_model_cer": -0.8200067574652514,
+      "lora_r16_vs_base_model_wer": -0.01174696761707586,
+      "lora_r16_vs_base_model_cer": -0.006353570776681305,
+      "latent_reasoning_vs_base_model_wer": 0.0006301055426783941,
+      "latent_reasoning_vs_base_model_cer": 0.0004271960791167109,
+      "latent_reasoning_vs_baseline_ft_wer": 0.005108355649571308,
+      "latent_reasoning_vs_baseline_ft_cer": 0.003188436190498377,
+      "latent_reasoning_vs_prompt_tuning_wer": 0.7953282174764272,
+      "latent_reasoning_vs_prompt_tuning_cer": 0.8204339535443682,
+      "latent_reasoning_vs_lora_r16_wer": 0.012377073159754254,
+      "latent_reasoning_vs_lora_r16_cer": 0.006780766855798016
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.09037513783558745,
+    "base_model_weighted_cer": 0.05900354572745667,
+    "baseline_ft_weighted_wer": 0.09485338794248037,
+    "baseline_ft_weighted_cer": 0.061764785838838335,
+    "prompt_tuning_weighted_wer": 0.8850732497693363,
+    "prompt_tuning_weighted_cer": 0.8790103031927081,
+    "lora_r16_weighted_wer": 0.10212210545266331,
+    "lora_r16_weighted_cer": 0.06535711650413797,
+    "latent_reasoning_weighted_wer": 0.08974503229290906,
+    "latent_reasoning_weighted_cer": 0.05857634964833996,
+    "baseline_ft_vs_base_model_weighted_wer": -0.004478250106892914,
+    "baseline_ft_vs_base_model_weighted_cer": -0.002761240111381666,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.0006301055426783941,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0004271960791167109,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": 0.005108355649571308,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": 0.003188436190498377,
+    "prompt_tuning_vs_base_model_weighted_wer": -0.7946981119337488,
+    "prompt_tuning_vs_base_model_weighted_cer": -0.8200067574652514,
+    "lora_r16_vs_base_model_weighted_wer": -0.01174696761707586,
+    "lora_r16_vs_base_model_weighted_cer": -0.006353570776681305,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": 0.7953282174764272,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": 0.8204339535443682,
+    "latent_reasoning_vs_lora_r16_weighted_wer": 0.012377073159754254,
+    "latent_reasoning_vs_lora_r16_weighted_cer": 0.006780766855798016
+  }
+}

results/paper500_main_eval_20260518/paper500_complete_results.md

@@ -0,0 +1,176 @@
+# Paper 500-Activation Complete Results
+
+All results below use the 500-utterance activation setting unless explicitly stated otherwise. Metrics are shown in percent. Unless noted otherwise, `Delta` is `model - baseline`, so negative means an error reduction.
+
+Canonical paper choice: use `eval_runs/paper_tbd_retrain_20260518/checkpoints/activation_500/activation_500_epoch10.pth` for the main LatentASR result. This is the better of the two available 500-utterance/N=4/theta=0 runs by mean FLEURS/VoxPopuli WER delta, and it is the checkpoint represented by the 500 row in the activation-size sweep. The older `eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth` should be treated as an auxiliary ablation/diagnostic run unless its dependent tables are intentionally retained with that label.
+
+## Source Artifacts
+
+- Main baseline/adaptation JSONs: `eval_runs/paper500_main_eval_20260518/`
+- Canonical LatentASR JSONs: `eval_runs/paper_tbd_eval_20260518/activation_500_fleurs_theta_zero.json`, `eval_runs/paper_tbd_eval_20260518/activation_500_voxpopuli_theta_zero.json`
+- Retrained 500 checkpoints: `eval_runs/paper500_retrain_20260518/checkpoints/`
+- Main baseline checkpoints: `eval_runs/paper500_main_baselines_20260518/checkpoints/`
+- Threshold sweep: `eval_runs/paper500_threshold_20260518/threshold_sweep_report.md`
+- Component/N/p_neg ablations: `eval_runs/paper500_eval_20260518/paper_tbd_results.md`
+- Activation scaling 100-800: `eval_runs/paper_tbd_eval_20260518/activation_scaling_100_800_full_results.md`
+- Multilingual streaming: `eval_runs/paper500_multilingual_streaming_20260518/showcase_report.md`
+- English clean/noise suite: `eval_runs/paper500_english_clean_noise_20260518/showcase_report.md`
+- ASCEND: `eval_runs/paper500_ascend_20260518/ascend_clean.json`
+- Latency: `eval_runs/paper500_latency_20260518/latency.json`
+
+## Main Results
+
+Main baselines were retrained/evaluated with the 500-utterance activation setting. The canonical LatentASR row uses the best 500-utterance activation checkpoint from the activation-size sweep (`activation_500_epoch10.pth`). Full fine-tuning initially OOMed with micro-batch 16, so it was rerun with micro-batch 4 and gradient accumulation 4, preserving effective batch size 16.
+
+| Model | FLEURS WER | FLEURS CER | Rel. Delta WER | VoxPopuli WER | VoxPopuli CER | Rel. Delta WER |
+|---|---:|---:|---:|---:|---:|---:|
+| Baseline | 4.90 | 2.33 | -- | 9.04 | 5.90 | -- |
+| Full fine-tuning | 5.56 | 2.48 | +13.38 | 9.49 | 6.18 | +4.96 |
+| Prompt tuning | 84.80 | 82.47 | +1630.70 | 88.51 | 87.90 | +879.33 |
+| LoRA r16 | 6.47 | 2.94 | +31.97 | 10.21 | 6.54 | +13.00 |
+| LatentASR N=4, theta=0 | 4.78 | 2.24 | -2.54 | 8.99 | 5.87 | -0.47 |
+
+Prompt tuning collapses badly in the 500 setting on both FLEURS and VoxPopuli. This should be reported plainly if the table is used.
+
+## Activation Scaling 100-800
+
+The activation-scaling sweep was run at 100 to 800 utterances, every 100. The 500 point gives the best average absolute WER delta across FLEURS and VoxPopuli.
+
+| Activation size | FLEURS WER | FLEURS Delta pp | VoxPopuli WER | VoxPopuli Delta pp | Mean Delta pp |
+|---:|---:|---:|---:|---:|---:|
+| 100 | 4.87 | -0.03 | 8.95 | -0.08 | -0.055 |
+| 200 | 4.91 | +0.01 | 9.01 | -0.03 | -0.010 |
+| 300 | 4.90 | +0.00 | 9.01 | -0.03 | -0.015 |
+| 400 | 4.91 | +0.01 | 9.04 | -0.00 | +0.005 |
+| 500 | 4.78 | -0.12 | 8.99 | -0.04 | -0.084 |
+| 600 | 4.93 | +0.03 | 9.02 | -0.02 | +0.005 |
+| 700 | 4.82 | -0.08 | 9.04 | +0.00 | -0.040 |
+| 800 | 4.88 | -0.02 | 9.07 | +0.04 | +0.010 |
+
+## Threshold Sweep
+
+Converted from the sweep report to paper convention: Delta WER is `LatentASR - Baseline`, so negative is better.
+
+Important consistency note: the threshold sweep below was run with `paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth`, not the canonical `activation_500_epoch10.pth`. If the main paper uses the better canonical checkpoint, this section must either be rerun with `activation_500_epoch10.pth` or explicitly labeled as an auxiliary same-protocol diagnostic run.
+
+| Dataset | theta | Avg. steps | Skip | WER | Delta WER pp |
+|---|---:|---:|---:|---:|---:|
+| FLEURS | -2.0 | 4.00 | 0.0 | 4.84 | -0.062 |
+| FLEURS | -0.2 | 1.37 | 43.7 | 4.86 | -0.041 |
+| FLEURS | 0.0 | 1.24 | 47.0 | 4.86 | -0.041 |
+| FLEURS | +0.2 | 0.00 | 100.0 | 4.90 | +0.000 |
+| FLEURS | +0.5 | 0.00 | 100.0 | 4.90 | +0.000 |
+| VoxPopuli | -2.0 | 4.00 | 0.0 | 9.02 | -0.014 |
+| VoxPopuli | -0.2 | 0.84 | 54.9 | 8.97 | -0.070 |
+| VoxPopuli | 0.0 | 0.71 | 60.2 | 8.97 | -0.063 |
+| VoxPopuli | +0.2 | 0.00 | 100.0 | 9.04 | +0.000 |
+| VoxPopuli | +0.5 | 0.00 | 100.0 | 9.04 | +0.000 |
+
+In this 500 setting, full compute does not regress VoxPopuli; it is slightly positive. The older claim that no-halting increases VoxPopuli WER should be revised for the 500 paper version. Dynamic halting is still useful because it recovers most of the gain at much lower average steps.
+
+## Compute Allocation at theta=0
+
+The clean FLEURS/VoxPopuli theta=0 allocation for the canonical `activation_500_epoch10.pth` is available from the activation sweep: FLEURS average steps 1.20 with 47.0% skip; VoxPopuli average steps 0.70 with 63.0% skip. The table below additionally includes ASCEND from the older `n4_epoch10.pth` run and therefore should be rerun if strict checkpoint consistency is required.
+
+| Dataset | N=0 | N=1 | N=2 | N=3 | N=4 |
+|---|---:|---:|---:|---:|---:|
+| FLEURS clean | 47.0 | 23.2 | 7.0 | 4.6 | 18.2 |
+| VoxPopuli clean | 60.2 | 24.0 | 6.7 | 2.8 | 6.2 |
+| ASCEND clean | 22.3 | 30.3 | 8.2 | 5.1 | 34.1 |
+
+## Component Ablation
+
+FLEURS, theta=0. Baseline WER for this ablation run is 4.90.
+
+| Variant | WER | Delta WER pp |
+|---|---:|---:|
+| Full LatentASR N=4 | 4.86 | -0.04 |
+| Remove bounded delta | 51.75 | +46.85 |
+| Remove sigmoid gate | 7.89 | +2.99 |
+| Remove fixed-embedding anchor | 16.22 | +11.33 |
+
+This strongly supports keeping the stabilization-mechanism ablation in the paper.
+
+## Latent Budget N Sweep
+
+theta=0.
+
+| N | FLEURS WER | FLEURS Delta pp | VoxPopuli WER | VoxPopuli Delta pp |
+|---:|---:|---:|---:|---:|
+| 1 | 4.82 | -0.08 | 8.98 | -0.06 |
+| 2 | 4.89 | -0.01 | 9.03 | -0.00 |
+| 4 | 4.86 | -0.04 | 8.97 | -0.06 |
+| 8 | 4.90 | +0.00 | 9.03 | -0.00 |
+
+N=1 is surprisingly strong in this 500 run. N=4 remains a reasonable default because it ties/bests VoxPopuli and supports deeper reasoning on the subset that needs it, but the paper should not claim N=4 is strictly best on every dataset.
+
+## Forced-Negative Sampling
+
+FLEURS, theta=0 unless otherwise specified.
+
+| Setting | WER | Delta WER pp | Skip at theta=+0.2 | Skip range over sweep |
+|---|---:|---:|---:|---:|
+| p_neg=0.3 | 4.86 | -0.04 | 100.0 | [0, 100] |
+| p_neg=0.0 | 4.80 | -0.10 | 100.0 | [0, 100] |
+
+Important paper caveat: in the 500 run, removing forced-negative sampling does not collapse threshold reachability. The previous placeholder prose saying the saturated regime disappears is false for this setting and should be removed or rewritten. A safer statement is that forced-negative sampling changes value calibration/aggressiveness, while this 500 run does not show it is required for saturation.
+
+## Multilingual Streaming
+
+| Subset | #utts | Baseline WER | LatentASR WER | Delta WER pp | Rel. Delta WER | Baseline CER | LatentASR CER | Delta CER pp | Rel. Delta CER |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| Primary multilingual: FLEURS30 + MLS public7 | 36,982 | 24.982 | 24.941 | -0.041 | -0.163 | 9.428 | 9.411 | -0.017 | -0.178 |
+| FLEURS 30 overall | 23,049 | 32.649 | 32.573 | -0.076 | -0.232 | 12.810 | 12.764 | -0.046 | -0.358 |
+| FLEURS core12 | 8,876 | 31.708 | 31.627 | -0.081 | -0.255 | 12.649 | 12.564 | -0.085 | -0.671 |
+| FLEURS +8 | 5,597 | 17.479 | 17.447 | -0.032 | -0.185 | 6.922 | 6.904 | -0.018 | -0.256 |
+| FLEURS +10 | 8,576 | 43.523 | 43.424 | -0.099 | -0.227 | 16.819 | 16.796 | -0.024 | -0.142 |
+| MLS public7 overall | 13,933 | 12.299 | 12.316 | +0.018 | +0.143 | 3.834 | 3.865 | +0.031 | +0.815 |
+
+MLS public7 slightly regresses under 500. The broad multilingual aggregate remains positive because FLEURS 30 improves.
+
+### Character-Based FLEURS Languages
+
+| Language | #utts | Baseline CER | LatentASR CER | Rel. Delta CER |
+|---|---:|---:|---:|---:|
+| Mandarin (cmn_hans_cn) | 945 | 47.94 | 47.58 | -0.75 |
+| Cantonese (yue_hant_hk) | 819 | 49.20 | 48.80 | -0.82 |
+| Japanese (ja_jp) | 650 | 10.35 | 10.35 | +0.00 |
+| Thai (th_th) | 1,021 | 9.53 | 9.41 | -1.31 |
+
+## English Clean/Noise Suite and Robustness
+
+| Dataset | Condition | Metric | Baseline | LatentASR | Delta pp | Rel. Delta |
+|---|---|---|---:|---:|---:|---:|
+| FLEURS | clean | WER | 4.90 | 4.78 | -0.124 | -2.54 |
+| FLEURS | SNR=0 dB | WER | 29.81 | 29.42 | -0.393 | -1.32 |
+| MInDS-14 | clean | WER | 33.70 | 33.68 | -0.024 | -0.07 |
+| MInDS-14 | SNR=0 dB | WER | 40.25 | 40.49 | +0.237 | +0.59 |
+| VoxPopuli | clean | WER | 9.04 | 8.99 | -0.043 | -0.47 |
+| VoxPopuli | SNR=0 dB | WER | 19.71 | 19.51 | -0.200 | -1.02 |
+| ASCEND | clean/accented | CER | 57.81 | 48.55 | -9.26 | -16.02 |
+
+ASCEND remains the strongest robustness result. MInDS-14 SNR=0 regresses slightly and should not be summarized as uniformly robust across every noise condition.
+
+## Latency
+
+Measured on one NVIDIA RTX 5090, batch size 1, 100 utterances after 10 warmup utterances.
+
+| Setting | FLEURS ms/utt | FLEURS overhead | VoxPopuli ms/utt | VoxPopuli overhead |
+|---|---:|---:|---:|---:|
+| Baseline | 304.31 | -- | 297.95 | -- |
+| LatentASR theta=-2.0, full N=4 | 358.31 | +17.75 | 349.70 | +17.37 |
+| LatentASR theta=0.0, deployed | 341.69 | +12.28 | 329.37 | +10.54 |
+| LatentASR theta=+0.5, full skip | 321.52 | +5.66 | 314.36 | +5.51 |
+
+The full-skip wrapper still has a fixed overhead of about 5-6%, so the paper should not claim exact zero overhead in the skip case.
+
+## Paper Text Adjustments Required
+
+- Replace the old main table with the canonical `activation_500_epoch10.pth` main results above.
+- Rerun or relabel threshold, compute-allocation, multilingual, robustness, and per-sample analysis tables that currently cite `paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth`.
+- Replace the threshold discussion: with 500, full compute does not regress VoxPopuli; dynamic halting is a compute-efficiency mechanism that preserves gains rather than the only way to avoid VoxPopuli regression.
+- Replace the forced-negative ablation prose: p_neg=0.0 does not remove the saturated skip regime in the 500 run.
+- Keep the component ablation; it is strong and clean.
+- Mention prompt tuning collapse explicitly or consider moving prompt tuning to a failure-mode baseline if the huge WER hurts presentation.
+- For multilingual, say the primary aggregate and FLEURS 30 improve, while MLS public7 is near-neutral/slightly worse.
+- For robustness, say ASCEND and most zero-SNR English conditions improve, but MInDS-14 SNR=0 is a small regression.

results/paper500_more_testing_stress_20260525/ami_ihm_sdm_snr0_500.json

@@ -0,0 +1,106 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "edinburghcstr/ami",
+  "dataset_name_input": "edinburghcstr/ami",
+  "split": "test",
+  "configs": [
+    "ihm",
+    "sdm"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "ihm",
+      "samples_total": 500,
+      "samples_used": 498,
+      "text_column": "text",
+      "base_model_wer": 0.6516084873374401,
+      "base_model_cer": 0.5181941718254568,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.6379192334017796,
+      "latent_reasoning_cer": 0.5201570285369168,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.013689253935660561,
+      "latent_reasoning_vs_base_model_cer": -0.001962856711460015,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    },
+    {
+      "config": "sdm",
+      "samples_total": 500,
+      "samples_used": 498,
+      "text_column": "text",
+      "base_model_wer": 0.9040667361835245,
+      "base_model_cer": 0.7600583538083538,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.8724365658672228,
+      "latent_reasoning_cer": 0.738713144963145,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.031630170316301665,
+      "latent_reasoning_vs_base_model_cer": 0.021345208845208852,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.7778376117604824,
+    "base_model_weighted_cer": 0.6391262628169052,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.7551778996345011,
+    "latent_reasoning_weighted_cer": 0.6294350867500308,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.02265971212598128,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.009691176066874418,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/common_voice_en_snr0_500.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "SpeechTest/common_voice_16_0",
+  "dataset_name_input": "SpeechTest/common_voice_16_0",
+  "split": "test",
+  "configs": [
+    "en"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "en",
+      "samples_total": 500,
+      "samples_used": 500,
+      "text_column": "sentence",
+      "base_model_wer": 0.3161731207289294,
+      "base_model_cer": 0.21590186278964107,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.3193621867881549,
+      "latent_reasoning_cer": 0.21353930031803725,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": -0.0031890660592255315,
+      "latent_reasoning_vs_base_model_cer": 0.002362562471603824,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.3161731207289294,
+    "base_model_weighted_cer": 0.21590186278964107,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.3193621867881549,
+    "latent_reasoning_weighted_cer": 0.21353930031803725,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": -0.0031890660592255315,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.002362562471603824,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/extreme_asr_pony_500.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "SpeechTest/extreme_asr_pony",
+  "dataset_name_input": "SpeechTest/extreme_asr_pony",
+  "split": "train",
+  "configs": [
+    "default"
+  ],
+  "streaming": true,
+  "text_normalizer": "basic",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "default",
+      "samples_total": 500,
+      "samples_used": 499,
+      "text_column": "text",
+      "base_model_wer": 0.722823147647377,
+      "base_model_cer": 0.41449099372596643,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.6649540292049757,
+      "latent_reasoning_cer": 0.3808495806067148,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.05786911844240128,
+      "latent_reasoning_vs_base_model_cer": 0.03364141311925162,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.722823147647377,
+    "base_model_weighted_cer": 0.41449099372596643,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.6649540292049757,
+    "latent_reasoning_weighted_cer": 0.38084958060671475,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.05786911844240128,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.03364141311925167,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/gigaspeech_test_snr0_500.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "SpeechTest/gigaspeech",
+  "dataset_name_input": "SpeechTest/gigaspeech",
+  "split": "test",
+  "configs": [
+    "test"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "test",
+      "samples_total": 500,
+      "samples_used": 391,
+      "text_column": "text",
+      "base_model_wer": 0.2093853608773272,
+      "base_model_cer": 0.12873092389539675,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.20874776842642184,
+      "latent_reasoning_cer": 0.12885580837725105,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.000637592450905361,
+      "latent_reasoning_vs_base_model_cer": -0.00012488448185429823,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.2093853608773272,
+    "base_model_weighted_cer": 0.12873092389539675,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.20874776842642184,
+    "latent_reasoning_weighted_cer": 0.12885580837725105,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.000637592450905361,
+    "latent_reasoning_vs_base_model_weighted_cer": -0.00012488448185429823,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/librispeech_clean_other_snr0_500.json

@@ -0,0 +1,106 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "openslr/librispeech_asr",
+  "dataset_name_input": "openslr/librispeech_asr",
+  "split": "test",
+  "configs": [
+    "clean",
+    "other"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "clean",
+      "samples_total": 500,
+      "samples_used": 500,
+      "text_column": "text",
+      "base_model_wer": 0.10200129115558425,
+      "base_model_cer": 0.054846653234833224,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.10255464354883335,
+      "latent_reasoning_cer": 0.054777772037678016,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": -0.0005533523932491069,
+      "latent_reasoning_vs_base_model_cer": 6.888119715520863e-05,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    },
+    {
+      "config": "other",
+      "samples_total": 500,
+      "samples_used": 500,
+      "text_column": "text",
+      "base_model_wer": 0.26742456438589035,
+      "base_model_cer": 0.16974330287774256,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.26912452188695285,
+      "latent_reasoning_cer": 0.16781652060413949,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": -0.001699957501062499,
+      "latent_reasoning_vs_base_model_cer": 0.0019267822736030726,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.18471292777073728,
+    "base_model_weighted_cer": 0.11229497805628791,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.1858395827178931,
+    "latent_reasoning_weighted_cer": 0.11129714632090876,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": -0.0011266549471558307,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.000997831735379151,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/peoples_speech_test_snr0_500.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "SpeechTest/peoples_speech",
+  "dataset_name_input": "SpeechTest/peoples_speech",
+  "split": "test",
+  "configs": [
+    "test"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "test",
+      "samples_total": 500,
+      "samples_used": 500,
+      "text_column": "text",
+      "base_model_wer": 0.31687113348013,
+      "base_model_cer": 0.224544784759499,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.31770997168921045,
+      "latent_reasoning_cer": 0.22947058204399537,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": -0.0008388382090804281,
+      "latent_reasoning_vs_base_model_cer": -0.0049257972844963804,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.31687113348013,
+    "base_model_weighted_cer": 0.224544784759499,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.31770997168921045,
+    "latent_reasoning_weighted_cer": 0.22947058204399537,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": -0.0008388382090804281,
+    "latent_reasoning_vs_base_model_weighted_cer": -0.0049257972844963804,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}

results/paper500_more_testing_stress_20260525/showcase_report.md

@@ -0,0 +1,35 @@
+# LR HuggingFace ASR Showcase Report
+
+- Generated UTC: 2026-05-25T16:47:09+00:00
+- Output directory: `/user_data/lr_whisper/eval_runs/paper500_more_testing_stress_20260525`
+- Delta WER is `base_model_wer - latent_reasoning_wer`; positive means LR is better.
+
+## Best LR Wins
+
+| Rank | Dataset | Configs | Condition | N | Base WER | LR WER | Delta WER | Relative | Delta CER | JSON |
+|---:|---|---|---|---:|---:|---:|---:|---:|---:|---|
+| 1 | SpeechTest/extreme_asr_pony | default | unknown | 499 | 0.722823 | 0.664954 | 0.057869 | +8.01% | 0.033641 | `extreme_asr_pony_500.json` |
+| 2 | edinburghcstr/ami | ihm,sdm | unknown | 996 | 0.777838 | 0.755178 | 0.022660 | +2.91% | 0.009691 | `ami_ihm_sdm_snr0_500.json` |
+| 3 | TwinkStart/tedlium | release1 | unknown | 500 | 0.148490 | 0.142912 | 0.005578 | +3.76% | 0.001232 | `tedlium_release1_snr0_500.json` |
+| 4 | SpeechTest/gigaspeech | test | unknown | 391 | 0.209385 | 0.208748 | 0.000638 | +0.30% | -0.000125 | `gigaspeech_test_snr0_500.json` |
+
+## All Cases
+
+| Dataset | Configs | Condition | N | Base WER | LR WER | Delta WER | Relative | Base CER | LR CER | Delta CER | JSON |
+|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---|
+| SpeechTest/common_voice_16_0 | en | unknown | 500 | 0.316173 | 0.319362 | -0.003189 | -1.01% | 0.215902 | 0.213539 | 0.002363 | `common_voice_en_snr0_500.json` |
+| SpeechTest/extreme_asr_pony | default | unknown | 499 | 0.722823 | 0.664954 | 0.057869 | +8.01% | 0.414491 | 0.380850 | 0.033641 | `extreme_asr_pony_500.json` |
+| SpeechTest/gigaspeech | test | unknown | 391 | 0.209385 | 0.208748 | 0.000638 | +0.30% | 0.128731 | 0.128856 | -0.000125 | `gigaspeech_test_snr0_500.json` |
+| SpeechTest/peoples_speech | test | unknown | 500 | 0.316871 | 0.317710 | -0.000839 | -0.26% | 0.224545 | 0.229471 | -0.004926 | `peoples_speech_test_snr0_500.json` |
+| TwinkStart/tedlium | release1 | unknown | 500 | 0.148490 | 0.142912 | 0.005578 | +3.76% | 0.088532 | 0.087300 | 0.001232 | `tedlium_release1_snr0_500.json` |
+| edinburghcstr/ami | ihm,sdm | unknown | 996 | 0.777838 | 0.755178 | 0.022660 | +2.91% | 0.639126 | 0.629435 | 0.009691 | `ami_ihm_sdm_snr0_500.json` |
+| openslr/librispeech_asr | clean,other | unknown | 1000 | 0.184713 | 0.185840 | -0.001127 | -0.61% | 0.112295 | 0.111297 | 0.000998 | `librispeech_clean_other_snr0_500.json` |
+
+## Regressions To Check
+
+| Dataset | Configs | Condition | N | Delta WER | Relative | JSON |
+|---|---|---|---:|---:|---:|---|
+| SpeechTest/common_voice_16_0 | en | unknown | 500 | -0.003189 | -1.01% | `common_voice_en_snr0_500.json` |
+| openslr/librispeech_asr | clean,other | unknown | 1000 | -0.001127 | -0.61% | `librispeech_clean_other_snr0_500.json` |
+| SpeechTest/peoples_speech | test | unknown | 500 | -0.000839 | -0.26% | `peoples_speech_test_snr0_500.json` |
+

results/paper500_more_testing_stress_20260525/tedlium_release1_snr0_500.json

@@ -0,0 +1,75 @@
+{
+  "model_id": "Qwen/Qwen3-ASR-0.6B",
+  "dataset_name": "TwinkStart/tedlium",
+  "dataset_name_input": "TwinkStart/tedlium",
+  "split": "test",
+  "configs": [
+    "release1"
+  ],
+  "streaming": true,
+  "text_normalizer": "english",
+  "base_model_enabled": true,
+  "baseline_checkpoint": "",
+  "prompt_tuning_checkpoint": "",
+  "lora_r16_checkpoint": "",
+  "latent_reasoning_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "latent_checkpoint": "eval_runs/paper500_retrain_20260518/checkpoints/n4/n4_epoch10.pth",
+  "rows": [
+    {
+      "config": "release1",
+      "samples_total": 500,
+      "samples_used": 500,
+      "text_column": "text",
+      "base_model_wer": 0.148490094248894,
+      "base_model_cer": 0.08853179716516335,
+      "baseline_ft_wer": null,
+      "baseline_ft_cer": null,
+      "prompt_tuning_wer": null,
+      "prompt_tuning_cer": null,
+      "lora_r16_wer": null,
+      "lora_r16_cer": null,
+      "latent_reasoning_wer": 0.142912098480477,
+      "latent_reasoning_cer": 0.0873000833775487,
+      "baseline_ft_vs_base_model_wer": null,
+      "baseline_ft_vs_base_model_cer": null,
+      "prompt_tuning_vs_base_model_wer": null,
+      "prompt_tuning_vs_base_model_cer": null,
+      "lora_r16_vs_base_model_wer": null,
+      "lora_r16_vs_base_model_cer": null,
+      "latent_reasoning_vs_base_model_wer": 0.005577995768416999,
+      "latent_reasoning_vs_base_model_cer": 0.0012317137876146494,
+      "latent_reasoning_vs_baseline_ft_wer": null,
+      "latent_reasoning_vs_baseline_ft_cer": null,
+      "latent_reasoning_vs_prompt_tuning_wer": null,
+      "latent_reasoning_vs_prompt_tuning_cer": null,
+      "latent_reasoning_vs_lora_r16_wer": null,
+      "latent_reasoning_vs_lora_r16_cer": null
+    }
+  ],
+  "summary": {
+    "base_model_weighted_wer": 0.148490094248894,
+    "base_model_weighted_cer": 0.08853179716516335,
+    "baseline_ft_weighted_wer": null,
+    "baseline_ft_weighted_cer": null,
+    "prompt_tuning_weighted_wer": null,
+    "prompt_tuning_weighted_cer": null,
+    "lora_r16_weighted_wer": null,
+    "lora_r16_weighted_cer": null,
+    "latent_reasoning_weighted_wer": 0.142912098480477,
+    "latent_reasoning_weighted_cer": 0.0873000833775487,
+    "baseline_ft_vs_base_model_weighted_wer": null,
+    "baseline_ft_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_base_model_weighted_wer": 0.005577995768416999,
+    "latent_reasoning_vs_base_model_weighted_cer": 0.0012317137876146494,
+    "latent_reasoning_vs_baseline_ft_weighted_wer": null,
+    "latent_reasoning_vs_baseline_ft_weighted_cer": null,
+    "prompt_tuning_vs_base_model_weighted_wer": null,
+    "prompt_tuning_vs_base_model_weighted_cer": null,
+    "lora_r16_vs_base_model_weighted_wer": null,
+    "lora_r16_vs_base_model_weighted_cer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_wer": null,
+    "latent_reasoning_vs_prompt_tuning_weighted_cer": null,
+    "latent_reasoning_vs_lora_r16_weighted_wer": null,
+    "latent_reasoning_vs_lora_r16_weighted_cer": null
+  }
+}