Upload 9 files

README.md

@@ -0,0 +1,16 @@
+# Code and Artifacts
+
+This repository contains the code and supporting artifacts that accompany a paper
+currently under double-blind peer review.
+
+All documentation — the training and decoding recipe, dataset details, and reproduction steps — is provided in the supplementary material of the paper. 
+
+## Anonymity notice
+
+To preserve double-blind review, the paper title, author names, and affiliations are
+withheld, and identifying paths and identifiers have been removed. Please do not
+attempt to de-anonymize the authors.
+
+## License
+
+Released under the MIT License.

eval_model.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+eval_model.py
+
+Evaluate a .nemo ASR model on a manifest (batch + streaming WER).
+
+Usage:
+  python eval_model.py --model /path/to/best_model.nemo --manifest /path/to/test_manifest.json
+  python eval_model.py --model /path/to/best_model.nemo --manifest /path/to/test_manifest.json --gpu 0
+  python eval_model.py --model /path/to/best_model.nemo --manifest /path/to/test_manifest.json --no-streaming
+
+Manifest format (one JSON object per line):
+  {"audio_filepath": "/abs/path/utt.wav", "text": "reference transcript"}
+  Only `audio_filepath` and `text` are read; other keys (e.g. `duration`) are ignored.
+
+Note:
+    WER here uses Whisper's BasicMultilingualTextNormalizer from the
+    Open ASR Leaderboard repo, matching the paper pipeline.
+
+Requirements:
+  pip install nemo_toolkit[asr] soundfile numpy
+"""
+
+import argparse
+import json
+import os
+import sys
+
+import numpy as np
+import torch
+
+
+# Use Whisper's BasicMultilingualTextNormalizer for consistency with paper runs.
+try:
+    from normalizer import BasicMultilingualTextNormalizer
+    _ml_normalizer = BasicMultilingualTextNormalizer()
+except ImportError:
+    print(
+        "ERROR: could not import BasicMultilingualTextNormalizer. "
+        "This script requires Whisper's BasicMultilingualTextNormalizer, "
+        "shipped in the Open ASR Leaderboard repo. "
+        "Clone https://github.com/huggingface/open_asr_leaderboard and add it "
+        "to PYTHONPATH (or set OPEN_ASR_LB_ROOT).",
+        file=sys.stderr,
+    )
+    raise SystemExit(1)
+
+
+def normalize_text(text):
+    return _ml_normalizer(text)
+
+
+def simple_wer(ref_words, hyp_words):
+    n, m = len(ref_words), len(hyp_words)
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1): dp[i][0] = i
+    for j in range(m + 1): dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            dp[i][j] = dp[i-1][j-1] if ref_words[i-1] == hyp_words[j-1] \
+                else 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+    return dp[n][m]
+
+
+@torch.no_grad()
+def evaluate_batch(model, manifest_path, device):
+    import soundfile as sf
+    model.eval()
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+
+    total_edits, total_words = 0, 0
+    errors = 0
+    batch_size = 16
+    examples = []
+
+    for start in range(0, len(samples), batch_size):
+        batch_samples = samples[start:start + batch_size]
+        try:
+            audios = []
+            for s in batch_samples:
+                audio, sr = sf.read(s["audio_filepath"], dtype="float32")
+                if len(audio.shape) > 1:
+                    audio = audio.mean(axis=1)
+                audios.append(torch.FloatTensor(audio))
+
+            audio_lens = torch.LongTensor([len(a) for a in audios])
+            max_len = audio_lens.max().item()
+            padded = torch.zeros(len(audios), max_len)
+            for i, a in enumerate(audios):
+                padded[i, :len(a)] = a
+
+            padded = padded.to(device)
+            audio_lens = audio_lens.to(device)
+
+            mel, mel_len = model.preprocessor(input_signal=padded, length=audio_lens)
+            enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+
+            best_hyps = model.decoding.rnnt_decoder_predictions_tensor(enc, enc_len)
+            if isinstance(best_hyps, tuple):
+                best_hyps = best_hyps[0]
+
+            for s, hyp in zip(batch_samples, best_hyps):
+                if hasattr(hyp, 'text') and hyp.text:
+                    pred = hyp.text
+                elif hasattr(hyp, 'y_sequence'):
+                    tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                    pred = model.tokenizer.ids_to_text(tids) if tids else ""
+                else:
+                    pred = str(hyp)
+
+                ref_n = normalize_text(s["text"])
+                pred_n = normalize_text(pred)
+                ref_words = ref_n.split()
+                pred_words = pred_n.split()
+                if ref_words:
+                    total_edits += simple_wer(ref_words, pred_words)
+                    total_words += len(ref_words)
+
+                if len(examples) < 10:
+                    examples.append((s["text"][:60], pred[:60]))
+
+        except Exception as e:
+            errors += 1
+            if errors <= 3:
+                print(f"  [batch eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+
+    print(f"\n  {'Reference':<60} | {'Prediction':<60}")
+    print(f"  {'-'*60} | {'-'*60}")
+    for ref, pred in examples:
+        print(f"  {ref:<60} | {pred:<60}")
+    if errors:
+        print(f"  ({errors} batch eval errors)")
+
+    return wer_score, total_edits, total_words
+
+
+@torch.no_grad()
+def evaluate_streaming(model, manifest_path, device):
+    import soundfile as sf
+    from nemo.collections.asr.parts.utils.streaming_utils import CacheAwareStreamingAudioBuffer
+
+    model.eval()
+
+    right_context = 13
+    chunk_frames = 1 + right_context
+    model.encoder.setup_streaming_params(
+        chunk_size=chunk_frames,
+        shift_size=chunk_frames,
+        left_chunks=70 // max(chunk_frames, 1),
+    )
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+
+    total_edits, total_words = 0, 0
+    examples = []
+    errors = 0
+
+    for s in samples:
+        try:
+            audio, sr = sf.read(s["audio_filepath"], dtype="float32")
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            buffer = CacheAwareStreamingAudioBuffer(model=model)
+            buffer.append_audio(audio)
+
+            cache_last_channel, cache_last_time, cache_last_channel_len = \
+                model.encoder.get_initial_cache_state(batch_size=1, dtype=torch.float32, device=device)
+            previous_hypotheses = None
+            pred = ""
+
+            for chunk_audio, chunk_len in buffer:
+                if chunk_audio is None:
+                    break
+                result = model.conformer_stream_step(
+                    processed_signal=chunk_audio,
+                    processed_signal_length=chunk_len,
+                    cache_last_channel=cache_last_channel,
+                    cache_last_time=cache_last_time,
+                    cache_last_channel_len=cache_last_channel_len,
+                    previous_hypotheses=previous_hypotheses,
+                    return_transcription=True,
+                )
+                if isinstance(result, tuple) and len(result) >= 6:
+                    cache_last_channel = result[2]
+                    cache_last_time = result[3]
+                    cache_last_channel_len = result[4]
+                    previous_hypotheses = result[5]
+                    if result[5] and len(result[5]) > 0:
+                        hyp = result[5][0]
+                        new_text = ""
+                        if hasattr(hyp, 'text') and hyp.text:
+                            new_text = hyp.text
+                        elif hasattr(hyp, 'y_sequence'):
+                            tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                            if tids:
+                                new_text = model.tokenizer.ids_to_text(tids)
+                        if new_text and len(new_text) > len(pred):
+                            pred = new_text
+
+            ref_n = normalize_text(s["text"])
+            pred_n = normalize_text(pred)
+            ref_words = ref_n.split()
+            pred_words = pred_n.split()
+
+            if ref_words:
+                total_edits += simple_wer(ref_words, pred_words)
+                total_words += len(ref_words)
+
+            if len(examples) < 10:
+                examples.append((s["text"][:60], pred[:60]))
+
+        except Exception as e:
+            errors += 1
+            if errors <= 3:
+                print(f"  [streaming eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+
+    print(f"\n  {'Reference':<60} | {'Prediction':<60}")
+    print(f"  {'-'*60} | {'-'*60}")
+    for ref, pred in examples:
+        print(f"  {ref:<60} | {pred:<60}")
+    if errors:
+        print(f"  ({errors} samples failed)")
+
+    return wer_score, total_edits, total_words
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate NeMo ASR model")
+    parser.add_argument("--model", type=str, required=True, help="Path to .nemo model")
+    parser.add_argument("--manifest", type=str, required=True,
+                        help="Path to evaluation manifest (JSONL)")
+    parser.add_argument("--gpu", type=int, default=0, help="GPU index")
+    parser.add_argument("--no-streaming", action="store_true", help="Skip streaming eval")
+    args = parser.parse_args()
+
+    device = torch.device(f"cuda:{args.gpu}")
+    torch.cuda.set_device(args.gpu)
+
+    import nemo.collections.asr as nemo_asr
+    from nemo.core.classes.common import typecheck
+    typecheck.set_typecheck_enabled(False)
+
+    print(f"\n{'='*65}")
+    print(f"  Model:    {args.model}")
+    print(f"  Manifest: {args.manifest}")
+    print(f"  GPU:      {args.gpu}")
+    print(f"{'='*65}")
+
+    print(f"\n  Loading model...")
+    model = nemo_asr.models.ASRModel.restore_from(args.model, map_location=device)
+    model = model.to(device)
+    model.eval()
+
+    from omegaconf import open_dict
+    with open_dict(model.cfg):
+        model.cfg.decoding.greedy.use_cuda_graph_decoder = False
+    model.change_decoding_strategy(model.cfg.decoding)
+
+    print(f"  Vocab: {model.tokenizer.vocab_size} tokens")
+    print(f"  Params: {sum(p.numel() for p in model.parameters()) / 1e6:.1f}M")
+
+    # Count samples
+    with open(args.manifest) as f:
+        n_samples = sum(1 for _ in f)
+    print(f"  Samples: {n_samples}")
+
+    # Batch eval
+    print(f"\n{'='*65}")
+    print(f"  Batch Evaluation")
+    print(f"{'='*65}")
+    batch_wer, batch_edits, batch_words = evaluate_batch(model, args.manifest, device)
+    print(f"\n  Batch WER: {batch_wer:.2f}% ({batch_edits}/{batch_words})")
+
+    # Streaming eval
+    if not args.no_streaming:
+        print(f"\n{'='*65}")
+        print(f"  Streaming Evaluation")
+        print(f"{'='*65}")
+        stream_wer, stream_edits, stream_words = evaluate_streaming(model, args.manifest, device)
+        print(f"\n  Streaming WER: {stream_wer:.2f}% ({stream_edits}/{stream_words})")
+
+    # Summary
+    print(f"\n{'='*65}")
+    print(f"  Summary")
+    print(f"{'='*65}")
+    print(f"  Model:          {os.path.basename(args.model)}")
+    print(f"  Manifest:       {os.path.basename(args.manifest)}")
+    print(f"  Batch WER:      {batch_wer:.2f}%")
+    if not args.no_streaming:
+        print(f"  Streaming WER:  {stream_wer:.2f}%")
+    print(f"{'='*65}")
+
+
+if __name__ == "__main__":
+    main()

onnx_eval/eval_fleurs_onnx.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""FLEURS WER eval for a Nemotron ONNX (onnxruntime-genai) model.
+
+Streaming inference, per-utterance TSV + JSON summary, BasicMultilingualText
+normalization (same normalizer as the NeMo streaming eval).
+
+This is the per-language (monolingual) evaluator used for the INT4
+weight-only quantization study: each ONNX export already targets a single
+language and a single streaming-latency tier (the chunk size is baked into
+``genai_config.json``), so no language-id / prompt override is applied.
+
+Usage:
+    python eval_fleurs_onnx.py \
+        --onnx_model <ONNX_ROOT>/es_500h_new_ml_1e4_int4 \
+        --lang es_419 \
+        --name es_500h_new_ml_1e4_int4 \
+        --output_dir ./results
+
+Requires onnxruntime-genai and a model dir containing genai_config.json
+(plus encoder.onnx / decoder.onnx / joint.onnx / tokenizer.* / etc.).
+"""
+import argparse
+import json
+import os
+import re
+import sys
+import time
+
+import numpy as np
+import onnxruntime_genai as og
+
+
+# Multilingual exports may emit "<es-ES>" / "<de-DE>" tokens; strip from text.
+# (Harmless no-op for the monolingual exports evaluated here.)
+_LANG_TAG_RE = re.compile(r"\s*<[a-z]{2,3}(?:-[A-Za-z]{2,4})?>\s*")
+
+# WER normalization uses the Whisper BasicMultilingualTextNormalizer
+# packaged in the Open ASR Leaderboard repo, used unchanged:
+#   https://github.com/huggingface/open_asr_leaderboard
+# Clone it and add the repo root to PYTHONPATH (or set OPEN_ASR_LB_ROOT).
+_oalb = os.environ.get("OPEN_ASR_LB_ROOT")
+if _oalb:
+    sys.path.insert(0, _oalb)
+try:
+    from normalizer import BasicMultilingualTextNormalizer  # noqa: E402
+except ImportError as e:
+    raise RuntimeError(
+        "Could not import normalizer.BasicMultilingualTextNormalizer. "
+        "Clone https://github.com/huggingface/open_asr_leaderboard and set "
+        "OPEN_ASR_LB_ROOT=/path/to/open_asr_leaderboard."
+    ) from e
+
+_norm = BasicMultilingualTextNormalizer()
+
+
+def normalize_text(t: str) -> str:
+    return _norm(t)
+
+
+def compute_wer_ids(ref, hyp):
+    n, m = len(ref), len(hyp)
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = i
+    for j in range(m + 1):
+        dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            if ref[i - 1] == hyp[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1]
+            else:
+                dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+    subs = dels = ins = 0
+    i, j = n, m
+    while i > 0 or j > 0:
+        if i > 0 and j > 0 and ref[i - 1] == hyp[j - 1]:
+            i -= 1; j -= 1
+        elif i > 0 and j > 0 and dp[i][j] == dp[i - 1][j - 1] + 1:
+            subs += 1; i -= 1; j -= 1
+        elif i > 0 and dp[i][j] == dp[i - 1][j] + 1:
+            dels += 1; i -= 1
+        else:
+            ins += 1; j -= 1
+    return subs, dels, ins
+
+
+def load_fleurs(lang: str):
+    from datasets import load_dataset, Audio
+    cache = (os.environ.get("HF_DATASETS_CACHE")
+             or os.environ.get("HF_HOME"))
+    print(f"  Loading FLEURS {lang} test (cache_dir={cache})")
+    ds = load_dataset("google/fleurs", lang, split="test",
+                      trust_remote_code=True, cache_dir=cache)
+    ds = ds.cast_column("audio", Audio(sampling_rate=16000))
+    return ds
+
+
+def transcribe(model, params, tokenizer, sample_rate, chunk_samples, audio):
+    processor = og.StreamingProcessor(model)
+    processor.set_option("use_vad", "false")
+    gen = og.Generator(model, params)
+    tok_stream = tokenizer.create_stream()
+
+    text = ""
+
+    def _drain():
+        nonlocal text
+        while not gen.is_done():
+            gen.generate_next_token()
+            toks = gen.get_next_tokens()
+            if len(toks) > 0:
+                t = tok_stream.decode(toks[0])
+                if t:
+                    t = _LANG_TAG_RE.sub("", t)
+                    if t:
+                        text += t
+
+    for start in range(0, len(audio), chunk_samples):
+        chunk = audio[start:start + chunk_samples].astype(np.float32)
+        inp = processor.process(chunk)
+        if inp is not None:
+            gen.set_inputs(inp)
+            _drain()
+
+    inp = processor.flush()
+    if inp is not None:
+        gen.set_inputs(inp)
+        _drain()
+
+    del gen, processor
+    return text
+
+
+def evaluate(onnx_dir: str, dataset, name: str, lang: str, max_samples=None):
+    with open(os.path.join(onnx_dir, "genai_config.json")) as f:
+        cfg = json.load(f)
+    sample_rate = cfg["model"]["sample_rate"]
+    chunk_samples = cfg["model"]["chunk_samples"]
+
+    print(f"  Model: {onnx_dir}")
+    print(f"  chunk_samples: {chunk_samples}")
+    model = og.Model(og.Config(onnx_dir))
+    tokenizer = og.Tokenizer(model)
+    params = og.GeneratorParams(model)
+
+    total_subs = total_dels = total_ins = total_words = 0
+    total_audio_sec = total_proc_sec = 0.0
+    errors = 0
+    utts = []
+
+    n_total = len(dataset)
+    if max_samples:
+        n_total = min(n_total, max_samples)
+        dataset = dataset.select(range(n_total))
+    print(f"  Samples: {n_total}")
+
+    for i, sample in enumerate(dataset):
+        try:
+            audio = np.asarray(sample["audio"]["array"], dtype=np.float32)
+            sr = sample["audio"]["sampling_rate"]
+            if sr != sample_rate:
+                new_len = int(len(audio) * sample_rate / sr)
+                audio = np.interp(np.linspace(0, len(audio) - 1, new_len),
+                                  np.arange(len(audio)), audio).astype(np.float32)
+
+            t0 = time.perf_counter()
+            hyp = transcribe(model, params, tokenizer, sample_rate, chunk_samples, audio)
+            proc = time.perf_counter() - t0
+            dur = len(audio) / sample_rate
+            total_audio_sec += dur
+            total_proc_sec += proc
+
+            ref_n = normalize_text(sample["transcription"])
+            pred_n = normalize_text(_LANG_TAG_RE.sub(" ", hyp).strip())
+            ref_w = ref_n.split()
+            pred_w = pred_n.split()
+
+            sid = sample.get("id", str(i))
+            utts.append({"idx": i, "sample_id": str(sid),
+                         "duration": f"{dur:.2f}", "ref": ref_n, "hyp": pred_n})
+
+            if ref_w:
+                s, d, ins_ = compute_wer_ids(ref_w, pred_w)
+                total_subs += s; total_dels += d; total_ins += ins_
+                total_words += len(ref_w)
+
+            if (i + 1) % 25 == 0:
+                running = (total_subs + total_dels + total_ins) / max(total_words, 1) * 100
+                rtf = total_audio_sec / max(total_proc_sec, 1e-9)
+                print(f"    [{i+1}/{n_total}] WER: {running:.2f}%  RTF: {rtf:.2f}x",
+                      flush=True)
+        except Exception as e:
+            errors += 1
+            if errors <= 3:
+                print(f"    [error] {type(e).__name__}: {e}")
+
+    del model
+    total_edits = total_subs + total_dels + total_ins
+    wer = total_edits / max(total_words, 1) * 100
+    return {
+        "name": name, "dataset": "fleurs", "lang": lang,
+        "wer": wer,
+        "subs": total_subs, "dels": total_dels, "ins": total_ins,
+        "sub_rate": total_subs / max(total_words, 1) * 100,
+        "del_rate": total_dels / max(total_words, 1) * 100,
+        "ins_rate": total_ins / max(total_words, 1) * 100,
+        "total_edits": total_edits, "total_words": total_words,
+        "errors": errors,
+        "audio_sec": total_audio_sec, "proc_sec": total_proc_sec,
+        "rtf": total_audio_sec / max(total_proc_sec, 1e-9),
+        "utterances": utts,
+    }
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--onnx_model", required=True,
+                   help="Path to ONNX model dir (must contain genai_config.json).")
+    p.add_argument("--lang", required=True,
+                   help="FLEURS lang code, e.g. es_419, de_de, fr_fr.")
+    p.add_argument("--name", default="onnx_model",
+                   help="Display/file name for outputs.")
+    p.add_argument("--output_dir", default=None,
+                   help="Write per-utterance TSV + JSON summary here.")
+    p.add_argument("--max_samples", type=int, default=None)
+    args = p.parse_args()
+
+    print(f"\n  === {args.name} (FLEURS {args.lang}) — ONNX streaming ===")
+    ds = load_fleurs(args.lang)
+    r = evaluate(args.onnx_model, ds, name=args.name, lang=args.lang,
+                 max_samples=args.max_samples)
+
+    print(f"\n  WER: {r['wer']:.2f}%  "
+          f"(S={r['sub_rate']:.2f}% D={r['del_rate']:.2f}% I={r['ins_rate']:.2f}%)")
+    print(f"  Words: {r['total_words']}  Errors: {r['errors']}  "
+          f"Audio: {r['audio_sec']:.1f}s  Proc: {r['proc_sec']:.1f}s  "
+          f"RTF: {r['rtf']:.2f}x")
+
+    if args.output_dir and r["utterances"]:
+        os.makedirs(args.output_dir, exist_ok=True)
+        tsv = os.path.join(args.output_dir, f"{args.name}_fleurs_streaming.tsv")
+        with open(tsv, "w") as f:
+            f.write("idx\tsample_id\tduration_sec\tref\thyp\n")
+            for u in r["utterances"]:
+                f.write(f"{u['idx']}\t{u['sample_id']}\t{u['duration']}\t"
+                        f"{u['ref']}\t{u['hyp']}\n")
+        print(f"  Saved {len(r['utterances'])} utterances -> {tsv}")
+        summary = {k: v for k, v in r.items() if k != "utterances"}
+        with open(os.path.join(args.output_dir,
+                               f"{args.name}_fleurs_streaming.json"), "w") as f:
+            json.dump(summary, f, indent=2)
+
+
+if __name__ == "__main__":
+    main()

onnx_eval/run_fleurs_eval.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# FLEURS streaming WER eval for Nemotron ONNX (onnxruntime-genai) models.
+#
+# Mirrors the NeMo streaming-eval drivers, but runs the ONNX exports used for
+# the INT4 weight-only encoder-quantization study. The streaming-latency tier
+# is baked into each ONNX export (chunk_samples in genai_config.json), so there
+# is no --chunk_latency flag here: point ONNX_ROOT at the 160/560/1120 ms export
+# set you want to score.
+#
+# Usage:
+#   ONNX_ROOT=/path/to/onnx_models bash run_fleurs_eval.sh [GPU] [FLEURS_LANG]
+#   ONNX_ROOT=/path/to/onnx_models bash run_fleurs_eval.sh 0 de_de
+#
+# Required env:
+#   ONNX_ROOT          dir with one subdir per ONNX model (each has genai_config.json).
+# Optional env:
+#   OUTPUT_ROOT        where to write per-model TSV+JSON (default: <script_dir>/results).
+#   OPEN_ASR_LB_ROOT   clone of huggingface/open_asr_leaderboard (WER normalizer).
+#   HF_DATASETS_CACHE  HuggingFace datasets cache for the FLEURS download.
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PY="$SCRIPT_DIR/eval_fleurs_onnx.py"
+
+GPU=${1:-0}
+LANG_CODE=${2:-es_419}
+: "${ONNX_ROOT:?set ONNX_ROOT to a directory of ONNX model subdirs}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-$SCRIPT_DIR/results}"
+mkdir -p "$OUTPUT_ROOT"
+
+# WER normalizer (Whisper BasicMultilingualTextNormalizer) from the Open ASR
+# Leaderboard repo; export OPEN_ASR_LB_ROOT or pre-set PYTHONPATH.
+[[ -n "${OPEN_ASR_LB_ROOT:-}" ]] && export PYTHONPATH="$OPEN_ASR_LB_ROOT:${PYTHONPATH:-}"
+
+# Model subdirectories under $ONNX_ROOT to evaluate (also used as display names).
+# Edit this list to match your exported models (INT4 / FP32 / per-tier).
+MODELS=(
+    es_500h_new_ml_1e4_int4
+    es_500h_new_ml_1e4_fp32
+)
+
+for name in "${MODELS[@]}"; do
+    ONNX_DIR="$ONNX_ROOT/$name"
+    OUT="$OUTPUT_ROOT/$name"
+    SUMMARY="$OUT/${name}_fleurs_streaming.json"
+
+    echo ""
+    echo "================================================================="
+    echo "  Evaluating: $name  (FLEURS $LANG_CODE)"
+    echo "================================================================="
+    if [[ ! -f "$ONNX_DIR/genai_config.json" ]]; then
+        echo "  SKIP — no genai_config.json at $ONNX_DIR" >&2
+        continue
+    fi
+    if [[ -f "$SUMMARY" ]]; then
+        echo "  SKIP — result already exists at $SUMMARY"
+        continue
+    fi
+    CUDA_VISIBLE_DEVICES=$GPU python3 "$PY" \
+        --onnx_model "$ONNX_DIR" \
+        --lang "$LANG_CODE" \
+        --name "$name" \
+        --output_dir "$OUT"
+done
+
+echo ""
+echo "=== SUMMARY ==="
+for name in "${MODELS[@]}"; do
+    SUM="$OUTPUT_ROOT/$name/${name}_fleurs_streaming.json"
+    if [[ -f "$SUM" ]]; then
+        WER=$(grep -oE '"wer":[[:space:]]*[0-9.]+' "$SUM" | head -1 | awk '{print $2}')
+        printf "  %-40s WER = %s%%\n" "$name" "$WER"
+    fi
+done
+echo "ONNX FLEURS streaming eval done!"

paper/aggregate.py

@@ -0,0 +1,687 @@
+#!/usr/bin/env python3
+"""Recompute every WER aggregate reported in the paper from a single
+JSON file of per-cell WERs (``wer_results.json``, shipped alongside
+this script).
+
+This script is self-contained: it reads only the per-cell WER values
+from the JSON and re-derives every table and figure number in the
+paper that depends on those WERs alone.  Quantities that need inputs
+beyond the per-cell WER table -- the per-utterance paired-bootstrap
+significance markers in Table~\\ref{tab:main160}, or convergence-epoch
+counts taken from the training logs -- are out of scope here and are
+not recomputed.
+
+Each check below is keyed to a stable LaTeX ``\\label`` (its ``\\ref``
+target), which does not change if the paper is reordered; the ``[N]``
+markers are just this script's own output tags, not paper section
+numbers:
+
+  [1]  tab:main160         FLEURS WER (%) @ 160 ms, per-(lang, hours).
+  [2]  sec:hours intro     seen / unseen group mean Δ trajectory.
+  [3]  tab:latency_effect  mean EN-ML gap per (tier, hours), FLEURS.
+  [4]  tab:abs_wer         mean ML-init absolute WER per (tier, hours).
+  [5]  tab:lst             per-lang  Δ  + LST  per hours; macro mean.
+  [6]  sec:from_pl         HR-from-PL pivot vs direct ML, 160 ms.
+  [7]  sec:reinitjoint     joiner-reinit Δ, 560 ms FLEURS/VP.
+  [8]  tab:quant           INT4 vs FP32 @ 560 ms FLEURS, paired stats.
+  [9]  tab:5000h_es        ES 5000h vs 2500h ML deltas, and ES 5000h
+                           vs Nemotron-3.5 ML (tab:supp:es5000h).
+  [10] fig:gap_powerlaw    fit  Δ(h) = a·h^(-β) at 160 ms;
+                           language-bootstrap 95% CI on β; R².
+  [11] tab:hybrid          hybrid-encoder 100h/560ms FLEURS table.
+  [12] tab:seed + sec:seed HR/PT main-grid seed deltas + 16-cell 100h
+                           re-run @ 560 ms (FLEURS + VP); IS-EN excursion.
+  [13] streaming penalty   per (tier, hours, init), FLEURS.
+  [14] tab:per_dataset     per-dataset 160 ms WER appendix.
+
+Usage:
+    # with wer_results.json sitting next to this script:
+    python3 aggregate.py
+    # or pass an explicit path to a results JSON:
+    python3 aggregate.py /path/to/wer_results.json
+"""
+from __future__ import annotations
+
+import json
+import statistics
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+# Default to wer_results.json sitting next to this script; fall back to
+# the in-repository ``paper/`` layout when run from a full checkout.
+DEFAULT_JSON = next(
+    (p for p in (HERE / "wer_results.json",
+                 HERE.parent / "paper" / "wer_results.json")
+     if p.is_file()),
+    HERE / "wer_results.json",
+)
+
+LANGS = ["de", "es", "fr", "hr", "is", "nl", "pl", "pt"]
+SEEN = ["de", "es", "fr", "nl"]
+UNSEEN = ["pt", "hr", "is", "pl"]
+HOURS = ["100h", "250h", "500h", "1000h", "2500h"]
+TIERS = ["160ms", "560ms", "1120ms", "offline"]
+
+
+# ---------------------------------------------------------------------------
+# JSON helpers
+# ---------------------------------------------------------------------------
+def wer(d, lang, hours, init, tier, dataset):
+    """Return the WER (float) at d[lang][hours][init][tier][dataset], or None."""
+    try:
+        cell = d[lang][hours][init][tier][dataset]
+        if isinstance(cell, dict):
+            v = cell.get("wer")
+            return float(v) if v is not None else None
+    except (KeyError, TypeError):
+        pass
+    return None
+
+
+def delta(d, lang, hours, tier, dataset):
+    """EN - ML WER gap; None if either side missing."""
+    ml = wer(d, lang, hours, "ml", tier, dataset)
+    en = wer(d, lang, hours, "enc", tier, dataset)
+    if ml is None or en is None:
+        return None
+    return en - ml
+
+
+def fmt(x, signed=False, w=7):
+    if x is None:
+        return f"{'--':>{w}s}"
+    return f"{x:+{w}.2f}" if signed else f"{x:{w}.2f}"
+
+
+def mean(xs):
+    xs = [x for x in xs if x is not None]
+    return statistics.fmean(xs) if xs else None
+
+
+def hr(title):
+    print()
+    print("=" * 78)
+    print(title)
+    print("=" * 78)
+
+
+# ---------------------------------------------------------------------------
+# [1] Table :main160 — FLEURS WER (%) at 160 ms streaming, per-(lang, hours)
+# ---------------------------------------------------------------------------
+def t_main160(d):
+    hr("[1] Table tab:main160 — FLEURS WER (%) @ 160 ms")
+    head = "lang  " + "".join(f"{h:>27s}" for h in HOURS)
+    print(head)
+    sub = "      " + "".join(f"{'ml':>9s}{'enc':>9s}{'Δ':>9s}" for _ in HOURS)
+    print(sub)
+    for lang in LANGS:
+        row = f"{lang.upper():<6s}"
+        for h in HOURS:
+            ml = wer(d, lang, h, "ml", "160ms", "fleurs")
+            en = wer(d, lang, h, "enc", "160ms", "fleurs")
+            dl = (en - ml) if (ml is not None and en is not None) else None
+            row += fmt(ml, w=9) + fmt(en, w=9) + fmt(dl, signed=True, w=9)
+        print(row)
+    print("-" * len(head))
+    # macro means
+    row = f"{'mean':<6s}"
+    for h in HOURS:
+        mls = [wer(d, l, h, "ml",  "160ms", "fleurs") for l in LANGS]
+        ens = [wer(d, l, h, "enc", "160ms", "fleurs") for l in LANGS]
+        dls = [(e - m) for m, e in zip(mls, ens) if m is not None and e is not None]
+        row += fmt(mean(mls), w=9) + fmt(mean(ens), w=9) \
+             + fmt(mean(dls) if dls else None, signed=True, w=9)
+    print(row)
+    n_per_h = {h: sum(1 for l in LANGS
+                       if wer(d, l, h, "ml", "160ms", "fleurs") is not None
+                       and wer(d, l, h, "enc", "160ms", "fleurs") is not None)
+               for h in HOURS}
+    print("  K per hours: " + ", ".join(f"{h}={n_per_h[h]}" for h in HOURS))
+
+
+# ---------------------------------------------------------------------------
+# [2] sec:hours — seen / unseen group mean Δ trajectory, FLEURS @ 160 ms
+# ---------------------------------------------------------------------------
+def t_seen_unseen(d):
+    hr("[2] sec:hours — seen vs unseen group mean Δ, FLEURS @ 160 ms")
+    print(f"  {'group':<10s}" + "".join(f"{h:>10s}" for h in HOURS))
+    for label, group in (("seen", SEEN), ("unseen", UNSEEN), ("all", LANGS)):
+        row = f"  {label:<10s}"
+        for h in HOURS:
+            dls = [delta(d, l, h, "160ms", "fleurs") for l in group]
+            row += fmt(mean(dls), signed=True, w=10)
+        print(row)
+
+
+# ---------------------------------------------------------------------------
+# [3] Table :latency_effect — mean EN-ML gap per (tier, hours), FLEURS
+# ---------------------------------------------------------------------------
+def t_latency_effect(d):
+    hr("[3] Table tab:latency_effect — mean Δ (EN-ML) per (tier, hours), FLEURS")
+    print(f"  {'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS)
+          + f"{'range':>10s}")
+    per_h = {h: [] for h in HOURS}
+    for tier in TIERS:
+        row = f"  {tier:<10s}"
+        for h in HOURS:
+            dls = [delta(d, l, h, tier, "fleurs") for l in LANGS]
+            m = mean(dls)
+            per_h[h].append(m)
+            row += fmt(m, signed=True, w=10)
+        print(row)
+    # cross-tier range of mean Δ at each hours (paper sentence)
+    print(f"  {'tier-range':<10s}", end="")
+    for h in HOURS:
+        vs = [v for v in per_h[h] if v is not None]
+        rng = max(vs) - min(vs) if vs else None
+        print(fmt(rng, w=10), end="")
+    print()
+
+
+# ---------------------------------------------------------------------------
+# [4] Table :abs_wer — mean ML-init absolute FLEURS WER per (tier, hours)
+# ---------------------------------------------------------------------------
+def t_abs_wer(d):
+    hr("[4] Table tab:abs_wer — mean ML-init FLEURS WER (%) per (tier, hours)")
+    print(f"  {'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS))
+    for tier in TIERS:
+        row = f"  {tier:<10s}"
+        for h in HOURS:
+            mls = [wer(d, l, h, "ml", tier, "fleurs") for l in LANGS]
+            row += fmt(mean(mls), w=10)
+        print(row)
+
+
+# ---------------------------------------------------------------------------
+# [5] Table :lst — per-lang  Δ  + LST  per hours; macro mean
+#     LST(lang, h) = max_tier Δ_tier(lang, h) - min_tier Δ_tier(lang, h)
+#      Δ(lang, h) = mean_tier Δ_tier(lang, h)
+#     Both are taken over the THREE streaming tiers only (160/560/1120 ms);
+#     offline is excluded by definition (eq. lst / Table tab:lst caption).
+# ---------------------------------------------------------------------------
+def t_lst(d):
+    hr("[5] Table tab:lst — per-lang  Δ , LST on FLEURS  (per hours)")
+    stream_tiers = ["160ms", "560ms", "1120ms"]     # LST excludes offline
+    h_show = ["100h", "250h", "500h", "1000h"]      # paper omits 2500h here
+    head = f"  {'lang':<6s}" + "".join(f"{h:>20s}" for h in h_show)
+    print(head)
+    print(f"  {'':<6s}" + "".join(f"{'Δ':>10s}{'LST':>10s}" for _ in h_show))
+    barD = {h: [] for h in h_show}
+    lst = {h: [] for h in h_show}
+    for lang in LANGS:
+        row = f"  {lang.upper():<6s}"
+        for h in h_show:
+            ds = [delta(d, lang, h, t, "fleurs") for t in stream_tiers]
+            ds = [x for x in ds if x is not None]
+            if not ds:
+                row += fmt(None, w=10) + fmt(None, w=10); continue
+            bd = sum(ds) / len(ds)
+            ls = max(ds) - min(ds)
+            barD[h].append(bd); lst[h].append(ls)
+            row += fmt(bd, signed=True, w=10) + fmt(ls, w=10)
+        print(row)
+    print("  " + "-" * 76)
+    row = f"  {'mean':<6s}"
+    for h in h_show:
+        row += fmt(mean(barD[h]), signed=True, w=10) + fmt(mean(lst[h]), w=10)
+    print(row)
+
+
+# ---------------------------------------------------------------------------
+# [6] Sec :from_pl — HR-from-PL pivot vs direct ML, 160 ms FLEURS/VP
+# ---------------------------------------------------------------------------
+def t_from_pl(d):
+    hr("[6] Sec sec:from_pl — HR PL-pivot vs direct ML (160 ms)")
+    rows = ["100h", "250h", "500h", "1000h"]
+    print(f"  {'hours':<6s}{'direct ml FL':>14s}{'pivot ml FL':>14s}{'Δ FL':>8s}"
+          f"{'direct ml VP':>14s}{'pivot ml VP':>14s}{'Δ VP':>8s}")
+    for h in rows:
+        dml_fl = wer(d, "hr", h, "ml",          "160ms", "fleurs")
+        piv_fl = wer(d, "hr", h, "from_pl_ml",  "160ms", "fleurs")
+        dml_vp = wer(d, "hr", h, "ml",          "160ms", "voxpopuli")
+        piv_vp = wer(d, "hr", h, "from_pl_ml",  "160ms", "voxpopuli")
+        dfl = (piv_fl - dml_fl) if (dml_fl is not None and piv_fl is not None) else None
+        dvp = (piv_vp - dml_vp) if (dml_vp is not None and piv_vp is not None) else None
+        print(f"  {h:<6s}{fmt(dml_fl,w=14)}{fmt(piv_fl,w=14)}{fmt(dfl,signed=True,w=8)}"
+              f"{fmt(dml_vp,w=14)}{fmt(piv_vp,w=14)}{fmt(dvp,signed=True,w=8)}")
+    # PL(EN) pivot only at 100h
+    piv_en_fl = wer(d, "hr", "100h", "from_pl_enc", "160ms", "fleurs")
+    den_fl    = wer(d, "hr", "100h", "enc",         "160ms", "fleurs")
+    if piv_en_fl is not None and den_fl is not None:
+        print(f"  PL(EN) pivot @100h FLEURS: direct enc={den_fl:.2f}  "
+              f"pivot={piv_en_fl:.2f}  Δ={piv_en_fl - den_fl:+.2f} pp")
+
+
+# ---------------------------------------------------------------------------
+# [7] Sec :reinitjoint — joiner re-init Δ at 100 h, 560 ms FLEURS/VP
+# ---------------------------------------------------------------------------
+def t_reinitjoint(d):
+    hr("[7] Sec sec:reinitjoint — joiner-reinit Δ vs baseline @ 100h, 560 ms")
+    deltas_fl = {"ml": [], "enc": []}
+    deltas_vp = {"ml": [], "enc": []}
+    rows = []
+    for lang in LANGS:
+        for init in ("ml", "enc"):
+            base_fl = wer(d, lang, "100h", init, "560ms", "fleurs")
+            rj_fl   = wer(d, lang, "100h", f"{init}_reinitjoint", "560ms", "fleurs")
+            base_vp = wer(d, lang, "100h", init, "560ms", "voxpopuli")
+            rj_vp   = wer(d, lang, "100h", f"{init}_reinitjoint", "560ms", "voxpopuli")
+            dfl = (rj_fl - base_fl) if (base_fl is not None and rj_fl is not None) else None
+            dvp = (rj_vp - base_vp) if (base_vp is not None and rj_vp is not None) else None
+            if dfl is not None: deltas_fl[init].append(dfl)
+            if dvp is not None: deltas_vp[init].append(dvp)
+            rows.append((lang, init, dfl, dvp))
+    if not (deltas_fl["ml"] or deltas_fl["enc"]):
+        print("  (no reinitjoint cells found in JSON)")
+        return
+    print(f"  {'lang':<4s} {'init':<4s} {'Δ FL':>8s} {'Δ VP':>8s}")
+    for lang, init, dfl, dvp in rows:
+        print(f"  {lang:<4s} {init:<4s} {fmt(dfl,signed=True,w=8)} {fmt(dvp,signed=True,w=8)}")
+    all_fl = deltas_fl["ml"] + deltas_fl["enc"]
+    all_vp = deltas_vp["ml"] + deltas_vp["enc"]
+    hurt_fl = sum(1 for x in all_fl if x > 0)
+    hurt_vp = sum(1 for x in all_vp if x > 0)
+    print(f"\n  mean Δ FL  (all 16): {mean(all_fl):+0.2f} pp  ({hurt_fl}/{len(all_fl)} hurt)")
+    print(f"  mean Δ FL  (ml arm): {mean(deltas_fl['ml']):+0.2f} pp")
+    print(f"  mean Δ FL  (enc arm):{mean(deltas_fl['enc']):+0.2f} pp")
+    print(f"  mean Δ VP  (all):    {mean(all_vp):+0.2f} pp  ({hurt_vp}/{len(all_vp)} hurt)")
+    print(f"  mean Δ VP  (ml arm): {mean(deltas_vp['ml']):+0.2f} pp")
+    print(f"  mean Δ VP  (enc arm):{mean(deltas_vp['enc']):+0.2f} pp")
+    if deltas_fl["enc"] and deltas_fl["ml"]:
+        worst_enc = max(rows, key=lambda r: r[2] if r[1] == "enc" and r[2] is not None else -1)
+        worst_ml  = max(rows, key=lambda r: r[2] if r[1] == "ml"  and r[2] is not None else -1)
+        print(f"  worst Δ FL enc: {worst_enc[0]}-{worst_enc[1]} {worst_enc[2]:+0.2f}")
+        print(f"  worst Δ FL ml:  {worst_ml[0]}-{worst_ml[1]} {worst_ml[2]:+0.2f}")
+
+
+# ---------------------------------------------------------------------------
+# [8] Table :quant — INT4 vs FP32 @ 560 ms FLEURS
+# ---------------------------------------------------------------------------
+def t_quant(d):
+    hr("[8] Table tab:quant — INT4 vs FP32 @ 560 ms FLEURS")
+    rows = {h: {"ml": [], "enc": []} for h in HOURS}
+    all_cells = []           # (lang, hours, init, Δ_int4-fp32)
+    paired = []              # (lang, hours, Δ_ml, Δ_enc)
+    for h in HOURS:
+        per_lang_paired = {}
+        for lang in LANGS:
+            for init in ("ml", "enc"):
+                i4 = wer(d, lang, h, init, "560ms", "fleurs_int4")
+                f3 = wer(d, lang, h, init, "560ms", "fleurs_fp32")
+                if i4 is None or f3 is None:
+                    continue
+                dq = i4 - f3
+                rows[h][init].append(dq)
+                all_cells.append((lang, h, init, dq))
+                per_lang_paired.setdefault(lang, {})[init] = dq
+        for lang, cells in per_lang_paired.items():
+            if "ml" in cells and "enc" in cells:
+                paired.append((lang, h, cells["ml"], cells["enc"]))
+
+    print(f"  {'hours':<6s}{'Δ_ml':>9s}{'n_ml':>6s}{'Δ_enc':>9s}{'n_enc':>6s}")
+    for h in HOURS:
+        ml = rows[h]["ml"]; en = rows[h]["enc"]
+        print(f"  {h:<6s}{fmt(mean(ml),signed=True,w=9)}{len(ml):>6d}"
+              f"{fmt(mean(en),signed=True,w=9)}{len(en):>6d}")
+
+    # pooled stats over all (lang, hours, init)
+    dq_all = [c[3] for c in all_cells]
+    if dq_all:
+        dq_sorted = sorted(dq_all)
+        med = statistics.median(dq_sorted)
+        n = len(dq_all)
+        within05 = sum(1 for x in dq_all if abs(x) <= 0.5)
+        within10 = sum(1 for x in dq_all if abs(x) <= 1.0)
+        worse    = sum(1 for x in dq_all if x > 0)
+        better   = sum(1 for x in dq_all if x < 0)
+        print()
+        print(f"  pooled (n={n}):  mean={mean(dq_all):+0.2f}  median={med:+0.2f}"
+              f"  range=[{min(dq_all):+0.2f},{max(dq_all):+0.2f}]")
+        print(f"  |Δ| ≤ 0.5 pp: {within05}/{n}     |Δ| ≤ 1.0 pp: {within10}/{n}")
+        print(f"  INT4 worse than FP32: {worse}/{n}     INT4 better: {better}/{n}")
+
+    # paired ML vs EN quant cost
+    if paired:
+        diffs = [p[3] - p[2] for p in paired]              # Δ_enc - Δ_ml
+        enc_costlier = sum(1 for x in diffs if x > 0)
+        print(f"\n  paired ML vs EN (same lang, same hours, n={len(paired)}):")
+        print(f"    mean (Δ_enc - Δ_ml) = {mean(diffs):+0.2f} pp")
+        print(f"    EN costlier than ML in {enc_costlier}/{len(paired)} cells")
+        print(f"    range = [{min(diffs):+0.2f}, {max(diffs):+0.2f}] pp")
+        # 100h breakdown (paper says 'weakest at 100h, EN costlier in 5 of 8')
+        for h in HOURS:
+            sub = [(p[2], p[3]) for p in paired if p[1] == h]
+            if not sub:
+                continue
+            sub_diffs = [b - a for a, b in sub]
+            print(f"    {h}: paired n={len(sub)}  mean Δ_enc-Δ_ml={mean(sub_diffs):+0.2f}"
+                  f"  EN costlier in {sum(1 for x in sub_diffs if x > 0)}/{len(sub)}")
+
+
+# ---------------------------------------------------------------------------
+# [9] ES 5000h ML deltas vs ES 2500h ML (tab:5000h_es), plus ES 5000h ML
+#     vs the Nemotron-3.5 ML baseline (tab:supp:es5000h); all four test
+#     sets, 560 ms streaming.
+# ---------------------------------------------------------------------------
+def t_es_5000h(d):
+    if "5000h" not in d.get("es", {}):
+        return
+    hr("[9] Sec sec:hours — ES 5000h vs 2500h ML, 560 ms streaming")
+    for dataset in ("fleurs", "cv", "mls", "voxpopuli"):
+        a = wer(d, "es", "5000h", "ml", "560ms", dataset)
+        b = wer(d, "es", "2500h", "ml", "560ms", dataset)
+        delta_ = (a - b) if (a is not None and b is not None) else None
+        print(f"  {dataset:<10s}  5000h={fmt(a)}  2500h={fmt(b)}"
+              f"  Δ={fmt(delta_, signed=True)}")
+
+    # tab:supp:es5000h — ES 5000h (ML) vs contemporaneous Nemotron-3.5 ML
+    # baseline, 560 ms streaming.  Δ = WER_5000h − WER_Nemotron (negative:
+    # our 5000h model better).
+    if "nvidia-nemotron-3.5-asr" in d.get("es", {}).get("5000h", {}):
+        print("  -- tab:supp:es5000h — ES 5000h (ML) vs Nemotron-3.5 ML:")
+        for dataset in ("fleurs", "cv", "mls", "voxpopuli"):
+            a = wer(d, "es", "5000h", "ml", "560ms", dataset)
+            n = wer(d, "es", "5000h", "nvidia-nemotron-3.5-asr", "560ms", dataset)
+            delta_ = (a - n) if (a is not None and n is not None) else None
+            print(f"  {dataset:<10s}  5000h={fmt(a)}  nemotron={fmt(n)}"
+                  f"  Δ={fmt(delta_, signed=True)}")
+
+
+# ---------------------------------------------------------------------------
+# [10] fig:gap_powerlaw — fit  Δ(h) = a · h^(-β)  on the 160 ms macro means
+#      with a language-bootstrap 95% CI on β.
+# ---------------------------------------------------------------------------
+def t_powerlaw(d, B=10000, seed=0):
+    hr("[10] fig:gap_powerlaw — transfer-gap power-law fit (160 ms FLEURS)")
+    import math
+    import random as _rand
+    rng = _rand.Random(seed)
+    hours_int = [int(h[:-1]) for h in HOURS]
+
+    def fit(deltas_by_h):
+        """Return (β, log_a, R²) from least-squares fit on log(h) vs log(Δ)
+        across hours where Δ > 0 (so log is defined)."""
+        xs, ys = [], []
+        for h, dl in zip(hours_int, deltas_by_h):
+            if dl is None or dl <= 0:
+                continue
+            xs.append(math.log(h)); ys.append(math.log(dl))
+        if len(xs) < 2:
+            return None, None, None
+        n = len(xs)
+        mx = sum(xs)/n; my = sum(ys)/n
+        sxy = sum((x-mx)*(y-my) for x, y in zip(xs, ys))
+        sxx = sum((x-mx)**2 for x in xs)
+        if sxx == 0:
+            return None, None, None
+        slope = sxy / sxx       # = -β
+        intercept = my - slope * mx
+        beta = -slope
+        # R²
+        syy = sum((y-my)**2 for y in ys)
+        if syy == 0:
+            r2 = 1.0
+        else:
+            ss_res = sum((y - (slope*x + intercept))**2 for x, y in zip(xs, ys))
+            r2 = 1 - ss_res/syy
+        return beta, intercept, r2
+
+    # point estimate from the full 8-lang macro means
+    macro = [mean([delta(d, l, h, "160ms", "fleurs") for l in LANGS]) for h in HOURS]
+    beta, log_a, r2 = fit(macro)
+    if beta is None:
+        print("  (insufficient points for power-law fit)")
+        return
+    print(f"  hours      mean Δ (160 ms FLEURS)")
+    for h, m in zip(HOURS, macro):
+        print(f"  {h:<8s}   {fmt(m, signed=True)}")
+    print(f"\n  β_TG  = {beta:.3f}    R² = {r2:.4f}    "
+          f"(fit on log Δ vs log h, where Δ>0)")
+
+    # language-bootstrap CI: resample 8 languages with replacement, recompute
+    # macro means per hours, refit, collect β.
+    betas = []
+    n_lang = len(LANGS)
+    for _ in range(B):
+        sample = [LANGS[rng.randrange(n_lang)] for _ in range(n_lang)]
+        ms = [mean([delta(d, l, h, "160ms", "fleurs") for l in sample]) for h in HOURS]
+        b, _, _ = fit(ms)
+        if b is not None and math.isfinite(b):
+            betas.append(b)
+    if betas:
+        betas.sort()
+        lo = betas[int(0.025 * len(betas))]
+        hi = betas[int(0.975 * len(betas))]
+        frac_below = sum(1 for b in betas if b < 0.5) / len(betas)
+        print(f"  language-bootstrap 95% CI on β (B={B}): [{lo:.2f}, {hi:.2f}]")
+        print(f"  P(β < 0.5) = {frac_below:.4f}  ({100 * frac_below:.2f}%)")
+
+    # off-tier residuals (paper Fig. fig:gap_powerlaw caption: 0.23/0.29/0.13 pp)
+    import math as _m
+    print("\n  Off-tier residuals against the 160 ms-fitted curve:")
+    for tier in ("560ms", "1120ms", "offline"):
+        mac = [mean([delta(d, l, h, tier, "fleurs") for l in LANGS]) for h in HOURS]
+        res = []
+        for h, m in zip(hours_int, mac):
+            if m is None or m <= 0:
+                continue
+            pred = _m.exp(log_a + (-beta) * _m.log(h))
+            res.append((m - pred) ** 2)
+        if res:
+            rms = (sum(res) / len(res)) ** 0.5
+            print(f"    {tier:<8s}   RMS={rms:.2f} pp  (n={len(res)})")
+
+
+# ---------------------------------------------------------------------------
+# [11] tab:hybrid — hybrid-encoder, 100h training, 560 ms FLEURS
+#      Splices: hybrid_0to12 / hybrid_last / hybrid_first / hybrid_middle
+#      Reference rows are seed-45 ml / enc (paper: same common seed).
+# ---------------------------------------------------------------------------
+def t_hybrid(d):
+    hr("[11] tab:hybrid — hybrid encoder @ 100h, 560 ms FLEURS")
+    rows = [
+        ("ML (s45)",   "ml_s45"),
+        ("0:12",        "hybrid_0to12"),
+        ("last",        "hybrid_last"),
+        ("first",       "hybrid_first"),
+        ("middle",      "hybrid_middle"),
+        ("EN (s45)",   "enc_s45"),
+    ]
+    # header
+    print(f"  {'row':<10s}" + "".join(f"{l.upper():>7s}" for l in LANGS)
+          + f"{'mean':>9s}{'Δ vs ML':>10s}")
+    ml_row = None
+    table = []
+    for label, init in rows:
+        cells = [wer(d, l, "100h", init, "560ms", "fleurs") for l in LANGS]
+        mn = mean(cells)
+        table.append((label, init, cells, mn))
+        if init == "ml_s45":
+            ml_row = cells
+    for label, init, cells, mn in table:
+        if ml_row is None or any(c is None for c in cells) or any(m is None for m in ml_row):
+            d_vs_ml = None
+        else:
+            pairwise = [c - m for c, m in zip(cells, ml_row)]
+            d_vs_ml = sum(pairwise) / len(pairwise)
+        row = f"  {label:<10s}" + "".join(fmt(c, w=7) for c in cells) + fmt(mn, w=9)
+        row += fmt(d_vs_ml, signed=True, w=10) if d_vs_ml is not None else f"{'--':>10s}"
+        print(row)
+
+    # seen / unseen group means
+    print("\n  group means:")
+    for label, init, cells, _ in table:
+        seen_m   = mean([wer(d, l, "100h", init, "560ms", "fleurs") for l in SEEN])
+        unseen_m = mean([wer(d, l, "100h", init, "560ms", "fleurs") for l in UNSEEN])
+        print(f"    {label:<10s}  seen={fmt(seen_m, w=7)}  unseen={fmt(unseen_m, w=7)}")
+
+
+# ---------------------------------------------------------------------------
+# [12] tab:seed + sec:seed — seed comparison
+#      (a) HR/PT main-grid 160 ms FLEURS + VP, default seed vs seed 45
+#      (b) 16-cell 100h re-run @ 560 ms across all 8 langs × 2 inits;
+#          stats: mean |Δ|, median, max on FLEURS and VP
+#      (c) HR-100h FLEURS swing collapse at 560 ms
+#      (d) Largest seed-induced EN-ML gap excursion (IS at 100h)
+# ---------------------------------------------------------------------------
+def t_seed(d):
+    hr("[12] tab:seed + sec:seed — seed-default vs seed-45")
+    # (a) HR / PT main grid at 160 ms FLEURS + VP
+    print("  (a) HR / PT main-grid FLEURS@160ms and VP@160ms seed deltas:")
+    print(f"  {'lang':<4s}{'init':<5s}{'hours':<6s}"
+          f"{'FL_s1':>8s}{'FL_s2':>8s}{'ΔFL':>8s}"
+          f"{'VP_s1':>8s}{'VP_s2':>8s}{'ΔVP':>8s}")
+    fl_abs, vp_abs = [], []
+    rows = []
+    for lang in ("hr", "pt"):
+        for init in ("ml", "enc"):
+            for h in HOURS:
+                a_fl = wer(d, lang, h, init,       "160ms", "fleurs")
+                b_fl = wer(d, lang, h, init+"_s45","160ms", "fleurs")
+                a_vp = wer(d, lang, h, init,       "160ms", "voxpopuli")
+                b_vp = wer(d, lang, h, init+"_s45","160ms", "voxpopuli")
+                if a_fl is None or b_fl is None:
+                    continue
+                dfl = b_fl - a_fl
+                dvp = (b_vp - a_vp) if (a_vp is not None and b_vp is not None) else None
+                fl_abs.append(abs(dfl))
+                if dvp is not None: vp_abs.append(abs(dvp))
+                rows.append((lang, init, h, dfl, dvp))
+                print(f"  {lang:<4s}{init:<5s}{h:<6s}"
+                      f"{a_fl:>8.2f}{b_fl:>8.2f}{dfl:>+8.2f}"
+                      f"{fmt(a_vp,w=8)}{fmt(b_vp,w=8)}{fmt(dvp,signed=True,w=8)}")
+    if fl_abs:
+        print(f"\n    mean |ΔFL| = {sum(fl_abs)/len(fl_abs):.2f} pp"
+              f"  (n={len(fl_abs)}, max={max(fl_abs):.2f})")
+    if vp_abs:
+        print(f"    mean |ΔVP| = {sum(vp_abs)/len(vp_abs):.2f} pp"
+              f"  (n={len(vp_abs)}, max={max(vp_abs):.2f})")
+
+    # (b) 16-cell 100h re-run @ 560 ms (all 8 langs × 2 inits)
+    print("\n  (b) 100h × 8 langs × 2 inits  @ 560 ms (FLEURS, VP):")
+    fl, vp = [], []
+    cells_fl, cells_vp = [], []
+    for lang in LANGS:
+        for init in ("ml", "enc"):
+            a_fl = wer(d, lang, "100h", init,        "560ms", "fleurs")
+            b_fl = wer(d, lang, "100h", init+"_s45", "560ms", "fleurs")
+            a_vp = wer(d, lang, "100h", init,        "560ms", "voxpopuli")
+            b_vp = wer(d, lang, "100h", init+"_s45", "560ms", "voxpopuli")
+            if a_fl is not None and b_fl is not None:
+                fl.append(abs(b_fl - a_fl))
+                cells_fl.append((lang, init, b_fl - a_fl))
+            if a_vp is not None and b_vp is not None:
+                vp.append(abs(b_vp - a_vp))
+                cells_vp.append((lang, init, b_vp - a_vp))
+    if fl:
+        s = sorted(fl)
+        worst = max(cells_fl, key=lambda x: abs(x[2]))
+        print(f"    FLEURS:  mean |Δ|={sum(fl)/len(fl):.2f}  median={s[len(s)//2]:.2f}"
+              f"  max={max(fl):.2f}  ({worst[0]}-{worst[1]})  n={len(fl)}")
+    if vp:
+        s = sorted(vp)
+        worst = max(cells_vp, key=lambda x: abs(x[2]))
+        print(f"    VoxPopuli: mean |Δ|={sum(vp)/len(vp):.2f}  median={s[len(s)//2]:.2f}"
+              f"  max={max(vp):.2f}  ({worst[0]}-{worst[1]})  n={len(vp)}")
+
+    # (c) HR-100h FLEURS swing collapse at 560 ms vs 160 ms
+    print("\n  (c) HR-100h FLEURS seed swing collapse 160 ms → 560 ms:")
+    for init in ("ml", "enc"):
+        for tier in ("160ms", "560ms"):
+            a = wer(d, "hr", "100h", init,        tier, "fleurs")
+            b = wer(d, "hr", "100h", init+"_s45", tier, "fleurs")
+            if a is not None and b is not None:
+                print(f"    hr-{init:<3s} @ {tier:<6s}: s1={a:.2f}  s2={b:.2f}  Δ={b-a:+.2f}")
+
+    # (d) Largest seed-induced EN-ML gap excursion at 100h / 560 ms
+    print("\n  (d) Seed-induced EN-ML gap excursion at 100h / 560 ms FLEURS:")
+    print(f"  {'lang':<4s}{'Δ(s1)':>10s}{'Δ(s2)':>10s}{'shift':>10s}{'sign?':>8s}")
+    biggest = (None, 0.0)
+    for lang in LANGS:
+        ml1 = wer(d, lang, "100h", "ml",      "560ms", "fleurs")
+        en1 = wer(d, lang, "100h", "enc",     "560ms", "fleurs")
+        ml2 = wer(d, lang, "100h", "ml_s45",  "560ms", "fleurs")
+        en2 = wer(d, lang, "100h", "enc_s45", "560ms", "fleurs")
+        if any(x is None for x in (ml1, en1, ml2, en2)):
+            continue
+        d1 = en1 - ml1; d2 = en2 - ml2
+        sign_keep = "yes" if (d1 >= 0) == (d2 >= 0) else "NO"
+        shift = d2 - d1
+        print(f"  {lang:<4s}{d1:>+10.2f}{d2:>+10.2f}{shift:>+10.2f}{sign_keep:>8s}")
+        if abs(shift) > abs(biggest[1]):
+            biggest = (lang, shift)
+    if biggest[0]:
+        print(f"    largest shift: {biggest[0]} ({biggest[1]:+.2f} pp)")
+
+
+# ---------------------------------------------------------------------------
+# [13] Streaming penalty per (tier, hours, init) on FLEURS
+#      penalty = WER(tier) - WER(offline)
+# ---------------------------------------------------------------------------
+def t_streaming_penalty(d):
+    hr("[13] Streaming penalty (FLEURS): WER(tier) - WER(offline)")
+    print(f"  {'init':<5s}{'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS))
+    for init in ("ml", "enc"):
+        for tier in ("160ms", "560ms", "1120ms"):
+            row = f"  {init:<5s}{tier:<10s}"
+            for h in HOURS:
+                tier_wers = [wer(d, l, h, init, tier,     "fleurs") for l in LANGS]
+                off_wers  = [wer(d, l, h, init, "offline", "fleurs") for l in LANGS]
+                pairs = [(t - o) for t, o in zip(tier_wers, off_wers)
+                         if t is not None and o is not None]
+                m = mean(pairs)
+                row += fmt(m, signed=True, w=10)
+            print(row)
+
+
+# ---------------------------------------------------------------------------
+# [14] tab:per_dataset — 160 ms WER per (lang, hours, init, dataset)
+# ---------------------------------------------------------------------------
+def t_per_dataset(d):
+    hr("[14] tab:per_dataset — 160 ms WER per (lang, hours, init, dataset)")
+    datasets = ("cv", "mls", "voxpopuli", "fleurs")
+    print(f"  {'lang':<5s}{'hours':<7s}"
+          + "".join(f"{ds.upper() + ' ml':>10s}{ds.upper() + ' en':>10s}"
+                    for ds in datasets))
+    for lang in LANGS:
+        for h in HOURS:
+            row = f"  {lang:<5s}{h:<7s}"
+            for ds in datasets:
+                ml = wer(d, lang, h, "ml",  "160ms", ds)
+                en = wer(d, lang, h, "enc", "160ms", ds)
+                row += fmt(ml, w=10) + fmt(en, w=10)
+            print(row)
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+def main(argv):
+    src = Path(argv[1]) if len(argv) > 1 else DEFAULT_JSON
+    if not src.is_file():
+        print(f"error: results file not found: {src}\n"
+              f"       pass the path to wer_results.json as the first argument.",
+              file=sys.stderr)
+        return 2
+    d = json.loads(src.read_text())
+    print(f"Reading {src}")
+    t_main160(d)
+    t_seen_unseen(d)
+    t_latency_effect(d)
+    t_abs_wer(d)
+    t_lst(d)
+    t_from_pl(d)
+    t_reinitjoint(d)
+    t_quant(d)
+    t_es_5000h(d)
+    t_powerlaw(d)
+    t_hybrid(d)
+    t_seed(d)
+    t_streaming_penalty(d)
+    t_per_dataset(d)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

requirements.txt

@@ -0,0 +1,25 @@
+# Minimal suggested environment for the released scripts.
+#
+# This is intentionally not a full pip freeze / exact reproduction of the
+# authors' local environment. CUDA, PyTorch and NeMo stacks can be
+# platform-specific, so this file lists only the main direct dependencies
+# needed to understand and run the code in a typical setup.
+#
+# Core training / .nemo evaluation dependencies
+nemo_toolkit[asr]==2.6.2
+numpy
+torch
+tqdm
+soundfile
+jiwer
+sentencepiece
+omegaconf
+
+# Used by eval_fleurs.py
+datasets
+
+# Used by onnx_eval/eval_fleurs_onnx.py
+onnxruntime-genai
+
+# Note: the WER normalization code is imported from a clone of
+# huggingface/open_asr_leaderboard via OPEN_ASR_LB_ROOT or PYTHONPATH.

train_multilingual_nemotron.py

@@ -0,0 +1,1029 @@
+#!/usr/bin/env python3
+"""
+train_multilingual_nemotron.py
+
+Multi-GPU training of Nemotron-Speech-Streaming for 5 European languages.
+Based on distill_parakeet_to_nemotron_german.py, adapted for:
+  - Multi-GPU (torchrun + DDP)
+  - Multilingual (DE, ES, FR, IT, NL combined manifest)
+  - No distillation by default (Stage 1 = pure RNNT fine-tuning)
+
+Usage:
+  # Multilingual baseline (7 GPUs)
+  torchrun --nproc_per_node=7 train_multilingual_nemotron.py \
+    --train_manifest <DATA_ROOT>/combined_train.json \
+    --val_manifest   <VAL_MANIFEST> \
+    --output_dir ./multilingual_baseline \
+    --epochs 30 --batch_size 32 --grad_accum 2 --lr 1e-4
+
+Manifest format (one JSON object per line):
+  {"audio_filepath": "/abs/path/utt.wav", "duration": 8.4, "text": "reference transcript"}
+  `duration` (seconds) is required for min/max-duration filtering.
+
+Requirements:
+  pip install nemo_toolkit[asr] soundfile jiwer tqdm
+"""
+
+import argparse
+import json
+import math
+import os
+import random
+import re
+import sys
+import unicodedata
+from collections import defaultdict
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader, DistributedSampler
+from tqdm import tqdm
+
+
+# ═══════════════════════════════════════════════════════════
+# DDP Utilities
+# ═══════════════════════════════════════════════════════════
+
+def setup_ddp():
+    """Initialize distributed training. Returns (rank, world_size, is_distributed)."""
+    if "RANK" in os.environ:
+        rank = int(os.environ["RANK"])
+        world_size = int(os.environ["WORLD_SIZE"])
+        local_rank = int(os.environ["LOCAL_RANK"])
+        dist.init_process_group("nccl")
+        torch.cuda.set_device(local_rank)
+        return rank, world_size, local_rank, True
+    else:
+        return 0, 1, 0, False
+
+
+def cleanup_ddp(is_distributed):
+    if is_distributed:
+        dist.destroy_process_group()
+
+
+def is_main(rank):
+    return rank == 0
+
+
+def print_rank0(msg, rank=0):
+    if is_main(rank):
+        print(msg, flush=True)
+
+
+# ═══════════════════════════════════════════════════════════
+# Configuration
+# ═══════════════════════════════════════════════════════════
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        description="Multi-GPU Nemotron Streaming ASR Training (Multilingual)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    # Models
+    p.add_argument("--teacher", default="nvidia/parakeet-tdt-0.6b-v3",
+                   help="Teacher model for tokenizer extraction")
+    p.add_argument("--student", default="nvidia/nemotron-speech-streaming-en-0.6b",
+                   help="Student model (English, streaming)")
+
+    # Data — manifests directly
+    p.add_argument("--train_manifest", type=str, required=True,
+                   help="Path to combined training manifest (JSONL)")
+    p.add_argument("--val_manifest", type=str, default=None,
+                   help="Path to combined validation manifest (for best model selection)")
+    p.add_argument("--eval_dir", type=str, default=None,
+                   help="Optional: base dir containing per-language eval/ dirs with "
+                        "validation_manifest.json (used for the per-language WER "
+                        "printout at eval time). Skipped if not set.")
+
+    # Training
+    p.add_argument("--output_dir", default="./multilingual_nemotron")
+    p.add_argument("--epochs", type=int, default=30)
+    p.add_argument("--batch_size", type=int, default=32,
+                   help="Per-GPU batch size")
+    p.add_argument("--grad_accum", type=int, default=2,
+                   help="Gradient accumulation steps")
+    p.add_argument("--lr", type=float, default=1e-4)
+    p.add_argument("--min_lr", type=float, default=4e-6)
+    p.add_argument("--weight_decay", type=float, default=1e-3)
+    p.add_argument("--warmup_epochs", type=int, default=1)
+    p.add_argument("--max_duration", type=float, default=20.0)
+    p.add_argument("--min_duration", type=float, default=0.3)
+
+    # SpecAugment
+    p.add_argument("--no_spec_augment", action="store_true", default=False)
+    p.add_argument("--freq_masks", type=int, default=2)
+    p.add_argument("--freq_width", type=int, default=27)
+    p.add_argument("--time_masks", type=int, default=10)
+    p.add_argument("--time_width", type=float, default=0.05)
+
+    # Speed perturbation
+    p.add_argument("--speed_perturb", action="store_true", default=True)
+    p.add_argument("--speed_perturb_factors", type=float, nargs='+', default=[0.9, 1.0, 1.1])
+
+    # Misc
+    p.add_argument("--freeze_encoder_epochs", type=int, default=0,
+                   help="Freeze encoder for first N epochs")
+    p.add_argument("--constant_lr", action="store_true", default=False)
+    p.add_argument("--log_every", type=int, default=50)
+    p.add_argument("--eval_every_epoch", type=int, default=1)
+    p.add_argument("--save_every_epoch", type=int, default=5)
+    p.add_argument("--early_stop_patience", type=int, default=3,
+                   help="Stop if WER doesn't improve for N evals (0=disabled)")
+    p.add_argument("--fp16", action="store_true", default=True)
+    p.add_argument("--num_workers", type=int, default=4)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--resume_from", type=str, default=None,
+                   help="Resume from .nemo checkpoint (skips tokenizer swap)")
+
+    return p.parse_args()
+
+
+# ═══════════════════════════════════════════════════════════
+# Tokenizer Extraction (from teacher)
+# ═══════════════════════════════════════════════════════════
+
+def extract_tokenizer(model, tokenizer_dir):
+    """Extract tokenizer .model file from a NeMo ASR model."""
+    from pathlib import Path
+    import tarfile
+
+    os.makedirs(tokenizer_dir, exist_ok=True)
+    out_model = Path(tokenizer_dir) / "tokenizer.model"
+
+    tok = getattr(model, "tokenizer", None)
+    sp = getattr(tok, "tokenizer", None)
+
+    if sp is not None and hasattr(sp, "serialized_model_proto"):
+        blob = sp.serialized_model_proto()
+        if blob:
+            out_model.write_bytes(blob)
+            _generate_vocab_txt(tokenizer_dir)
+            vs = getattr(sp, "vocab_size", None)
+            if callable(vs):
+                vs = vs()
+            return str(Path(tokenizer_dir)), int(vs) if vs else 0
+
+    raise RuntimeError("Could not extract tokenizer from teacher model")
+
+
+def _generate_vocab_txt(tokenizer_dir):
+    import sentencepiece as spm_lib
+    model_path = os.path.join(tokenizer_dir, "tokenizer.model")
+    vocab_path = os.path.join(tokenizer_dir, "vocab.txt")
+    if os.path.exists(vocab_path):
+        return
+    sp = spm_lib.SentencePieceProcessor()
+    sp.load(model_path)
+    with open(vocab_path, "w", encoding="utf-8") as f:
+        for i in range(sp.get_piece_size()):
+            f.write(sp.id_to_piece(i) + "\n")
+
+
+# ═══════════════════════════════════════════════════════════
+# Model Setup
+# ═══════════════════════════════════════════════════════════
+
+def setup_spec_augment(student, args):
+    from nemo.collections.asr.modules.audio_preprocessing import SpectrogramAugmentation
+
+    if args.no_spec_augment:
+        student.spec_augmentation = None
+        return
+
+    spec_aug = SpectrogramAugmentation(
+        freq_masks=args.freq_masks,
+        time_masks=args.time_masks,
+        freq_width=args.freq_width,
+        time_width=args.time_width,
+    )
+    student.spec_augmentation = spec_aug.to(next(student.parameters()).device)
+
+    from omegaconf import open_dict
+    with open_dict(student.cfg):
+        student.cfg.spec_augment.freq_masks = args.freq_masks
+        student.cfg.spec_augment.time_masks = args.time_masks
+        student.cfg.spec_augment.freq_width = args.freq_width
+        student.cfg.spec_augment.time_width = args.time_width
+
+
+def load_student(args, device, rank):
+    """Load student model, optionally swap tokenizer."""
+    import nemo.collections.asr as nemo_asr
+
+    if args.resume_from:
+        print_rank0(f"  Resuming student from: {args.resume_from}", rank)
+        student = nemo_asr.models.ASRModel.restore_from(args.resume_from, map_location='cpu')
+        print_rank0(f"  Student vocab: {student.tokenizer.vocab_size} tokens", rank)
+        args.freeze_encoder_epochs = 0
+    else:
+        # Extract teacher tokenizer (only rank 0 does this, then all read from disk)
+        tokenizer_dir = os.path.join(args.output_dir, "teacher_tokenizer")
+        if is_main(rank):
+            print_rank0(f"  Loading teacher for tokenizer: {args.teacher}", rank)
+            teacher = nemo_asr.models.ASRModel.from_pretrained(args.teacher)
+            tokenizer_dir, teacher_vocab_size = extract_tokenizer(teacher, tokenizer_dir)
+            print_rank0(f"  Teacher vocab: {teacher_vocab_size}", rank)
+            del teacher
+            torch.cuda.empty_cache()
+
+        if dist.is_initialized():
+            dist.barrier()
+
+        # Load student
+        print_rank0(f"  Loading student: {args.student}", rank)
+        student = nemo_asr.models.ASRModel.from_pretrained(args.student)
+
+        old_vocab = student.tokenizer.vocab_size
+        student.change_vocabulary(new_tokenizer_dir=tokenizer_dir, new_tokenizer_type="bpe")
+        new_vocab = student.tokenizer.vocab_size
+        print_rank0(f"  Tokenizer swap: {old_vocab} → {new_vocab}", rank)
+
+    student = student.to(device)
+
+    # SpecAugment
+    setup_spec_augment(student, args)
+
+    # Disable CUDA graphs and typecheck
+    from omegaconf import open_dict
+    from nemo.core.classes.common import typecheck
+    typecheck.set_typecheck_enabled(False)
+    with open_dict(student.cfg):
+        student.cfg.decoding.greedy.use_cuda_graph_decoder = False
+    student.change_decoding_strategy(student.cfg.decoding)
+
+    params = sum(p.numel() for p in student.parameters()) / 1e6
+    print_rank0(f"  Student params: {params:.1f}M", rank)
+
+    return student
+
+
+# ═══════════════════════════════════════════════════════════
+# Dataset & DataLoader
+# ═══════════════════════════════════════════════════════════
+
+class ASRManifestDataset(torch.utils.data.Dataset):
+    def __init__(self, manifest_path, tokenizer, min_duration=0.3, max_duration=20.0,
+                 speed_perturb=False, speed_perturb_factors=None):
+        self.tokenizer = tokenizer
+        self.speed_perturb = speed_perturb
+        self.speed_perturb_factors = speed_perturb_factors or [0.9, 1.0, 1.1]
+        self.samples = []
+
+        with open(manifest_path) as f:
+            for line in f:
+                item = json.loads(line)
+                dur = item["duration"]
+                if min_duration <= dur <= max_duration:
+                    self.samples.append(item)
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        import soundfile as sf
+        item = self.samples[idx]
+        try:
+            audio, sr = sf.read(item["audio_filepath"], dtype="float32")
+        except Exception as e:
+            print(f"    Corrupt audio: {item['audio_filepath']} ({e})", flush=True)
+            return None
+
+        if sr != 16000:
+            ratio = 16000 / sr
+            new_len = int(len(audio) * ratio)
+            audio = np.interp(
+                np.linspace(0, len(audio) - 1, new_len),
+                np.arange(len(audio)), audio,
+            ).astype(np.float32)
+
+        # Speed perturbation
+        if self.speed_perturb:
+            import random
+            speed = random.choice(self.speed_perturb_factors)
+            if speed != 1.0:
+                new_len = int(len(audio) / speed)
+                audio = np.interp(
+                    np.linspace(0, len(audio) - 1, new_len),
+                    np.arange(len(audio)), audio,
+                ).astype(np.float32)
+
+        audio_tensor = torch.FloatTensor(audio)
+
+        text = unicodedata.normalize("NFKC", item["text"])
+        text = " ".join(text.split())
+        tokens = torch.LongTensor(self.tokenizer.text_to_ids(text))
+
+        return audio_tensor, tokens
+
+
+def collate_asr(batch):
+    batch = [b for b in batch if b is not None]
+    if len(batch) == 0:
+        return None
+    audios = [b[0] for b in batch]
+    tokens_list = [b[1] for b in batch]
+
+    audio_lens = torch.LongTensor([len(a) for a in audios])
+    token_lens = torch.LongTensor([len(t) for t in tokens_list])
+
+    max_audio = audio_lens.max().item()
+    max_tokens = token_lens.max().item()
+    B = len(audios)
+
+    padded_audio = torch.zeros(B, max_audio)
+    padded_tokens = torch.zeros(B, max_tokens, dtype=torch.long)
+
+    for i in range(B):
+        padded_audio[i, :audio_lens[i]] = audios[i]
+        padded_tokens[i, :token_lens[i]] = tokens_list[i]
+
+    return padded_audio, audio_lens, padded_tokens, token_lens
+
+
+# ═══════════════════════════════════════════════════════════
+# Training Step
+# ═══════════════════════════════════════════════════════════
+
+def train_step(student, batch, device):
+    """Single forward/backward step: RNNT loss only."""
+    audio, audio_len, tokens, token_len = batch
+    audio = audio.to(device)
+    audio_len = audio_len.to(device)
+    tokens = tokens.to(device)
+    token_len = token_len.to(device)
+
+    # Get underlying model if wrapped in DDP
+    model = student.module if isinstance(student, DDP) else student
+
+    # Mel spectrogram
+    mel, mel_len = model.preprocessor(input_signal=audio, length=audio_len)
+
+    # Spec augmentation
+    if model.spec_augmentation is not None and model.training:
+        mel = model.spec_augmentation(input_spec=mel, length=mel_len)
+
+    # Encoder
+    enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+
+    # Decoder
+    dec_out = model.decoder(targets=tokens, target_length=token_len)
+    if isinstance(dec_out, tuple):
+        dec_out = dec_out[0]
+
+    # Joint + RNNT loss
+    if getattr(model.joint, 'fuse_loss_wer', False):
+        result = model.joint(
+            encoder_outputs=enc, decoder_outputs=dec_out,
+            encoder_lengths=enc_len, transcripts=tokens,
+            transcript_lengths=token_len, compute_wer=False,
+        )
+        loss = result[0]
+    else:
+        joint_out = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
+        loss = model.loss(
+            log_probs=joint_out, targets=tokens,
+            input_lengths=enc_len, target_lengths=token_len,
+        )
+
+    # Ensure loss is scalar
+    if loss.dim() > 0:
+        loss = loss.mean()
+
+    return loss
+
+
+# ═══════════════════════════════════════════════════════════
+# Evaluation
+# ═══════════════════════════════════════════════════════════
+
+@torch.no_grad()
+def evaluate(student, manifest_path, device, max_samples=None):
+    """Evaluate WER using streaming inference."""
+    import soundfile as sf_eval
+    from nemo.collections.asr.parts.utils.streaming_utils import CacheAwareStreamingAudioBuffer
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    def normalize_text(text):
+        text = unicodedata.normalize('NFKC', text)
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', '', text)
+        return ' '.join(text.split())
+
+    def simple_wer(ref_words, hyp_words):
+        n, m = len(ref_words), len(hyp_words)
+        dp = [[0] * (m + 1) for _ in range(n + 1)]
+        for i in range(n + 1): dp[i][0] = i
+        for j in range(m + 1): dp[0][j] = j
+        for i in range(1, n + 1):
+            for j in range(1, m + 1):
+                dp[i][j] = dp[i-1][j-1] if ref_words[i-1] == hyp_words[j-1] \
+                    else 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+        return dp[n][m]
+
+    right_context = 13
+    chunk_frames = 1 + right_context
+    model.encoder.setup_streaming_params(
+        chunk_size=chunk_frames,
+        shift_size=chunk_frames,
+        left_chunks=70 // max(chunk_frames, 1),
+    )
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_edits, total_words = 0, 0
+    examples = []
+    errors = 0
+
+    for s in samples:
+        try:
+            audio, sr = sf_eval.read(s["audio_filepath"], dtype="float32")
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            buffer = CacheAwareStreamingAudioBuffer(model=model)
+            buffer.append_audio(audio)
+
+            cache_last_channel, cache_last_time, cache_last_channel_len = \
+                model.encoder.get_initial_cache_state(batch_size=1, dtype=torch.float32, device=device)
+            previous_hypotheses = None
+            pred = ""
+
+            for chunk_audio, chunk_len in buffer:
+                if chunk_audio is None:
+                    break
+                result = model.conformer_stream_step(
+                    processed_signal=chunk_audio,
+                    processed_signal_length=chunk_len,
+                    cache_last_channel=cache_last_channel,
+                    cache_last_time=cache_last_time,
+                    cache_last_channel_len=cache_last_channel_len,
+                    previous_hypotheses=previous_hypotheses,
+                    return_transcription=True,
+                )
+                if isinstance(result, tuple) and len(result) >= 6:
+                    cache_last_channel = result[2]
+                    cache_last_time = result[3]
+                    cache_last_channel_len = result[4]
+                    previous_hypotheses = result[5]
+                    if result[5] and len(result[5]) > 0:
+                        hyp = result[5][0]
+                        new_text = ""
+                        if hasattr(hyp, 'text') and hyp.text:
+                            new_text = hyp.text
+                        elif hasattr(hyp, 'y_sequence'):
+                            tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                            if tids:
+                                new_text = model.tokenizer.ids_to_text(tids)
+                        if new_text and len(new_text) > len(pred):
+                            pred = new_text
+
+            ref_n = normalize_text(s["text"])
+            pred_n = normalize_text(pred)
+            ref_words = ref_n.split()
+            pred_words = pred_n.split()
+
+            if ref_words:
+                edits = simple_wer(ref_words, pred_words)
+                total_edits += edits
+                total_words += len(ref_words)
+
+            if len(examples) < 5:
+                examples.append((s["text"][:55], pred[:55]))
+
+        except Exception as e:
+            errors += 1
+            if errors <= 3:
+                print(f"    [eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+
+    print(f"\n    {'Reference':<55} | {'Prediction':<55}")
+    print(f"    {'-'*55} | {'-'*55}")
+    for ref, pred in examples:
+        print(f"    {ref:<55} | {pred:<55}")
+    if errors:
+        print(f"    ({errors} samples failed)")
+
+    model.train()
+    return wer_score
+
+
+@torch.no_grad()
+def evaluate_batch(student, manifest_path, device, max_samples=None):
+    """Evaluate WER using batch (non-streaming) inference."""
+    import soundfile as sf_eval
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    def normalize_text(text):
+        text = unicodedata.normalize('NFKC', text)
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', '', text)
+        return ' '.join(text.split())
+
+    def simple_wer(ref_words, hyp_words):
+        n, m = len(ref_words), len(hyp_words)
+        dp = [[0] * (m + 1) for _ in range(n + 1)]
+        for i in range(n + 1): dp[i][0] = i
+        for j in range(m + 1): dp[0][j] = j
+        for i in range(1, n + 1):
+            for j in range(1, m + 1):
+                dp[i][j] = dp[i-1][j-1] if ref_words[i-1] == hyp_words[j-1] \
+                    else 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+        return dp[n][m]
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_edits, total_words = 0, 0
+    errors = 0
+    batch_size = 16
+
+    for start in range(0, len(samples), batch_size):
+        batch_samples = samples[start:start + batch_size]
+        try:
+            audios = []
+            for s in batch_samples:
+                audio, sr = sf_eval.read(s["audio_filepath"], dtype="float32")
+                if len(audio.shape) > 1:
+                    audio = audio.mean(axis=1)
+                audios.append(torch.FloatTensor(audio))
+
+            audio_lens = torch.LongTensor([len(a) for a in audios])
+            max_len = audio_lens.max().item()
+            padded = torch.zeros(len(audios), max_len)
+            for i, a in enumerate(audios):
+                padded[i, :len(a)] = a
+
+            padded = padded.to(device)
+            audio_lens = audio_lens.to(device)
+
+            mel, mel_len = model.preprocessor(input_signal=padded, length=audio_lens)
+            enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+
+            # Greedy decode
+            best_hyps = model.decoding.rnnt_decoder_predictions_tensor(enc, enc_len)
+            if isinstance(best_hyps, tuple):
+                best_hyps = best_hyps[0]
+
+            for s, hyp in zip(batch_samples, best_hyps):
+                if hasattr(hyp, 'text') and hyp.text:
+                    pred = hyp.text
+                elif hasattr(hyp, 'y_sequence'):
+                    tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                    pred = model.tokenizer.ids_to_text(tids) if tids else ""
+                else:
+                    pred = str(hyp)
+
+                ref_n = normalize_text(s["text"])
+                pred_n = normalize_text(pred)
+                ref_words = ref_n.split()
+                pred_words = pred_n.split()
+                if ref_words:
+                    total_edits += simple_wer(ref_words, pred_words)
+                    total_words += len(ref_words)
+        except Exception as e:
+            errors += 1
+            if errors <= 3:
+                print(f"    [batch eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+    if errors:
+        print(f"    ({errors} batch eval errors)")
+    model.train()
+    return wer_score
+
+
+@torch.no_grad()
+def compute_val_loss(student, manifest_path, device, max_samples=500):
+    """Compute RNNT loss on validation set (no decoding, fast)."""
+    import soundfile as sf_val
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_loss = 0.0
+    count = 0
+
+    for s in samples:
+        try:
+            audio, sr = sf_val.read(s["audio_filepath"], dtype="float32")
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            text = unicodedata.normalize("NFKC", s["text"])
+            text = " ".join(text.split())
+            tokens = model.tokenizer.text_to_ids(text)
+            if not tokens:
+                continue
+
+            audio_tensor = torch.FloatTensor(audio).unsqueeze(0).to(device)
+            audio_len = torch.LongTensor([len(audio)]).to(device)
+            token_tensor = torch.LongTensor([tokens]).to(device)
+            token_len = torch.LongTensor([len(tokens)]).to(device)
+
+            mel, mel_len = model.preprocessor(input_signal=audio_tensor, length=audio_len)
+            enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+            dec_out = model.decoder(targets=token_tensor, target_length=token_len)
+            if isinstance(dec_out, tuple):
+                dec_out = dec_out[0]
+
+            if getattr(model.joint, 'fuse_loss_wer', False):
+                result = model.joint(
+                    encoder_outputs=enc, decoder_outputs=dec_out,
+                    encoder_lengths=enc_len, transcripts=token_tensor,
+                    transcript_lengths=token_len, compute_wer=False,
+                )
+                loss = result[0]
+            else:
+                joint_out = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
+                loss = model.loss(log_probs=joint_out, targets=token_tensor,
+                                  input_lengths=enc_len, target_lengths=token_len)
+
+            if loss.dim() > 0:
+                loss = loss.mean()
+            total_loss += loss.item()
+            count += 1
+        except Exception:
+            continue
+
+    model.train()
+    return total_loss / max(count, 1)
+
+
+# ═══════════════════════════════════════════════════════════
+# LR Schedule
+# ═══════════════════════════════════════════════════════════
+
+def get_cosine_schedule(optimizer, warmup_steps, total_steps, min_lr=5e-6):
+    base_lr = optimizer.defaults["lr"]
+
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return max(1e-8 / base_lr, step / max(1, warmup_steps))
+        progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+        cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
+        return max(min_lr / base_lr, cosine)
+
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+
+def get_constant_schedule(optimizer, warmup_steps):
+    base_lr = optimizer.defaults["lr"]
+
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return max(1e-8 / base_lr, step / max(1, warmup_steps))
+        return 1.0
+
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+
+# ═══════════════════════════════════════════════════════════
+# Main Training Loop
+# ═══════════════════════════════════════════════════════════
+
+def train(student, train_loader, train_sampler, val_manifest, device, args, rank,
+          is_distributed):
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    model = student.module if isinstance(student, DDP) else student
+
+    trainable_params = [p for p in student.parameters() if p.requires_grad]
+    optimizer = torch.optim.AdamW(
+        trainable_params,
+        lr=args.lr,
+        weight_decay=args.weight_decay,
+        betas=(0.9, 0.98),
+        eps=1e-9,
+    )
+
+    steps_per_epoch = len(train_loader) // args.grad_accum
+    total_steps = steps_per_epoch * args.epochs
+    warmup_steps = steps_per_epoch * args.warmup_epochs
+
+    if args.constant_lr:
+        scheduler = get_constant_schedule(optimizer, warmup_steps)
+    else:
+        scheduler = get_cosine_schedule(optimizer, warmup_steps, total_steps, args.min_lr)
+
+    scaler = torch.amp.GradScaler("cuda") if args.fp16 else None
+
+    effective_batch = args.batch_size * args.grad_accum
+    if is_distributed:
+        world_size = dist.get_world_size()
+        effective_batch *= world_size
+    else:
+        world_size = 1
+
+    print_rank0(f"\n{'='*65}", rank)
+    print_rank0(f"  Training Configuration", rank)
+    print_rank0(f"{'='*65}", rank)
+    print_rank0(f"  GPUs:               {world_size}", rank)
+    print_rank0(f"  Train samples:      {len(train_loader.dataset)}", rank)
+    print_rank0(f"  Per-GPU batch:      {args.batch_size}", rank)
+    print_rank0(f"  Effective batch:    {args.batch_size} x {args.grad_accum} x {world_size} = {effective_batch}", rank)
+    print_rank0(f"  Steps/epoch:        {steps_per_epoch}", rank)
+    print_rank0(f"  Total steps:        {total_steps}", rank)
+    print_rank0(f"  Warmup steps:       {warmup_steps}", rank)
+    print_rank0(f"  Learning rate:      {args.lr} ({'constant' if args.constant_lr else 'cosine decay'})", rank)
+    print_rank0(f"  Freeze encoder:     first {args.freeze_encoder_epochs} epochs", rank)
+    print_rank0(f"  Mixed precision:    {args.fp16}", rank)
+    print_rank0(f"{'='*65}\n", rank)
+
+    global_step = 0
+    best_wer = float("inf")
+    patience_counter = 0
+
+    import time as time_module
+
+    for epoch in range(args.epochs):
+        epoch_start = time_module.time()
+        student.train()
+
+        # Set epoch for distributed sampler (ensures different shuffling each epoch)
+        if train_sampler is not None:
+            train_sampler.set_epoch(epoch)
+
+        # Phase management
+        if epoch < args.freeze_encoder_epochs:
+            for p in model.encoder.parameters():
+                p.requires_grad = False
+            phase = f"Phase 1/{args.freeze_encoder_epochs} (encoder frozen)"
+        else:
+            for p in model.encoder.parameters():
+                p.requires_grad = True
+            phase = "Phase 2 (full training)"
+
+        # Update optimizer param groups
+        optimizer.param_groups[0]["params"] = [
+            p for p in student.parameters() if p.requires_grad
+        ]
+
+        epoch_loss = 0.0
+        epoch_steps = 0
+        epoch_grad_norm = 0.0
+        grad_norm_steps = 0
+
+        pbar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{args.epochs}",
+                    leave=True, ncols=120, disable=not is_main(rank))
+        optimizer.zero_grad()
+
+        for batch_idx, batch in enumerate(pbar):
+            if batch is None:
+                continue
+            try:
+                if scaler:
+                    with torch.amp.autocast("cuda"):
+                        loss = train_step(student, batch, device)
+                    scaled_loss = loss / args.grad_accum
+                    scaler.scale(scaled_loss).backward()
+                else:
+                    loss = train_step(student, batch, device)
+                    (loss / args.grad_accum).backward()
+
+            except RuntimeError as e:
+                if "out of memory" in str(e).lower():
+                    torch.cuda.empty_cache()
+                    print_rank0(f"\n    OOM at batch {batch_idx}, skipping", rank)
+                    optimizer.zero_grad()
+                    continue
+                raise
+
+            epoch_loss += loss.item()
+            epoch_steps += 1
+
+            if (batch_idx + 1) % args.grad_accum == 0:
+                if scaler:
+                    scaler.unscale_(optimizer)
+                trainable = [p for p in student.parameters() if p.requires_grad and p.grad is not None]
+                grad_norm = torch.nn.utils.clip_grad_norm_(trainable, 1.0).item()
+                if scaler:
+                    scaler.step(optimizer)
+                    scaler.update()
+                else:
+                    optimizer.step()
+
+                epoch_grad_norm += grad_norm
+                grad_norm_steps += 1
+                scheduler.step()
+                optimizer.zero_grad()
+                global_step += 1
+
+            if epoch_steps % args.log_every == 0 and epoch_steps > 0 and is_main(rank):
+                avg_loss = epoch_loss / epoch_steps
+                avg_gnorm = epoch_grad_norm / max(1, grad_norm_steps)
+                lr = optimizer.param_groups[0]["lr"]
+                pbar.set_postfix(loss=f"{avg_loss:.3f}", gnorm=f"{avg_gnorm:.2f}",
+                                 lr=f"{lr:.1e}", step=global_step)
+
+        # End of epoch
+        epoch_time = time_module.time() - epoch_start
+        avg_loss = epoch_loss / max(1, epoch_steps)
+        avg_gnorm = epoch_grad_norm / max(1, grad_norm_steps)
+        samples_per_sec = (epoch_steps * args.batch_size) / epoch_time
+        gpu_mem = torch.cuda.max_memory_allocated(device) / 1e9 if torch.cuda.is_available() else 0
+        print_rank0(f"\n  Epoch {epoch+1} | {phase} | loss={avg_loss:.4f} "
+                    f"grad_norm={avg_gnorm:.3f} lr={optimizer.param_groups[0]['lr']:.2e}"
+                    f" | {epoch_time/60:.1f}min | {samples_per_sec:.0f} samples/s | GPU mem: {gpu_mem:.1f}GB", rank)
+
+        # Evaluation (rank 0 only)
+        if is_main(rank) and val_manifest and (epoch + 1) % args.eval_every_epoch == 0:
+          try:
+            print_rank0(f"\n  Evaluating...", rank)
+
+            # Per-language WER (batch only) and val loss
+            lang_wers_batch = {}
+            lang_val_losses = {}
+            if args.eval_dir:
+                for lang in ['de', 'es', 'fr', 'it', 'nl']:
+                    lang_val = os.path.join(args.eval_dir, lang, 'eval', 'validation_manifest.json')
+                    if os.path.exists(lang_val):
+                        lang_wers_batch[lang] = evaluate_batch(student, lang_val, device)
+                        lang_val_losses[lang] = compute_val_loss(student, lang_val, device)
+
+            if lang_wers_batch:
+                batch_strs = [f"{l.upper()}={w:.1f}%" for l, w in lang_wers_batch.items()]
+                loss_strs = [f"{l.upper()}={v:.3f}" for l, v in lang_val_losses.items()]
+                print_rank0(f"    Batch WER:     {' | '.join(batch_strs)}", rank)
+                print_rank0(f"    Val loss:      {' | '.join(loss_strs)}", rank)
+
+            # Combined val loss + batch WER (used for best model selection)
+            val_loss = compute_val_loss(student, val_manifest, device)
+            val_wer_batch = evaluate_batch(student, val_manifest, device)
+            print_rank0(f"    Combined — Batch WER: {val_wer_batch:.2f}% | Val loss: {val_loss:.4f}", rank)
+
+            if val_wer_batch < best_wer:
+                best_wer = val_wer_batch
+                patience_counter = 0
+                save_path = os.path.join(args.output_dir, "best_model.nemo")
+                model.save_to(save_path)
+                print_rank0(f"    New best! Batch WER={best_wer:.2f}% -> {save_path}", rank)
+            else:
+                patience_counter += 1
+                print_rank0(f"    No improvement ({patience_counter}/{args.early_stop_patience})", rank)
+                if args.early_stop_patience > 0 and patience_counter >= args.early_stop_patience:
+                    print_rank0(f"\n    Early stopping! No improvement for {args.early_stop_patience} epochs.", rank)
+                    break
+          except Exception as e:
+            print_rank0(f"    [eval error] {type(e).__name__}: {e} — skipping evaluation this epoch", rank)
+
+        # Periodic checkpoint (rank 0 only)
+        if is_main(rank) and (epoch + 1) % args.save_every_epoch == 0:
+            save_path = os.path.join(args.output_dir, f"epoch_{epoch+1}.nemo")
+            model.save_to(save_path)
+            print_rank0(f"    Checkpoint -> {save_path}", rank)
+
+        # Sync all ranks before next epoch
+        if is_distributed:
+            dist.barrier()
+
+    # Final save
+    if is_main(rank):
+        save_path = os.path.join(args.output_dir, "final_model.nemo")
+        model.save_to(save_path)
+        print_rank0(f"\n  Final model -> {save_path}", rank)
+        print_rank0(f"  Best WER: {best_wer:.2f}%", rank)
+
+    return student
+
+
+# ═══════════════════════════════════════════════════════════
+# Entry Point
+# ═══════════════════════════════════════════════════════════
+
+def _seed_everything(seed, rank):
+    """Fully deterministic seeding for reproducibility (DDP-safe).
+
+    Each rank uses ``seed + rank`` so that DistributedSampler still shuffles
+    differently per worker, but the run is bit-exact reproducible given the
+    same hardware, library versions, and (rank, seed) pair.
+    """
+    seed = int(seed) + int(rank)
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def _make_worker_init_fn(base_seed, rank):
+    """DataLoader worker_init_fn: reseeds random/numpy/torch in each worker."""
+    def _init(worker_id):
+        s = int(base_seed) + int(rank) * 10_000 + int(worker_id)
+        random.seed(s)
+        np.random.seed(s)
+        torch.manual_seed(s)
+    return _init
+
+
+def main():
+    args = parse_args()
+
+    rank, world_size, local_rank, is_distributed = setup_ddp()
+    device = torch.device(f"cuda:{local_rank}")
+
+    _seed_everything(args.seed, rank)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    print_rank0(f"\n{'='*65}", rank)
+    print_rank0(f"  Nemotron Streaming ASR — Multilingual Training", rank)
+    print_rank0(f"{'='*65}", rank)
+    print_rank0(f"  GPUs:     {world_size}", rank)
+    print_rank0(f"  Student:  {args.student}", rank)
+    if args.resume_from:
+        print_rank0(f"  Resume:   {args.resume_from}", rank)
+    print_rank0(f"  Train:    {args.train_manifest}", rank)
+    print_rank0(f"{'='*65}", rank)
+
+    # Load model
+    print_rank0(f"\n[1/3] Loading model...", rank)
+    student = load_student(args, device, rank)
+
+    # Wrap in DDP
+    if is_distributed:
+        student = DDP(student, device_ids=[local_rank], find_unused_parameters=True)
+        print_rank0(f"  Wrapped in DDP (find_unused_parameters=True)", rank)
+
+    # Create dataloader
+    print_rank0(f"\n[2/3] Creating data loaders...", rank)
+    model_for_tok = student.module if isinstance(student, DDP) else student
+    train_dataset = ASRManifestDataset(
+        args.train_manifest,
+        model_for_tok.tokenizer,
+        min_duration=args.min_duration,
+        max_duration=args.max_duration,
+        speed_perturb=args.speed_perturb,
+        speed_perturb_factors=args.speed_perturb_factors,
+    )
+    print_rank0(f"  Train dataset: {len(train_dataset)} samples", rank)
+
+    train_sampler = DistributedSampler(train_dataset, shuffle=True, seed=args.seed) \
+        if is_distributed else None
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=args.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        num_workers=args.num_workers,
+        collate_fn=collate_asr,
+        pin_memory=True,
+        drop_last=True,
+        worker_init_fn=_make_worker_init_fn(args.seed, rank),
+        generator=torch.Generator().manual_seed(int(args.seed) + int(rank)),
+    )
+
+    # Train
+    print_rank0(f"\n[3/3] Starting training...", rank)
+    student = train(
+        student, train_loader, train_sampler,
+        args.val_manifest, device, args, rank, is_distributed,
+    )
+
+    # Final eval (batch only — run streaming eval separately on best model)
+    if is_main(rank):
+        print_rank0(f"\n{'='*65}", rank)
+        print_rank0(f"  Final Evaluation (Batch WER)", rank)
+        print_rank0(f"{'='*65}", rank)
+        if args.eval_dir:
+            for lang in ['de', 'es', 'fr', 'it', 'nl']:
+                lang_val = os.path.join(args.eval_dir, lang, 'eval', 'validation_manifest.json')
+                if os.path.exists(lang_val):
+                    b_wer = evaluate_batch(student, lang_val, device)
+                    print_rank0(f"  {lang.upper()} — Batch WER: {b_wer:.2f}%", rank)
+        if args.val_manifest:
+            b_wer = evaluate_batch(student, args.val_manifest, device)
+            print_rank0(f"  Combined — Batch WER: {b_wer:.2f}%", rank)
+
+    cleanup_ddp(is_distributed)
+
+
+if __name__ == "__main__":
+    main()

train_single_lang.py

@@ -0,0 +1,1858 @@
+#!/usr/bin/env python3
+"""
+train_single_lang.py
+
+Single-language fine-tuning of Nemotron-Speech-Streaming.
+Adapted from train_multilingual_nemotron.py for per-language training.
+
+This script is the entry point for every (language, hours, init) cell of
+the main grid in the paper.  The init arm is selected by the combination
+of --resume_from and --encoder_from / --reinit_encoder; the multilingual
+tokenizer, decoder and joint always come from the multilingual base.
+
+  ML init (paper's "ML" arm)
+      --resume_from <multilingual_base.nemo>
+      Encoder, decoder, joint and tokenizer all come from the multilingual
+      base checkpoint.
+
+  EN init (paper's "EN" arm)
+      --resume_from <multilingual_base.nemo>
+      --encoder_from nvidia/nemotron-speech-streaming-en-0.6b
+      The decoder, joint and tokenizer are kept from the multilingual base
+      (so the comparison isolates the encoder), and the encoder weights are
+      overwritten layer-for-layer with the English-only Nemotron encoder.
+
+  Random-encoder ablation (NOT the paper's EN arm)
+      --resume_from <multilingual_base.nemo>
+      --reinit_encoder
+      Same as ML init except the encoder is freshly random-initialized.
+
+  Direct from English checkpoint (legacy / not used in the main grid)
+      --student nvidia/nemotron-speech-streaming-en-0.6b
+      No --resume_from.  Everything (encoder, decoder, joint, tokenizer) is
+      taken from the English checkpoint and only the prediction-network
+      output layer is resized to the target tokenizer.
+
+Example usage (paper ML init for German, 100 h):
+  torchrun --nproc_per_node=1 train_single_lang.py \
+    --lang de \
+    --resume_from   <CKPT_DIR>/multilingual_base.nemo \
+    --train_manifest <DATA_ROOT>/de/100h/train.jsonl \
+    --val_manifest   <VAL_MANIFEST> \
+    --output_dir ./out/de_100h_ml \
+    --epochs 30 --batch_size 16 --grad_accum 3 --lr 1e-4 \
+    --early_stop_patience 8 --decay_spec_augment --seed 42
+
+Example usage (paper EN init for the same cell):
+  torchrun --nproc_per_node=1 train_single_lang.py \
+    --lang de \
+    --resume_from   <CKPT_DIR>/multilingual_base.nemo \
+    --encoder_from  nvidia/nemotron-speech-streaming-en-0.6b \
+    --train_manifest <DATA_ROOT>/de/100h/train.jsonl \
+    --val_manifest   <VAL_MANIFEST> \
+    --output_dir ./out/de_100h_en \
+    --epochs 30 --batch_size 16 --grad_accum 3 --lr 1e-4 \
+    --early_stop_patience 8 --decay_spec_augment --seed 42
+
+Manifest format (one JSON object per line):
+  {"audio_filepath": "/abs/path/utt.wav", "duration": 8.4, "text": "reference transcript"}
+  `duration` (seconds) is required: it drives min/max-duration filtering and
+  the --max_train_hours subsampling.
+
+Requirements:
+  pip install nemo_toolkit[asr] soundfile jiwer tqdm
+  Evaluation also requires Whisper's BasicMultilingualTextNormalizer from the
+  Open ASR Leaderboard repo (clone https://github.com/huggingface/open_asr_leaderboard
+  and add it to PYTHONPATH).
+"""
+
+import argparse
+import json
+import math
+import os
+import gc
+import re
+import sys
+import unicodedata
+from collections import defaultdict
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader, DistributedSampler
+from tqdm import tqdm
+
+# Use Whisper's BasicMultilingualTextNormalizer for consistent eval
+try:
+    from normalizer import BasicMultilingualTextNormalizer
+    _ml_normalizer = BasicMultilingualTextNormalizer()
+    _has_real_normalizer = True
+except ImportError:
+    print(
+        "ERROR: could not import BasicMultilingualTextNormalizer. "
+        "This script requires Whisper's BasicMultilingualTextNormalizer, "
+        "shipped in the Open ASR Leaderboard repo. "
+        "Clone https://github.com/huggingface/open_asr_leaderboard and add it "
+        "to PYTHONPATH (or set OPEN_ASR_LB_ROOT).",
+        file=sys.stderr,
+    )
+    exit(1)
+    _ml_normalizer = None
+    _has_real_normalizer = False
+
+
+# ═══════════════════════════════════════════════════════════
+# DDP Utilities
+# ═══════════════════════════════════════════════════════════
+
+def setup_ddp():
+    """Initialize distributed training. Returns (rank, world_size, local_rank, is_distributed)."""
+    if "RANK" in os.environ:
+        rank = int(os.environ["RANK"])
+        world_size = int(os.environ["WORLD_SIZE"])
+        local_rank = int(os.environ["LOCAL_RANK"])
+        from datetime import timedelta
+        dist.init_process_group("nccl", timeout=timedelta(minutes=60))
+        torch.cuda.set_device(local_rank)
+        return rank, world_size, local_rank, True
+    else:
+        return 0, 1, 0, False
+
+
+def cleanup_ddp(is_distributed):
+    if is_distributed:
+        dist.destroy_process_group()
+
+
+def is_main(rank):
+    return rank == 0
+
+
+def print_rank0(msg, rank=0):
+    if is_main(rank):
+        print(msg, flush=True)
+
+
+# ═══════════════════════════════════════════════════════════
+# Configuration
+# ═══════════════════════════════════════════════════════════
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        description="Single-language Nemotron Streaming ASR Training",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    # Language
+    p.add_argument("--lang", type=str, required=True,
+                   help="Language code (e.g., de, es, fr, it, nl, sv, pt, pl)")
+
+    # Models
+    p.add_argument("--teacher", default="nvidia/parakeet-tdt-0.6b-v3",
+                   help="Teacher model for tokenizer extraction")
+    p.add_argument("--student", default="nvidia/nemotron-speech-streaming-en-0.6b",
+                   help="Student model (English, streaming)")
+
+    # Data
+    p.add_argument("--train_manifest", type=str, required=True,
+                   help="Path to training manifest (JSONL)")
+    p.add_argument("--val_manifest", type=str, required=True,
+                   help="Path to validation manifest (JSONL)")
+
+    # Training
+    p.add_argument("--output_dir", default="./nemotron_lang")
+    p.add_argument("--epochs", type=int, default=30)
+    p.add_argument("--batch_size", type=int, default=16,
+                   help="Per-GPU batch size")
+    p.add_argument("--grad_accum", type=int, default=2,
+                   help="Gradient accumulation steps")
+    p.add_argument("--lr", type=float, default=1e-4)
+    p.add_argument("--min_lr", type=float, default=1e-6)
+    p.add_argument("--weight_decay", type=float, default=1e-3)
+    p.add_argument("--warmup_epochs", type=int, default=1)
+    p.add_argument("--max_duration", type=float, default=20.0)
+    p.add_argument("--min_duration", type=float, default=0.3)
+
+    # SpecAugment
+    p.add_argument("--no_spec_augment", action="store_true", default=False)
+    p.add_argument("--freq_masks", type=int, default=2)
+    p.add_argument("--freq_width", type=int, default=27)
+    p.add_argument("--time_masks", type=int, default=10)
+    p.add_argument("--time_width", type=float, default=0.05)
+
+    # Speed perturbation
+    p.add_argument("--speed_perturb", action="store_true", default=True)
+    p.add_argument("--speed_perturb_factors", type=float, nargs='+', default=[0.9, 1.0, 1.1])
+
+    # Misc
+    p.add_argument("--freeze_encoder_epochs", type=int, default=0,
+                   help="Freeze encoder for first N epochs")
+    p.add_argument("--reinit_encoder", action="store_true", default=False,
+                   help="Randomly reinitialize all encoder weights (ablation). "
+                        "NOT the paper's EN arm -- EN init uses --encoder_from "
+                        "to copy the English encoder weights, not random init.")
+    p.add_argument("--reinit_joint", action="store_true", default=False,
+                   help="Randomly reinitialize the RNNT joint network weights (ablation study). "
+                        "Useful after swapping encoders so the joint relearns the encoder->vocab mapping.")
+    p.add_argument("--lr_decay_epochs", type=int, default=25,
+                   help="Cosine decay reaches min_lr after N epochs (0=use total epochs)")
+    p.add_argument("--constant_lr", action="store_true", default=False)
+    p.add_argument("--log_every", type=int, default=50)
+    p.add_argument("--eval_every_epoch", type=int, default=1)
+    p.add_argument("--save_every_epoch", type=int, default=0,
+                   help="Save training state every N epochs (0=disabled)")
+    p.add_argument("--early_stop_patience", type=int, default=30,
+                   help="Stop if WER doesn't improve for N evals (0=disabled)")
+    p.add_argument("--grad_clip", type=float, default=1.0,
+                   help="Gradient clipping max norm")
+    p.add_argument("--rnnt_clamp", type=float, default=-1.0,
+                   help="RNNT loss per-frame clamping value (-1=disabled, 1.0=recommended)")
+    p.add_argument("--bf16", action="store_true", default=True)
+    p.add_argument("--fp16", action="store_true", default=False)
+    p.add_argument("--num_workers", type=int, default=4)
+    p.add_argument("--max_train_hours", type=float, default=0,
+                   help="Limit training data to N hours (0=use all data). Samples randomly.")
+    p.add_argument("--data_seed", type=int, default=12345,
+                   help="Seed for data subsampling (separate from training seed for reproducibility)")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--resume_from", type=str, default=None,
+                   help="Resume from .nemo checkpoint (the multilingual base for both "
+                        "the ML and EN arms of the paper's main grid). Sets the "
+                        "tokenizer, decoder and joint; the encoder is then either kept "
+                        "(ML arm), overwritten via --encoder_from (EN arm), or "
+                        "re-initialized via --reinit_encoder (ablation).")
+    p.add_argument("--encoder_from", type=str, default=None,
+                   help="Overwrite encoder weights with those of this checkpoint after "
+                        "--resume_from has loaded the multilingual base. This is how "
+                        "the paper's EN arm is built: multilingual tokenizer/decoder/joint "
+                        "+ English encoder (nvidia/nemotron-speech-streaming-en-0.6b).")
+    p.add_argument("--swap_joint_enc", action="store_true", default=False,
+                   help="When using --encoder_from, also copy the joint network's encoder projection (enc linear + enc_hat) from the source model. Keeps encoder and joint.enc in sync.")
+    p.add_argument("--encoder_from_layers", type=str, default="all",
+                   help="Which Conformer layer indices to copy from --encoder_from. "
+                        "Examples: 'all' (default, full encoder), 'none' (skip layers, only use preencode/postnorm flags), "
+                        "'0:8' (Python slice, layers 0..7), '-8:' (last 8 layers), '0:8,16:24' (multiple ranges). "
+                        "Negative indices count from the end. Layers outside the slice stay from --resume_from/--student.")
+    p.add_argument("--encoder_from_preencode", type=str, default="off", choices=["auto", "on", "off"],
+                   help="Copy the pre-encoder subsampling (conv frontend) and positional embeddings from --encoder_from. "
+                        "Default 'off' keeps the destination model's preencode (ML baseline when --resume_from is set), "
+                        "which is preferable for cross-lingual splices since the ML preencode has seen the target language. "
+                        "'auto': on iff layer 0 is in --encoder_from_layers.")
+    p.add_argument("--encoder_from_postnorm", type=str, default="off", choices=["auto", "on", "off"],
+                   help="Copy the final encoder norm/output projection from --encoder_from. "
+                        "Default 'off' keeps the destination model's postnorm (ML baseline when --resume_from is set), "
+                        "which is the natural pairing when the top layers also come from the destination. "
+                        "'auto': on iff the last layer is in --encoder_from_layers.")
+    p.add_argument("--decay_spec_augment", action="store_true", default=False,
+                   help="Linearly decay SpecAugment mask counts over training (time_masks: N->2, freq_masks: N->1)")
+    p.add_argument("--resume_training", type=str, default=None,
+                   help="Resume training from a training_state.pt checkpoint (saved in output_dir). Restores optimizer, scheduler, epoch, and all training state.")
+    p.add_argument("--confidence_penalty", type=float, default=0.0,
+                   help="Entropy regularization weight (0=off). Penalizes overconfident joint predictions. Try 0.1-0.3.")
+    p.add_argument("--streaming_chunk_sec", type=float, default=0,
+                   help="Enable chunk-aware streaming training. Chunk duration in seconds (e.g., 1.2). 0=full context training.")
+    p.add_argument("--test_manifest", type=str, default=None,
+                   help="Path to test manifest (JSONL) for final evaluation")
+    p.add_argument("--decoder_hidden", type=int, default=0,
+                   help="Override RNNT decoder (prediction network) LSTM hidden size. 0=keep original (640). E.g., 860, 1024.")
+    p.add_argument("--decoder_layers", type=int, default=0,
+                   help="Override RNNT decoder LSTM layer count. 0=keep original (2). E.g., 3, 4.")
+
+    return p.parse_args()
+
+
+# ═══════════════════════════════════════════════════════════
+# Tokenizer Extraction (from teacher)
+# ═══════════════════════════════════════════════════════════
+
+def extract_tokenizer(model, tokenizer_dir):
+    """Extract tokenizer .model file from a NeMo ASR model."""
+    from pathlib import Path
+
+    os.makedirs(tokenizer_dir, exist_ok=True)
+    out_model = Path(tokenizer_dir) / "tokenizer.model"
+
+    tok = getattr(model, "tokenizer", None)
+    sp = getattr(tok, "tokenizer", None)
+
+    if sp is not None and hasattr(sp, "serialized_model_proto"):
+        blob = sp.serialized_model_proto()
+        if blob:
+            out_model.write_bytes(blob)
+            _generate_vocab_txt(tokenizer_dir)
+            vs = getattr(sp, "vocab_size", None)
+            if callable(vs):
+                vs = vs()
+            return str(Path(tokenizer_dir)), int(vs) if vs else 0
+
+    raise RuntimeError("Could not extract tokenizer from teacher model")
+
+
+def _generate_vocab_txt(tokenizer_dir):
+    import sentencepiece as spm_lib
+    model_path = os.path.join(tokenizer_dir, "tokenizer.model")
+    vocab_path = os.path.join(tokenizer_dir, "vocab.txt")
+    if os.path.exists(vocab_path):
+        return
+    sp = spm_lib.SentencePieceProcessor()
+    sp.load(model_path)
+    with open(vocab_path, "w", encoding="utf-8") as f:
+        for i in range(sp.get_piece_size()):
+            f.write(sp.id_to_piece(i) + "\n")
+
+
+# ═══════════════════════════════════════════════════════════
+# Model Setup
+# ═══════════════════════════════════════════════════════════
+
+def setup_spec_augment(student, args):
+    from nemo.collections.asr.modules.audio_preprocessing import SpectrogramAugmentation
+
+    if args.no_spec_augment:
+        student.spec_augmentation = None
+        return
+
+    spec_aug = SpectrogramAugmentation(
+        freq_masks=args.freq_masks,
+        time_masks=args.time_masks,
+        freq_width=args.freq_width,
+        time_width=args.time_width,
+    )
+    student.spec_augmentation = spec_aug.to(next(student.parameters()).device)
+
+
+def update_spec_augment(student, args, epoch, total_epochs, rank):
+    """Linearly decay SpecAugment mask counts over training."""
+    if not args.decay_spec_augment or args.no_spec_augment:
+        return
+    from nemo.collections.asr.modules.audio_preprocessing import SpectrogramAugmentation
+
+    progress = epoch / max(1, total_epochs - 1)
+    new_time_masks = max(2, round(args.time_masks * (1 - progress)))
+    new_freq_masks = max(1, round(args.freq_masks * (1 - 0.5 * progress)))
+
+    model = student.module if isinstance(student, DDP) else student
+    spec_aug = SpectrogramAugmentation(
+        freq_masks=new_freq_masks,
+        time_masks=new_time_masks,
+        freq_width=args.freq_width,
+        time_width=args.time_width,
+    )
+    model.spec_augmentation = spec_aug.to(next(model.parameters()).device)
+    print_rank0(f"    SpecAug decay: freq={new_freq_masks}x{args.freq_width} time={new_time_masks}x{args.time_width}", rank)
+
+    from omegaconf import open_dict
+    with open_dict(model.cfg):
+        model.cfg.spec_augment.freq_masks = new_freq_masks
+        model.cfg.spec_augment.time_masks = new_time_masks
+        model.cfg.spec_augment.freq_width = args.freq_width
+        model.cfg.spec_augment.time_width = args.time_width
+
+
+def _parse_layer_slice(spec, num_layers):
+    """Parse a slice spec like 'all', 'none', '0:8', '-8:', '0:8,16:24' into a sorted set of indices.
+
+    Supports Python-style slice ranges, comma-separated. Negative indices count from num_layers.
+    Returns a set of ints in [0, num_layers).
+    """
+    if spec is None:
+        return set()
+    s = spec.strip().lower()
+    if s in ("all", "*"):
+        return set(range(num_layers))
+    if s in ("none", ""):
+        return set()
+    out = set()
+    for part in s.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if ":" in part:
+            lo_s, hi_s = part.split(":", 1)
+            lo = int(lo_s) if lo_s else 0
+            hi = int(hi_s) if hi_s else num_layers
+            if lo < 0:
+                lo += num_layers
+            if hi < 0:
+                hi += num_layers
+            lo = max(0, min(num_layers, lo))
+            hi = max(0, min(num_layers, hi))
+            out.update(range(lo, hi))
+        else:
+            idx = int(part)
+            if idx < 0:
+                idx += num_layers
+            if 0 <= idx < num_layers:
+                out.add(idx)
+    return out
+
+
+def _splice_encoder(dst_encoder, src_encoder, layer_indices, include_preencode, include_postnorm, rank):
+    """Merge src_encoder weights into dst_encoder for the given layer indices, plus optional
+    preencode (subsampling + positional encoding) and postnorm modules.
+
+    Layer keys are expected to start with 'layers.<i>.'. Everything else is treated as
+    'preencode-like' if its name matches pre_encode/pos_enc/embedding, or 'postnorm-like' otherwise.
+    """
+    src_sd = src_encoder.state_dict()
+    dst_sd = dst_encoder.state_dict()
+
+    PREENC_PREFIXES = ("pre_encode", "pos_enc", "pos_embedding", "pos_embed", "embedding")
+
+    copied_layers = set()
+    copied_pre = []
+    copied_post = []
+    skipped_shape = []
+    skipped_missing = []
+
+    for k, v in src_sd.items():
+        if k.startswith("layers."):
+            try:
+                idx = int(k.split(".", 2)[1])
+            except (ValueError, IndexError):
+                continue
+            if idx not in layer_indices:
+                continue
+            target_key = k
+            bucket = ("layer", idx)
+        elif any(k.startswith(p) for p in PREENC_PREFIXES):
+            if not include_preencode:
+                continue
+            target_key = k
+            bucket = ("pre", k)
+        else:
+            if not include_postnorm:
+                continue
+            target_key = k
+            bucket = ("post", k)
+
+        if target_key not in dst_sd:
+            skipped_missing.append(target_key)
+            continue
+        if dst_sd[target_key].shape != v.shape:
+            skipped_shape.append((target_key, tuple(v.shape), tuple(dst_sd[target_key].shape)))
+            continue
+
+        dst_sd[target_key] = v
+        if bucket[0] == "layer":
+            copied_layers.add(bucket[1])
+        elif bucket[0] == "pre":
+            copied_pre.append(target_key)
+        else:
+            copied_post.append(target_key)
+
+    missing, unexpected = dst_encoder.load_state_dict(dst_sd, strict=False)
+    print_rank0(
+        f"  Encoder splice: copied layers {sorted(copied_layers)} "
+        f"({len(copied_layers)} of {len(layer_indices)} requested)", rank
+    )
+    if copied_pre:
+        print_rank0(f"  Encoder splice: copied {len(copied_pre)} preencode keys", rank)
+    if copied_post:
+        print_rank0(f"  Encoder splice: copied {len(copied_post)} postnorm/other keys", rank)
+    if skipped_shape:
+        print_rank0(f"  WARNING: skipped {len(skipped_shape)} keys due to shape mismatch (first: {skipped_shape[0]})", rank)
+    if skipped_missing:
+        print_rank0(f"  WARNING: skipped {len(skipped_missing)} keys missing in dst encoder (first: {skipped_missing[0]})", rank)
+
+
+def load_student(args, device, rank):
+    """Load student model, optionally swap tokenizer."""
+    import nemo.collections.asr as nemo_asr
+
+    if args.resume_from:
+        print_rank0(f"  Resuming from: {args.resume_from}", rank)
+        student = nemo_asr.models.ASRModel.restore_from(args.resume_from, map_location='cpu')
+        print_rank0(f"  Vocab: {student.tokenizer.vocab_size} tokens", rank)
+        args.freeze_encoder_epochs = 0
+
+        # Optionally override encoder weights from a different model (e.g., English)
+        if args.encoder_from:
+            print_rank0(f"  Loading encoder from: {args.encoder_from}", rank)
+            if args.encoder_from.endswith('.nemo'):
+                encoder_model = nemo_asr.models.ASRModel.restore_from(args.encoder_from, map_location='cpu')
+            else:
+                encoder_model = nemo_asr.models.ASRModel.from_pretrained(args.encoder_from, map_location='cpu')
+
+            # Determine number of Conformer layers from the source encoder
+            src_layers_attr = getattr(encoder_model.encoder, "layers", None)
+            num_layers = len(src_layers_attr) if src_layers_attr is not None else 0
+            dst_layers_attr = getattr(student.encoder, "layers", None)
+            dst_num_layers = len(dst_layers_attr) if dst_layers_attr is not None else 0
+            if num_layers == 0 or dst_num_layers == 0:
+                raise RuntimeError(
+                    f"Could not locate '.encoder.layers' on src ({num_layers}) or dst ({dst_num_layers}); "
+                    f"layer splicing requires a Conformer-style encoder with .layers nn.ModuleList."
+                )
+            if num_layers != dst_num_layers:
+                print_rank0(
+                    f"  WARNING: src encoder has {num_layers} layers but dst has {dst_num_layers}; "
+                    f"only layers present in both will be copied.", rank
+                )
+
+            spec = args.encoder_from_layers or "all"
+            effective_layers = min(num_layers, dst_num_layers)
+            layer_indices = _parse_layer_slice(spec, effective_layers)
+
+            # Auto-detect: preencode if EN provides layer 0; postnorm if EN provides last layer.
+            auto_preencode = 0 in layer_indices
+            auto_postnorm = (effective_layers - 1) in layer_indices
+
+            def _resolve(flag, auto_value, name):
+                if flag == "on":
+                    return True
+                if flag == "off":
+                    return False
+                return auto_value  # "auto"
+
+            include_preencode = _resolve(args.encoder_from_preencode, auto_preencode, "preencode")
+            include_postnorm = _resolve(args.encoder_from_postnorm, auto_postnorm, "postnorm")
+
+            # Fast path: entire encoder copied (all layers + both boundaries) -> direct load_state_dict.
+            full_copy = (
+                len(layer_indices) == effective_layers
+                and include_preencode
+                and include_postnorm
+                and num_layers == dst_num_layers
+            )
+            if full_copy:
+                student.encoder.load_state_dict(encoder_model.encoder.state_dict())
+                enc_params = sum(p.numel() for p in student.encoder.parameters()) / 1e6
+                print_rank0(f"  Encoder fully swapped: {enc_params:.1f}M params from {args.encoder_from}", rank)
+            else:
+                print_rank0(
+                    f"  Encoder splice spec='{spec}' ({len(layer_indices)}/{effective_layers} layers); "
+                    f"preencode={include_preencode} ({args.encoder_from_preencode}"
+                    f"{' -> auto=' + str(auto_preencode) if args.encoder_from_preencode == 'auto' else ''}), "
+                    f"postnorm={include_postnorm} ({args.encoder_from_postnorm}"
+                    f"{' -> auto=' + str(auto_postnorm) if args.encoder_from_postnorm == 'auto' else ''})", rank
+                )
+                _splice_encoder(
+                    student.encoder,
+                    encoder_model.encoder,
+                    layer_indices,
+                    include_preencode=include_preencode,
+                    include_postnorm=include_postnorm,
+                    rank=rank,
+                )
+
+            # Optionally also swap the joint network's encoder-side projection
+            if args.swap_joint_enc:
+                swapped_keys = []
+                src_joint_sd = encoder_model.joint.state_dict()
+                dst_joint_sd = student.joint.state_dict()
+                for key in src_joint_sd:
+                    # Match encoder-side projection layers (enc, enc_hat, etc.)
+                    if 'enc' in key and key in dst_joint_sd and src_joint_sd[key].shape == dst_joint_sd[key].shape:
+                        dst_joint_sd[key] = src_joint_sd[key]
+                        swapped_keys.append(key)
+                if swapped_keys:
+                    student.joint.load_state_dict(dst_joint_sd)
+                    print_rank0(f"  Joint encoder projection swapped: {swapped_keys}", rank)
+                else:
+                    print_rank0(f"  WARNING: --swap_joint_enc set but no matching joint.enc keys found", rank)
+
+            del encoder_model
+    else:
+        # Extract teacher tokenizer (only rank 0 does this, then all read from disk)
+        tokenizer_dir = os.path.join(args.output_dir, "teacher_tokenizer")
+        if is_main(rank):
+            print_rank0(f"  Loading teacher for tokenizer: {args.teacher}", rank)
+            teacher = nemo_asr.models.ASRModel.from_pretrained(args.teacher)
+            tokenizer_dir, teacher_vocab_size = extract_tokenizer(teacher, tokenizer_dir)
+            print_rank0(f"  Teacher vocab: {teacher_vocab_size}", rank)
+            del teacher
+            torch.cuda.empty_cache()
+
+        if dist.is_initialized():
+            dist.barrier()
+
+        # Load student
+        print_rank0(f"  Loading student: {args.student}", rank)
+        student = nemo_asr.models.ASRModel.from_pretrained(args.student)
+
+        old_vocab = student.tokenizer.vocab_size
+        student.change_vocabulary(new_tokenizer_dir=tokenizer_dir, new_tokenizer_type="bpe")
+        new_vocab = student.tokenizer.vocab_size
+        print_rank0(f"  Tokenizer swap: {old_vocab} → {new_vocab}", rank)
+
+    # Optionally resize decoder (prediction network)
+    if args.decoder_hidden > 0 or args.decoder_layers > 0:
+        from omegaconf import open_dict, OmegaConf
+        old_hidden = student.cfg.decoder.prednet.pred_hidden
+        old_layers = student.cfg.decoder.prednet.pred_rnn_layers
+        new_hidden = args.decoder_hidden if args.decoder_hidden > 0 else old_hidden
+        new_layers = args.decoder_layers if args.decoder_layers > 0 else old_layers
+
+        with open_dict(student.cfg):
+            student.cfg.decoder.prednet.pred_hidden = new_hidden
+            student.cfg.decoder.prednet.pred_rnn_layers = new_layers
+
+        # Rebuild decoder + joint with new dimensions
+        from nemo.collections.asr.modules import RNNTDecoder, RNNTJoint
+        student.decoder = RNNTDecoder(
+            prednet=OmegaConf.to_container(student.cfg.decoder.prednet, resolve=True),
+            vocab_size=student.tokenizer.vocab_size,
+            normalization_mode=student.cfg.decoder.get('normalization_mode', None),
+            random_state_sampling=student.cfg.decoder.get('random_state_sampling', False),
+            blank_as_pad=student.cfg.decoder.get('blank_as_pad', True),
+        )
+
+        # Rebuild joint network to match new decoder hidden
+        with open_dict(student.cfg):
+            student.cfg.joint.jointnet.pred_hidden = new_hidden
+            student.cfg.joint.jointnet.encoder_hidden = student.cfg.encoder.d_model
+            student.cfg.joint.num_classes = student.tokenizer.vocab_size
+        joint_cfg = OmegaConf.to_container(student.cfg.joint, resolve=True)
+        joint_cfg.pop('_target_', None)
+        joint_cfg.pop('vocabulary', None)
+        student.joint = RNNTJoint(**joint_cfg)
+
+        dec_params = sum(p.numel() for p in student.decoder.parameters()) / 1e6
+        joint_params = sum(p.numel() for p in student.joint.parameters()) / 1e6
+        print_rank0(f"  Decoder resized: hidden {old_hidden}->{new_hidden}, layers {old_layers}->{new_layers}", rank)
+        print_rank0(f"  New decoder params: {dec_params:.1f}M, joint params: {joint_params:.1f}M", rank)
+
+    student = student.to(device)
+
+    # Optionally reinitialize encoder weights (ablation study)
+    if args.reinit_encoder:
+        print_rank0("  REINITIALIZING ENCODER WEIGHTS (random init)", rank)
+        for name, param in student.encoder.named_parameters():
+            if param.dim() >= 2:
+                torch.nn.init.xavier_uniform_(param)
+            else:
+                torch.nn.init.zeros_(param)
+        # Also reinit batch norm running stats
+        for module in student.encoder.modules():
+            if isinstance(module, (torch.nn.BatchNorm1d, torch.nn.BatchNorm2d)):
+                module.reset_running_stats()
+        enc_params = sum(p.numel() for p in student.encoder.parameters())
+        print_rank0(f"  Reinitialized {enc_params/1e6:.1f}M encoder parameters", rank)
+
+    # Optionally reinitialize joint network weights (ablation study)
+    if args.reinit_joint:
+        print_rank0("  REINITIALIZING JOINT NETWORK WEIGHTS (random init)", rank)
+        # Re-seed RNG with a fixed value so ML and EN arms get IDENTICAL joint init
+        # (independent of prior RNG state consumed by different checkpoint loads).
+        # Using args.seed (not args.seed+rank) ensures same init across DDP ranks too.
+        _joint_seed = args.seed
+        _gen_state_cpu = torch.random.get_rng_state()
+        _gen_state_cuda = torch.cuda.get_rng_state_all() if torch.cuda.is_available() else None
+        torch.manual_seed(_joint_seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(_joint_seed)
+        print_rank0(f"  Joint reinit RNG seeded with {_joint_seed} (identical across ML/EN arms)", rank)
+        for name, param in student.joint.named_parameters():
+            if param.dim() >= 2:
+                torch.nn.init.xavier_uniform_(param)
+            else:
+                torch.nn.init.zeros_(param)
+        for module in student.joint.modules():
+            if isinstance(module, (torch.nn.BatchNorm1d, torch.nn.BatchNorm2d)):
+                module.reset_running_stats()
+        # Restore prior RNG state so training stochasticity is unaffected
+        torch.random.set_rng_state(_gen_state_cpu)
+        if _gen_state_cuda is not None:
+            torch.cuda.set_rng_state_all(_gen_state_cuda)
+        joint_params = sum(p.numel() for p in student.joint.parameters())
+        print_rank0(f"  Reinitialized {joint_params/1e6:.1f}M joint parameters", rank)
+
+    # SpecAugment
+    setup_spec_augment(student, args)
+
+    # Streaming chunk-aware training: restrict attention context
+    if args.streaming_chunk_sec > 0:
+        # Force single attention context mode [70, 13] instead of random multi-context
+        # Default model has 4 modes: [70,13], [70,6], [70,1], [70,0] sampled randomly
+        # This forces always using [70, 13] (largest context, lowest latency mode)
+        student.encoder.att_context_size = [70, 13]
+        student.encoder.att_context_size_all = [[70, 13]]
+        student.encoder.att_context_probs = [1.0]
+        print_rank0(f"  Streaming training: forced att_context=[70,13] only (no multi-context)", rank)
+
+    # Disable CUDA graphs and typecheck
+    from omegaconf import open_dict
+    from nemo.core.classes.common import typecheck
+    typecheck.set_typecheck_enabled(False)
+    with open_dict(student.cfg):
+        student.cfg.decoding.greedy.use_cuda_graph_decoder = False
+    student.change_decoding_strategy(student.cfg.decoding)
+
+    # Override RNNT loss clamping if requested
+    if args.rnnt_clamp > 0:
+        from nemo.collections.asr.losses.rnnt import RNNTLoss
+        with open_dict(student.cfg):
+            student.cfg.loss.warprnnt_numba_kwargs.clamp = args.rnnt_clamp
+        student.loss = RNNTLoss(num_classes=student.decoder.vocab_size, loss_name='default',
+                                loss_kwargs=dict(student.cfg.loss.warprnnt_numba_kwargs))
+        print_rank0(f"  RNNT loss clamping: {args.rnnt_clamp}", rank)
+
+    params = sum(p.numel() for p in student.parameters()) / 1e6
+    print_rank0(f"  Student params: {params:.1f}M", rank)
+
+    return student
+
+
+# ═══════════════════════════════════════════════════════════
+# Dataset & DataLoader
+# ═══════════════════════════════════════════════════════════
+
+class ASRManifestDataset(torch.utils.data.Dataset):
+    def __init__(self, manifest_path, tokenizer, min_duration=0.3, max_duration=20.0,
+                 speed_perturb=False, speed_perturb_factors=None,
+                 max_train_hours=0, seed=42):
+        self.tokenizer = tokenizer
+        self.speed_perturb = speed_perturb
+        self.speed_perturb_factors = speed_perturb_factors or [0.9, 1.0, 1.1]
+        self.samples = []
+
+        with open(manifest_path) as f:
+            for line in f:
+                item = json.loads(line)
+                dur = item["duration"]
+                if min_duration <= dur <= max_duration:
+                    self.samples.append(item)
+
+        # Subsample to max_train_hours if specified
+        if max_train_hours > 0:
+            target_seconds = max_train_hours * 3600
+            rng = np.random.RandomState(seed)
+            rng.shuffle(self.samples)
+            selected = []
+            total_dur = 0.0
+            for s in self.samples:
+                if total_dur >= target_seconds:
+                    break
+                selected.append(s)
+                total_dur += s["duration"]
+            self.samples = selected
+            self.total_hours = total_dur / 3600
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        import soundfile as sf
+        item = self.samples[idx]
+        try:
+            audio, sr = sf.read(item["audio_filepath"], dtype="float32")
+        except Exception as e:
+            print(f"    Corrupt audio: {item['audio_filepath']} ({e})", flush=True)
+            return None
+
+        if sr != 16000:
+            ratio = 16000 / sr
+            new_len = int(len(audio) * ratio)
+            audio = np.interp(
+                np.linspace(0, len(audio) - 1, new_len),
+                np.arange(len(audio)), audio,
+            ).astype(np.float32)
+
+        # Speed perturbation
+        if self.speed_perturb:
+            import random
+            speed = random.choice(self.speed_perturb_factors)
+            if speed != 1.0:
+                new_len = int(len(audio) / speed)
+                audio = np.interp(
+                    np.linspace(0, len(audio) - 1, new_len),
+                    np.arange(len(audio)), audio,
+                ).astype(np.float32)
+
+        audio_tensor = torch.FloatTensor(audio)
+
+        text = unicodedata.normalize("NFKC", item["text"])
+        text = " ".join(text.split())
+        tokens = torch.LongTensor(self.tokenizer.text_to_ids(text))
+
+        return audio_tensor, tokens
+
+
+def collate_asr(batch):
+    batch = [b for b in batch if b is not None]
+    if len(batch) == 0:
+        return None
+    audios = [b[0] for b in batch]
+    tokens_list = [b[1] for b in batch]
+
+    audio_lens = torch.LongTensor([len(a) for a in audios])
+    token_lens = torch.LongTensor([len(t) for t in tokens_list])
+
+    max_audio = audio_lens.max().item()
+    max_tokens = token_lens.max().item()
+    B = len(audios)
+
+    padded_audio = torch.zeros(B, max_audio)
+    padded_tokens = torch.zeros(B, max_tokens, dtype=torch.long)
+
+    for i in range(B):
+        padded_audio[i, :audio_lens[i]] = audios[i]
+        padded_tokens[i, :token_lens[i]] = tokens_list[i]
+
+    return padded_audio, audio_lens, padded_tokens, token_lens
+
+
+# ═══════════════════════════════════════════════════════════
+# Training Step
+# ═══════════════════════════════════════════════════════════
+
+def train_step(student, batch, device, confidence_penalty=0.0):
+    """Single forward/backward step: RNNT loss + optional entropy regularization."""
+    audio, audio_len, tokens, token_len = batch
+    audio = audio.to(device)
+    audio_len = audio_len.to(device)
+    tokens = tokens.to(device)
+    token_len = token_len.to(device)
+
+    model = student.module if isinstance(student, DDP) else student
+
+    # Mel spectrogram
+    mel, mel_len = model.preprocessor(input_signal=audio, length=audio_len)
+
+    # Spec augmentation
+    if model.spec_augmentation is not None and model.training:
+        mel = model.spec_augmentation(input_spec=mel, length=mel_len)
+
+    # Encoder
+    enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+
+    # Decoder
+    dec_out = model.decoder(targets=tokens, target_length=token_len)
+    if isinstance(dec_out, tuple):
+        dec_out = dec_out[0]
+
+    # Joint + RNNT loss
+    if getattr(model.joint, 'fuse_loss_wer', False):
+        result = model.joint(
+            encoder_outputs=enc, decoder_outputs=dec_out,
+            encoder_lengths=enc_len, transcripts=tokens,
+            transcript_lengths=token_len, compute_wer=False,
+        )
+        loss = result[0]
+    else:
+        joint_out = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
+        loss = model.loss(
+            log_probs=joint_out, targets=tokens,
+            input_lengths=enc_len, target_lengths=token_len,
+        )
+
+    if loss.dim() > 0:
+        loss = loss.mean()
+
+    # Confidence penalty: negative entropy regularization on joint output
+    # Encourages less confident (more spread) predictions, acts like label smoothing
+    if confidence_penalty > 0.0:
+        # Extra forward pass through joint to get logits (works with fuse_loss_wer too)
+        joint_logits = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
+        # joint_logits: (B, T, U, V) log-probabilities
+        probs = torch.exp(joint_logits)
+        entropy = -(probs * joint_logits).sum(dim=-1)  # (B, T, U)
+        # Maximize entropy = minimize negative entropy = subtract from loss
+        loss = loss - confidence_penalty * entropy.mean()
+
+    return loss
+
+
+# ═══════════════════════════════════════════════════════════
+# Evaluation
+# ═══════════════════════════════════════════════════════════
+
+def normalize_text(text):
+    if _ml_normalizer is not None:
+        return _ml_normalizer(text)
+    text = unicodedata.normalize('NFKC', text)
+    text = text.lower()
+    text = re.sub(r'[^\w\s]', '', text)
+    return ' '.join(text.split())
+
+
+def normalize_text_fallback(text):
+    """Always use fallback normalizer for consistency with older runs."""
+    text = unicodedata.normalize('NFKC', text)
+    text = text.lower()
+    text = re.sub(r'[^\w\s]', '', text)
+    return ' '.join(text.split())
+
+
+def simple_wer(ref_words, hyp_words):
+    n, m = len(ref_words), len(hyp_words)
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1): dp[i][0] = i
+    for j in range(m + 1): dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            dp[i][j] = dp[i-1][j-1] if ref_words[i-1] == hyp_words[j-1] \
+                else 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+    return dp[n][m]
+
+
+def compute_wer_ids(ref_words, hyp_words):
+    """Edit distance with backtrace to get S/D/I counts."""
+    n, m = len(ref_words), len(hyp_words)
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1): dp[i][0] = i
+    for j in range(m + 1): dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            if ref_words[i - 1] == hyp_words[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1]
+            else:
+                dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+    subs, dels, ins = 0, 0, 0
+    i, j = n, m
+    while i > 0 or j > 0:
+        if i > 0 and j > 0 and ref_words[i - 1] == hyp_words[j - 1]:
+            i -= 1; j -= 1
+        elif i > 0 and j > 0 and dp[i][j] == dp[i - 1][j - 1] + 1:
+            subs += 1; i -= 1; j -= 1
+        elif i > 0 and dp[i][j] == dp[i - 1][j] + 1:
+            dels += 1; i -= 1
+        else:
+            ins += 1; j -= 1
+    return subs, dels, ins
+
+
+@torch.no_grad()
+def evaluate_batch(student, manifest_path, device, max_samples=None, normalizer_fn=None, rank=0):
+    """Evaluate WER using batch (non-streaming) inference."""
+    import soundfile as sf_eval
+
+    if normalizer_fn is None:
+        normalizer_fn = normalize_text
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_edits, total_words = 0, 0
+    total_subs, total_dels, total_ins = 0, 0, 0
+    errors = 0
+    batch_size = 16
+    examples = []
+
+    total_batches = (len(samples) + batch_size - 1) // batch_size
+    for start in range(0, len(samples), batch_size):
+        batch_samples = samples[start:start + batch_size]
+        batch_num = start // batch_size + 1
+        if (batch_num % 10 == 0 or batch_num == 1) and rank == 0:
+            print(f"    [eval batch {batch_num}/{total_batches}]", flush=True)
+        try:
+            audios = []
+            for s in batch_samples:
+                audio, sr = sf_eval.read(s["audio_filepath"], dtype="float32")
+                if len(audio.shape) > 1:
+                    audio = audio.mean(axis=1)
+                audios.append(torch.FloatTensor(audio))
+
+            audio_lens = torch.LongTensor([len(a) for a in audios])
+            max_len = audio_lens.max().item()
+            padded = torch.zeros(len(audios), max_len)
+            for i, a in enumerate(audios):
+                padded[i, :len(a)] = a
+
+            padded = padded.to(device)
+            audio_lens = audio_lens.to(device)
+
+            mel, mel_len = model.preprocessor(input_signal=padded, length=audio_lens)
+            enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+
+            best_hyps = model.decoding.rnnt_decoder_predictions_tensor(enc, enc_len)
+            if isinstance(best_hyps, tuple):
+                best_hyps = best_hyps[0]
+
+            for s, hyp in zip(batch_samples, best_hyps):
+                if hasattr(hyp, 'text') and hyp.text:
+                    pred = hyp.text
+                elif hasattr(hyp, 'y_sequence'):
+                    tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                    pred = model.tokenizer.ids_to_text(tids) if tids else ""
+                else:
+                    pred = str(hyp)
+
+                ref_n = normalizer_fn(s["text"])
+                pred_n = normalizer_fn(pred)
+                ref_words = ref_n.split()
+                pred_words = pred_n.split()
+                if ref_words:
+                    sub_c, del_c, ins_c = compute_wer_ids(ref_words, pred_words)
+                    total_subs += sub_c
+                    total_dels += del_c
+                    total_ins += ins_c
+                    total_edits += sub_c + del_c + ins_c
+                    total_words += len(ref_words)
+
+                if len(examples) < 5:
+                    examples.append((s["text"][:55], pred[:55]))
+
+        except Exception as e:
+            errors += 1
+            if errors <= 3 and rank == 0:
+                print(f"    [batch eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+
+    if normalizer_fn is normalize_text and rank == 0:  # Only print examples for primary eval
+        print(f"\n    {'Reference':<55} | {'Prediction':<55}")
+        print(f"    {'-'*55} | {'-'*55}")
+        for ref, pred in examples:
+            print(f"    {ref:<55} | {pred:<55}")
+        if errors:
+            print(f"    ({errors} batch eval errors)")
+
+    model.train()
+    return wer_score, total_subs, total_dels, total_ins, total_words
+
+
+@torch.no_grad()
+def evaluate_streaming(student, manifest_path, device, max_samples=None, rank=0):
+    """Evaluate WER using streaming inference."""
+    import soundfile as sf_eval
+    from nemo.collections.asr.parts.utils.streaming_utils import CacheAwareStreamingAudioBuffer
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    right_context = 13
+    chunk_frames = 1 + right_context
+    model.encoder.setup_streaming_params(
+        chunk_size=chunk_frames,
+        shift_size=chunk_frames,
+        left_chunks=70 // max(chunk_frames, 1),
+    )
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_edits, total_words = 0, 0
+    total_subs, total_dels, total_ins = 0, 0, 0
+    examples = []
+    errors = 0
+
+    for s in samples:
+        try:
+            audio, sr = sf_eval.read(s["audio_filepath"], dtype="float32")
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            buffer = CacheAwareStreamingAudioBuffer(model=model)
+            buffer.append_audio(audio)
+
+            cache_last_channel, cache_last_time, cache_last_channel_len = \
+                model.encoder.get_initial_cache_state(batch_size=1, dtype=torch.float32, device=device)
+            previous_hypotheses = None
+            pred = ""
+
+            for chunk_audio, chunk_len in buffer:
+                if chunk_audio is None:
+                    break
+                result = model.conformer_stream_step(
+                    processed_signal=chunk_audio,
+                    processed_signal_length=chunk_len,
+                    cache_last_channel=cache_last_channel,
+                    cache_last_time=cache_last_time,
+                    cache_last_channel_len=cache_last_channel_len,
+                    previous_hypotheses=previous_hypotheses,
+                    return_transcription=True,
+                )
+                if isinstance(result, tuple) and len(result) >= 6:
+                    cache_last_channel = result[2]
+                    cache_last_time = result[3]
+                    cache_last_channel_len = result[4]
+                    previous_hypotheses = result[5]
+                    if result[5] and len(result[5]) > 0:
+                        hyp = result[5][0]
+                        new_text = ""
+                        if hasattr(hyp, 'text') and hyp.text:
+                            new_text = hyp.text
+                        elif hasattr(hyp, 'y_sequence'):
+                            tids = hyp.y_sequence.tolist() if torch.is_tensor(hyp.y_sequence) else list(hyp.y_sequence)
+                            if tids:
+                                new_text = model.tokenizer.ids_to_text(tids)
+                        if new_text and len(new_text) > len(pred):
+                            pred = new_text
+
+            ref_n = normalize_text(s["text"])
+            pred_n = normalize_text(pred)
+            ref_words = ref_n.split()
+            pred_words = pred_n.split()
+
+            if ref_words:
+                sub_c, del_c, ins_c = compute_wer_ids(ref_words, pred_words)
+                total_subs += sub_c
+                total_dels += del_c
+                total_ins += ins_c
+                total_edits += sub_c + del_c + ins_c
+                total_words += len(ref_words)
+
+            if len(examples) < 5:
+                examples.append((s["text"][:55], pred[:55]))
+
+        except Exception as e:
+            errors += 1
+            if errors <= 3 and rank == 0:
+                print(f"    [streaming eval error] {type(e).__name__}: {e}")
+
+    wer_score = total_edits / max(total_words, 1) * 100
+
+    if rank == 0:
+        print(f"\n    {'Reference':<55} | {'Prediction':<55}")
+        print(f"    {'-'*55} | {'-'*55}")
+        for ref, pred in examples:
+            print(f"    {ref:<55} | {pred:<55}")
+        if errors:
+            print(f"    ({errors} samples failed)")
+
+    model.train()
+    return wer_score, total_subs, total_dels, total_ins, total_words
+
+
+@torch.no_grad()
+def compute_val_loss(student, manifest_path, device, max_samples=500):
+    """Compute RNNT loss on validation set."""
+    import soundfile as sf_val
+
+    model = student.module if isinstance(student, DDP) else student
+    model.eval()
+
+    samples = []
+    with open(manifest_path) as f:
+        for line in f:
+            samples.append(json.loads(line))
+    if max_samples and len(samples) > max_samples:
+        samples = samples[:max_samples]
+
+    total_loss = 0.0
+    count = 0
+
+    for s in samples:
+        try:
+            audio, sr = sf_val.read(s["audio_filepath"], dtype="float32")
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            text = unicodedata.normalize("NFKC", s["text"])
+            text = " ".join(text.split())
+            tokens = model.tokenizer.text_to_ids(text)
+            if not tokens:
+                continue
+
+            audio_tensor = torch.FloatTensor(audio).unsqueeze(0).to(device)
+            audio_len = torch.LongTensor([len(audio)]).to(device)
+            token_tensor = torch.LongTensor([tokens]).to(device)
+            token_len = torch.LongTensor([len(tokens)]).to(device)
+
+            mel, mel_len = model.preprocessor(input_signal=audio_tensor, length=audio_len)
+            enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
+            dec_out = model.decoder(targets=token_tensor, target_length=token_len)
+            if isinstance(dec_out, tuple):
+                dec_out = dec_out[0]
+
+            if getattr(model.joint, 'fuse_loss_wer', False):
+                result = model.joint(
+                    encoder_outputs=enc, decoder_outputs=dec_out,
+                    encoder_lengths=enc_len, transcripts=token_tensor,
+                    transcript_lengths=token_len, compute_wer=False,
+                )
+                loss = result[0]
+            else:
+                joint_out = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
+                loss = model.loss(log_probs=joint_out, targets=token_tensor,
+                                  input_lengths=enc_len, target_lengths=token_len)
+
+            if loss.dim() > 0:
+                loss = loss.mean()
+            total_loss += loss.item()
+            count += 1
+        except Exception:
+            continue
+
+    model.train()
+    return total_loss / max(count, 1)
+
+
+# ═══════════════════════════════════════════════════════════
+# LR Schedule
+# ═══════════════════════════════════════════════════════════
+
+def get_cosine_schedule(optimizer, warmup_steps, total_steps, min_lr=1e-6):
+    base_lr = optimizer.defaults["lr"]
+
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return max(1e-8 / base_lr, step / max(1, warmup_steps))
+        progress = min(1.0, (step - warmup_steps) / max(1, total_steps - warmup_steps))
+        return (min_lr + 0.5 * (base_lr - min_lr) * (1.0 + math.cos(math.pi * progress))) / base_lr
+
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+
+def get_constant_schedule(optimizer, warmup_steps):
+    base_lr = optimizer.defaults["lr"]
+
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return max(1e-8 / base_lr, step / max(1, warmup_steps))
+        return 1.0
+
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+
+# ═══════════════════════════════════════════════════════════
+# Main Training Loop
+# ═══════════════════════════════════════════════════════════
+
+def train(student, train_loader, train_sampler, args, device, rank, is_distributed):
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    lang = args.lang.upper()
+    model = student.module if isinstance(student, DDP) else student
+
+    trainable_params = [p for p in student.parameters() if p.requires_grad]
+    optimizer = torch.optim.AdamW(
+        trainable_params,
+        lr=args.lr,
+        weight_decay=args.weight_decay,
+        betas=(0.9, 0.98),
+        eps=1e-9,
+    )
+
+    steps_per_epoch = len(train_loader) // args.grad_accum
+    total_steps = steps_per_epoch * args.epochs
+    warmup_steps = steps_per_epoch * args.warmup_epochs
+
+    if args.constant_lr:
+        scheduler = get_constant_schedule(optimizer, warmup_steps)
+    else:
+        decay_epochs = args.lr_decay_epochs if args.lr_decay_epochs > 0 else args.epochs
+        cosine_total_steps = steps_per_epoch * decay_epochs
+        scheduler = get_cosine_schedule(optimizer, warmup_steps, cosine_total_steps, args.min_lr)
+
+    use_amp = args.bf16 or args.fp16
+    amp_dtype = torch.bfloat16 if args.bf16 else torch.float16
+    scaler = torch.amp.GradScaler("cuda") if args.fp16 else None
+
+    effective_batch = args.batch_size * args.grad_accum
+    if is_distributed:
+        world_size = dist.get_world_size()
+        effective_batch *= world_size
+    else:
+        world_size = 1
+
+    starting_from = args.resume_from if args.resume_from else args.student
+    print_rank0(f"\n{'='*65}", rank)
+    print_rank0(f"  {lang} Training Configuration", rank)
+    print_rank0(f"{'='*65}", rank)
+    print_rank0(f"  Language:           {lang}", rank)
+    print_rank0(f"  Starting from:      {starting_from}", rank)
+    print_rank0(f"  GPUs:               {world_size}", rank)
+    print_rank0(f"  Train samples:      {len(train_loader.dataset)}", rank)
+    print_rank0(f"  Per-GPU batch:      {args.batch_size}", rank)
+    print_rank0(f"  Effective batch:    {args.batch_size} x {args.grad_accum} x {world_size} = {effective_batch}", rank)
+    print_rank0(f"  Steps/epoch:        {steps_per_epoch}", rank)
+    print_rank0(f"  Total steps:        {total_steps}", rank)
+    print_rank0(f"  Warmup steps:       {warmup_steps}", rank)
+    print_rank0(f"  Learning rate:      {args.lr} ({'constant' if args.constant_lr else 'cosine decay'})", rank)
+    print_rank0(f"  Min LR:             {args.min_lr}", rank)
+    print_rank0(f"  Freeze encoder:     first {args.freeze_encoder_epochs} epochs", rank)
+    print_rank0(f"  Mixed precision:    {'bf16' if args.bf16 else 'fp16' if args.fp16 else 'off'}", rank)
+    print_rank0(f"  Weight decay:       {args.weight_decay}", rank)
+    print_rank0(f"  Grad clip norm:     {args.grad_clip}", rank)
+    if args.no_spec_augment:
+        print_rank0(f"  SpecAugment:        OFF", rank)
+    else:
+        print_rank0(f"  SpecAugment:        freq={args.freq_masks}x{args.freq_width} time={args.time_masks}x{args.time_width}", rank)
+    print_rank0(f"  Speed perturb:      {args.speed_perturb_factors if args.speed_perturb else 'OFF'}", rank)
+    print_rank0(f"  LR decay epochs:    {args.lr_decay_epochs}", rank)
+    print_rank0(f"  Early stop:         {args.early_stop_patience} epochs", rank)
+    if args.confidence_penalty > 0:
+        print_rank0(f"  Confidence penalty: {args.confidence_penalty}", rank)
+    if args.streaming_chunk_sec > 0:
+        print_rank0(f"  Streaming train:    forced att_context=[70,13] only", rank)
+    print_rank0(f"  Val manifest:       {args.val_manifest}", rank)
+    print_rank0(f"{'='*65}\n", rank)
+
+    global_step = 0
+    best_wer = float("inf")
+    best_val_loss = float("inf")
+    patience_counter = 0
+    start_epoch = 0
+
+    # Track top-K best WER checkpoints
+    top_k_wer = 3
+    top_k_checkpoints = []  # list of (wer, epoch, path)
+
+    # Track WER per epoch for convergence analysis
+    wer_history = []
+
+    import time as time_module
+
+    # Resume from training checkpoint if specified
+    if args.resume_training:
+        ckpt_path = args.resume_training
+        if os.path.isdir(ckpt_path):
+            # Load latest model weights if available
+            latest_model_path = os.path.join(ckpt_path, "latest_model.pt")
+            if os.path.exists(latest_model_path):
+                print_rank0(f"  Loading latest model weights from: {latest_model_path}", rank)
+                sd = torch.load(latest_model_path, map_location=device, weights_only=False)
+                model.load_state_dict(sd)
+                del sd
+                torch.cuda.empty_cache()
+            ckpt_path = os.path.join(ckpt_path, "training_state.pt")
+        if os.path.exists(ckpt_path):
+            print_rank0(f"  Resuming training state from: {ckpt_path}", rank)
+            ckpt = torch.load(ckpt_path, map_location=device, weights_only=False)
+            optimizer.load_state_dict(ckpt["optimizer"])
+            scheduler.load_state_dict(ckpt["scheduler"])
+            start_epoch = ckpt["epoch"]
+            global_step = ckpt["global_step"]
+            best_wer = ckpt["best_wer"]
+            best_val_loss = ckpt["best_val_loss"]
+            patience_counter = ckpt["patience_counter"]
+            wer_history = ckpt.get("wer_history", [])
+            if scaler and "scaler" in ckpt:
+                scaler.load_state_dict(ckpt["scaler"])
+            print_rank0(f"  Resumed at epoch {start_epoch}, step {global_step}, best_wer={best_wer:.2f}%", rank)
+            del ckpt
+            torch.cuda.empty_cache()
+        else:
+            print_rank0(f"  WARNING: resume_training path not found: {ckpt_path}", rank)
+
+    if is_distributed:
+        dist.barrier()
+
+    # ── Epoch 0: evaluate before any training ──
+    if start_epoch == 0:
+        print_rank0(f"\n  === Epoch 0 (pre-training baseline) ===", rank)
+        import sys as _sys
+
+        # Compute initial train loss + grad norm on first few batches (all ranks)
+        student.train()
+        e0_loss = 0.0
+        e0_gnorm = 0.0
+        e0_steps = 0
+        e0_max_batches = 20
+        for batch_idx, batch in enumerate(train_loader):
+            if batch is None:
+                continue
+            if batch_idx >= e0_max_batches:
+                break
+            try:
+                if use_amp:
+                    with torch.amp.autocast("cuda", dtype=amp_dtype):
+                        loss = train_step(student, batch, device, confidence_penalty=0.0)
+                    loss.backward()
+                else:
+                    loss = train_step(student, batch, device, confidence_penalty=0.0)
+                    loss.backward()
+                trainable = [p for p in student.parameters() if p.requires_grad and p.grad is not None]
+                gnorm = torch.nn.utils.clip_grad_norm_(trainable, 1e6).item()
+                e0_loss += loss.item()
+                if math.isfinite(gnorm):
+                    e0_gnorm += gnorm
+                e0_steps += 1
+                optimizer.zero_grad()
+            except Exception:
+                optimizer.zero_grad()
+                continue
+
+        if e0_steps > 0:
+            print_rank0(f"    Epoch 0 train_loss={e0_loss/e0_steps:.4f} gnorm={e0_gnorm/e0_steps:.3f} (avg over {e0_steps} batches)", rank)
+
+        # Tear down DDP before eval (same as regular epoch eval)
+        if is_distributed:
+            optimizer.zero_grad(set_to_none=True)
+            del student
+            student = None
+            torch.cuda.empty_cache()
+            dist.barrier()
+
+        # Free GPU memory before eval
+        optimizer.zero_grad(set_to_none=True)
+        opt_state_backup_e0 = {}
+        for k, v in optimizer.state.items():
+            opt_state_backup_e0[k] = {sk: sv.cpu() if torch.is_tensor(sv) else sv for sk, sv in v.items()}
+        optimizer.state.clear()
+        torch.cuda.empty_cache()
+        gc.collect()
+
+        # Evaluate WER + val_loss (all ranks run forward passes)
+        print_rank0(f"\n  Evaluating {lang} (epoch 0)...", rank)
+        _sys.stdout.flush()
+        val_wer, _, _, _, _ = evaluate_batch(model, args.val_manifest, device, rank=rank)
+        print_rank0(f"    [eval] WER done", rank); _sys.stdout.flush()
+        val_loss = compute_val_loss(model, args.val_manifest, device)
+        print_rank0(f"    [eval] val_loss done", rank); _sys.stdout.flush()
+
+        if is_main(rank):
+            print_rank0(f"    Epoch 0 WER: {val_wer:.2f}% | Val loss: {val_loss:.4f}", rank)
+            wer_history.append({
+                'epoch': 0,
+                'wer': val_wer,
+                'val_loss': val_loss,
+                'lr': 0.0,
+                'train_loss': e0_loss / max(1, e0_steps),
+            })
+        _sys.stdout.flush()
+
+        # Restore optimizer states from CPU
+        for k, v in opt_state_backup_e0.items():
+            optimizer.state[k] = {sk: sv.to(device) if torch.is_tensor(sv) else sv for sk, sv in v.items()}
+        del opt_state_backup_e0
+        torch.cuda.empty_cache()
+
+        # Rebuild DDP for training
+        if is_distributed:
+            student = DDP(model, device_ids=[int(os.environ.get("LOCAL_RANK", 0))], find_unused_parameters=True)
+            optimizer.param_groups[0]["params"] = [p for p in student.parameters() if p.requires_grad]
+
+        # Reset dataloader state
+        if train_sampler is not None:
+            train_sampler.set_epoch(0)
+
+    for epoch in range(start_epoch, args.epochs):
+        epoch_start = time_module.time()
+        student.train()
+
+        # Decay SpecAugment if enabled (all ranks need updated module)
+        if args.decay_spec_augment:
+            update_spec_augment(student, args, epoch, args.epochs, rank)
+
+        if train_sampler is not None:
+            train_sampler.set_epoch(epoch)
+
+        # Phase management
+        if epoch < args.freeze_encoder_epochs:
+            for p in model.encoder.parameters():
+                p.requires_grad = False
+            phase = f"Encoder frozen ({epoch+1}/{args.freeze_encoder_epochs})"
+        else:
+            for p in model.encoder.parameters():
+                p.requires_grad = True
+            phase = "Full training"
+
+        optimizer.param_groups[0]["params"] = [
+            p for p in student.parameters() if p.requires_grad
+        ]
+
+        epoch_loss = 0.0
+        epoch_steps = 0
+        epoch_grad_norm = 0.0
+        grad_norm_steps = 0
+        inf_grad_steps = 0
+
+        pbar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{args.epochs} [{lang}]",
+                    leave=True, ncols=120, disable=not is_main(rank) or not sys.stderr.isatty())
+        optimizer.zero_grad()
+
+        max_batch_audio_sec = 0.0
+        batch_lengths = []
+
+        for batch_idx, batch in enumerate(pbar):
+            if batch is None:
+                continue
+
+            # Track batch audio lengths
+            audio, audio_len_t, _, _ = batch
+            max_audio_samples = audio_len_t.max().item()
+            total_audio_samples = audio_len_t.sum().item()
+            max_sec = max_audio_samples / 16000
+            total_sec = total_audio_samples / 16000
+            batch_lengths.append(max_sec)
+            if max_sec > max_batch_audio_sec:
+                max_batch_audio_sec = max_sec
+
+            try:
+                if use_amp:
+                    with torch.amp.autocast("cuda", dtype=amp_dtype):
+                        loss = train_step(student, batch, device, confidence_penalty=args.confidence_penalty)
+                    if scaler:
+                        scaled_loss = loss / args.grad_accum
+                        scaler.scale(scaled_loss).backward()
+                    else:
+                        (loss / args.grad_accum).backward()
+                else:
+                    loss = train_step(student, batch, device, confidence_penalty=args.confidence_penalty)
+                    (loss / args.grad_accum).backward()
+
+            except RuntimeError as e:
+                if "out of memory" in str(e).lower():
+                    torch.cuda.empty_cache()
+                    print_rank0(f"\n    OOM at batch {batch_idx} (max_audio={max_sec:.1f}s, total={total_sec:.1f}s, batch_size={len(audio_len_t)}), skipping", rank)
+                    optimizer.zero_grad()
+                    continue
+                raise
+
+            epoch_loss += loss.item()
+            epoch_steps += 1
+
+            if (batch_idx + 1) % args.grad_accum == 0:
+                if scaler:
+                    scaler.unscale_(optimizer)
+                trainable = [p for p in student.parameters() if p.requires_grad and p.grad is not None]
+                grad_norm = torch.nn.utils.clip_grad_norm_(trainable, args.grad_clip).item()
+                if scaler:
+                    scaler.step(optimizer)
+                    scaler.update()
+                else:
+                    optimizer.step()
+
+                if math.isfinite(grad_norm):
+                    epoch_grad_norm += grad_norm
+                    grad_norm_steps += 1
+                else:
+                    inf_grad_steps += 1
+                scheduler.step()
+                optimizer.zero_grad()
+                global_step += 1
+
+            if epoch_steps % args.log_every == 0 and epoch_steps > 0 and is_main(rank):
+                avg_loss = epoch_loss / epoch_steps
+                avg_gnorm = epoch_grad_norm / max(1, grad_norm_steps)
+                lr = optimizer.param_groups[0]["lr"]
+                gnorm_str = f"{avg_gnorm:.2f}" if grad_norm_steps > 0 else "n/a"
+                if inf_grad_steps > 0:
+                    gnorm_str += f" ({inf_grad_steps} skipped)"
+                pbar.set_postfix(loss=f"{avg_loss:.3f}", gnorm=gnorm_str,
+                                 lr=f"{lr:.1e}", step=global_step)
+
+        # End of epoch
+        epoch_time = time_module.time() - epoch_start
+        avg_loss = epoch_loss / max(1, epoch_steps)
+        avg_gnorm = epoch_grad_norm / max(1, grad_norm_steps)
+        gnorm_display = f"{avg_gnorm:.3f}" if grad_norm_steps > 0 else "n/a"
+        if inf_grad_steps > 0:
+            gnorm_display += f" ({inf_grad_steps} inf-skipped)"
+        samples_per_sec = (epoch_steps * args.batch_size) / epoch_time
+        gpu_mem = torch.cuda.max_memory_allocated(device) / 1e9 if torch.cuda.is_available() else 0
+
+        # Batch length stats
+        if batch_lengths:
+            avg_max_sec = sum(batch_lengths) / len(batch_lengths)
+            p95 = sorted(batch_lengths)[int(0.95 * len(batch_lengths))]
+            print_rank0(f"    [batch stats] max_audio={max_batch_audio_sec:.1f}s avg_max={avg_max_sec:.1f}s p95={p95:.1f}s", rank)
+
+        print_rank0(f"\n  Epoch {epoch+1} [{lang}] | {phase} | loss={avg_loss:.4f} "
+                    f"gnorm={gnorm_display} lr={optimizer.param_groups[0]['lr']:.2e}"
+                    f" | {epoch_time/60:.1f}min | {samples_per_sec:.0f} samples/s | GPU: {gpu_mem:.1f}GB", rank)
+
+        # Tear down DDP before eval to remove forward hooks from model.
+        # DDP with find_unused_parameters=True registers hooks on the underlying
+        # model, so calling model.forward() during rank-0-only eval would trigger
+        # DDP communication and deadlock the other ranks.
+        if is_distributed:
+            optimizer.zero_grad(set_to_none=True)
+            del student
+            student = None
+            torch.cuda.empty_cache()
+            dist.barrier()
+
+        # Free GPU memory before eval: offload optimizer states to CPU
+        optimizer.zero_grad(set_to_none=True)
+        opt_state_backup = {}
+        for k, v in optimizer.state.items():
+            opt_state_backup[k] = {sk: sv.cpu() if torch.is_tensor(sv) else sv for sk, sv in v.items()}
+        optimizer.state.clear()
+        torch.cuda.empty_cache()
+        gc.collect()
+
+        mem_after = torch.cuda.memory_allocated(device) / 1e9
+        print_rank0(f"    [pre-eval] GPU mem after offload: {mem_after:.1f}GB", rank)
+        import sys as _sys; _sys.stdout.flush()
+
+        # Evaluation — ALL ranks run forward passes (needed for SyncBatchNorm / distributed
+        # layers inside NeMo encoder), but only rank 0 uses the results.
+        if (epoch + 1) % args.eval_every_epoch == 0:
+            try:
+                print_rank0(f"\n  Evaluating {lang}...", rank)
+                _sys.stdout.flush()
+
+                val_wer, _, _, _, _ = evaluate_batch(model, args.val_manifest, device, rank=rank)
+                print_rank0(f"    [eval] WER done", rank); _sys.stdout.flush()
+                val_loss = compute_val_loss(model, args.val_manifest, device)
+                print_rank0(f"    [eval] val_loss done", rank); _sys.stdout.flush()
+
+                if is_main(rank):
+                    print_rank0(f"    {lang} Batch WER: {val_wer:.2f}% | Val loss: {val_loss:.4f}", rank)
+
+                    wer_history.append({
+                        'epoch': epoch + 1,
+                        'wer': val_wer,
+                        'val_loss': val_loss,
+                        'lr': optimizer.param_groups[0]["lr"],
+                        'train_loss': avg_loss,
+                    })
+
+                    if val_wer < best_wer:
+                        best_wer = val_wer
+                        patience_counter = 0
+                        save_path = os.path.join(args.output_dir, "best_model.nemo")
+                        print_rank0(f"    [saving] best_model.nemo...", rank); _sys.stdout.flush()
+                        model.save_to(save_path)
+                        print_rank0(f"    New best WER! WER={best_wer:.2f}% -> {save_path}", rank)
+                    else:
+                        patience_counter += 1
+                        print_rank0(f"    No WER improvement ({patience_counter}/{args.early_stop_patience})", rank)
+
+                    # Save top-K best WER checkpoints for post-hoc evaluation
+                    should_save_topk = len(top_k_checkpoints) < top_k_wer or val_wer < top_k_checkpoints[-1][0]
+                    if should_save_topk:
+                        topk_path = os.path.join(args.output_dir, f"best_model_wer_ep{epoch+1}.nemo")
+                        print_rank0(f"    [saving] top-{top_k_wer} checkpoint (WER={val_wer:.2f}%)...", rank); _sys.stdout.flush()
+                        model.save_to(topk_path)
+                        top_k_checkpoints.append((val_wer, epoch + 1, topk_path))
+                        top_k_checkpoints.sort(key=lambda x: x[0])  # sort by WER ascending
+                        # Remove worst checkpoint if we exceed top_k_wer
+                        while len(top_k_checkpoints) > top_k_wer:
+                            _, _, old_path = top_k_checkpoints.pop()
+                            if os.path.exists(old_path):
+                                os.remove(old_path)
+                                print_rank0(f"    [removed] {os.path.basename(old_path)}", rank)
+
+                    if args.early_stop_patience > 0 and patience_counter >= args.early_stop_patience:
+                        print_rank0(f"\n    Early stopping! No improvement for {args.early_stop_patience} epochs.", rank)
+                        break
+
+                    if val_loss < best_val_loss:
+                        best_val_loss = val_loss
+                        save_path = os.path.join(args.output_dir, "best_model_loss.nemo")
+                        print_rank0(f"    [saving] best_model_loss.nemo...", rank); _sys.stdout.flush()
+                        model.save_to(save_path)
+                        print_rank0(f"    New best loss! loss={best_val_loss:.4f} -> {save_path}", rank)
+            except Exception as e:
+                print_rank0(f"    [eval error] {type(e).__name__}: {e} — skipping", rank)
+
+        print_rank0(f"    [post-eval] reaching barrier...", rank); sys.stdout.flush()
+
+        # Restore optimizer states from CPU
+        for k, v in opt_state_backup.items():
+            optimizer.state[k] = {sk: sv.to(device) if torch.is_tensor(sv) else sv for sk, sv in v.items()}
+        del opt_state_backup
+        torch.cuda.empty_cache()
+
+        # Rebuild DDP for next training epoch (after eval is done)
+        if is_distributed:
+            student = DDP(model, device_ids=[int(os.environ.get("LOCAL_RANK", 0))], find_unused_parameters=True)
+            optimizer.param_groups[0]["params"] = [p for p in student.parameters() if p.requires_grad]
+
+        # Save full training state for resumability
+        if is_main(rank) and args.save_every_epoch > 0 and (epoch + 1) % args.save_every_epoch == 0:
+            # Save latest model weights as raw state dict (fast, avoids NeMo save_to overhead)
+            latest_path = os.path.join(args.output_dir, "latest_model.pt")
+            torch.save(model.state_dict(), latest_path + ".tmp")
+            os.replace(latest_path + ".tmp", latest_path)
+
+            state = {
+                "epoch": epoch + 1,
+                "global_step": global_step,
+                "optimizer": optimizer.state_dict(),
+                "scheduler": scheduler.state_dict(),
+                "best_wer": best_wer,
+                "best_val_loss": best_val_loss,
+                "patience_counter": patience_counter,
+                "wer_history": wer_history,
+            }
+            if scaler:
+                state["scaler"] = scaler.state_dict()
+            state_path = os.path.join(args.output_dir, "training_state.pt")
+            torch.save(state, state_path + ".tmp")
+            os.replace(state_path + ".tmp", state_path)
+
+        # Clear GPU memory fragmentation from eval/save before next training epoch
+        torch.cuda.empty_cache()
+
+        if is_distributed:
+            dist.barrier()
+
+    # Save WER history for convergence analysis
+    if is_main(rank):
+        history_path = os.path.join(args.output_dir, "wer_history.json")
+        with open(history_path, "w") as f:
+            json.dump(wer_history, f, indent=2)
+        print_rank0(f"\n  WER history saved to {history_path}", rank)
+
+        # Final save
+        save_path = os.path.join(args.output_dir, "final_model.nemo")
+        model.save_to(save_path)
+        print_rank0(f"  Final model -> {save_path}", rank)
+        print_rank0(f"  Best {lang} WER: {best_wer:.2f}%", rank)
+
+    return student
+
+
+# ═══════════════════════════════════════════════════════════
+# Entry Point
+# ═══════════════════════════════════════════════════════════
+
+def main():
+    args = parse_args()
+
+    rank, world_size, local_rank, is_distributed = setup_ddp()
+    device = torch.device(f"cuda:{local_rank}")
+
+    torch.manual_seed(args.seed + rank)
+    np.random.seed(args.seed + rank)
+    torch.cuda.manual_seed_all(args.seed + rank)
+    import random
+    random.seed(args.seed + rank)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    lang = args.lang.upper()
+    starting_from = "multilingual base" if args.resume_from else "English checkpoint"
+
+    print_rank0(f"\n{'='*65}", rank)
+    print_rank0(f"  Nemotron Streaming ASR — {lang} Training", rank)
+    print_rank0(f"{'='*65}", rank)
+    print_rank0(f"  Language:  {lang}", rank)
+    print_rank0(f"  Path:      {starting_from}", rank)
+    print_rank0(f"  GPUs:      {world_size}", rank)
+    if args.resume_from:
+        print_rank0(f"  Base:      {args.resume_from}", rank)
+    else:
+        print_rank0(f"  Student:   {args.student}", rank)
+    print_rank0(f"  Train:     {args.train_manifest}", rank)
+    print_rank0(f"  Val:       {args.val_manifest}", rank)
+    print_rank0(f"{'='*65}", rank)
+
+    # Load model
+    print_rank0(f"\n[1/3] Loading model...", rank)
+    student = load_student(args, device, rank)
+
+    # Wrap in DDP
+    if is_distributed:
+        student = DDP(student, device_ids=[local_rank], find_unused_parameters=True)
+        print_rank0(f"  Wrapped in DDP (find_unused_parameters=True)", rank)
+
+    # Create dataloader
+    print_rank0(f"\n[2/3] Creating data loaders...", rank)
+    model_for_tok = student.module if isinstance(student, DDP) else student
+    train_dataset = ASRManifestDataset(
+        args.train_manifest,
+        model_for_tok.tokenizer,
+        min_duration=args.min_duration,
+        max_duration=args.max_duration,
+        speed_perturb=args.speed_perturb,
+        speed_perturb_factors=args.speed_perturb_factors,
+        max_train_hours=args.max_train_hours,
+        seed=args.data_seed,
+    )
+    print_rank0(f"  Train dataset: {len(train_dataset)} samples", rank)
+    if args.max_train_hours > 0:
+        print_rank0(f"  Subsampled to {train_dataset.total_hours:.1f}h (requested {args.max_train_hours}h)", rank)
+
+    # Offset by -42 so --seed=42 (default) keeps PyTorch's default sampler seed=0
+    # for backward compat with prior runs. --seed=43 -> sampler seed=1, etc.
+    train_sampler = DistributedSampler(train_dataset, shuffle=True, seed=args.seed - 42) if is_distributed else None
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=args.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        num_workers=args.num_workers,
+        collate_fn=collate_asr,
+        pin_memory=True,
+        drop_last=True,
+    )
+
+    # Train
+    print_rank0(f"\n[3/3] Starting {lang} training...", rank)
+    student = train(
+        student, train_loader, train_sampler,
+        args, device, rank, is_distributed,
+    )
+
+    # Final eval on best model — all ranks run eval (NeMo model has distributed internals),
+    # only rank 0 prints/uses results
+    import nemo.collections.asr as nemo_asr
+
+    best_path = os.path.join(args.output_dir, "best_model.nemo")
+    if os.path.exists(best_path):
+        print_rank0(f"\n  Loading best model from {best_path}...", rank)
+        best_model = nemo_asr.models.ASRModel.restore_from(best_path, map_location=device)
+        best_model = best_model.to(device)
+        best_model.eval()
+    else:
+        print_rank0(f"\n  Best model not found, using final model.", rank)
+        best_model = model
+
+    print_rank0(f"\n{'='*65}", rank)
+    print_rank0(f"  Final Evaluation — {lang} (best checkpoint)", rank)
+    print_rank0(f"{'='*65}", rank)
+
+    batch_wer, b_s, b_d, b_i, b_w = evaluate_batch(best_model, args.val_manifest, device, rank=rank)
+    if is_main(rank):
+        print_rank0(f"  {lang} Val Batch WER:     {batch_wer:.2f}%  (S={b_s/max(b_w,1)*100:.2f}% D={b_d/max(b_w,1)*100:.2f}% I={b_i/max(b_w,1)*100:.2f}%)", rank)
+        print_rank0(f"    Counts: subs={b_s} dels={b_d} ins={b_i} / {b_w} ref words", rank)
+
+    print_rank0(f"\n  Running streaming eval...", rank)
+    stream_wer, s_s, s_d, s_i, s_w = evaluate_streaming(best_model, args.val_manifest, device, rank=rank)
+    if is_main(rank):
+        print_rank0(f"  {lang} Val Streaming WER:  {stream_wer:.2f}%  (S={s_s/max(s_w,1)*100:.2f}% D={s_d/max(s_w,1)*100:.2f}% I={s_i/max(s_w,1)*100:.2f}%)", rank)
+        print_rank0(f"    Counts: subs={s_s} dels={s_d} ins={s_i} / {s_w} ref words", rank)
+
+    if args.test_manifest:
+        print_rank0(f"\n{'='*65}", rank)
+        print_rank0(f"  Test Evaluation — {lang} (best checkpoint)", rank)
+        print_rank0(f"{'='*65}", rank)
+
+        test_batch_wer, tb_s, tb_d, tb_i, tb_w = evaluate_batch(best_model, args.test_manifest, device, rank=rank)
+        if is_main(rank):
+            print_rank0(f"  {lang} Test Batch WER:     {test_batch_wer:.2f}%  (S={tb_s/max(tb_w,1)*100:.2f}% D={tb_d/max(tb_w,1)*100:.2f}% I={tb_i/max(tb_w,1)*100:.2f}%)", rank)
+            print_rank0(f"    Counts: subs={tb_s} dels={tb_d} ins={tb_i} / {tb_w} ref words", rank)
+
+        print_rank0(f"\n  Running streaming test eval...", rank)
+        test_stream_wer, ts_s, ts_d, ts_i, ts_w = evaluate_streaming(best_model, args.test_manifest, device, rank=rank)
+        if is_main(rank):
+            print_rank0(f"  {lang} Test Streaming WER:  {test_stream_wer:.2f}%  (S={ts_s/max(ts_w,1)*100:.2f}% D={ts_d/max(ts_w,1)*100:.2f}% I={ts_i/max(ts_w,1)*100:.2f}%)", rank)
+            print_rank0(f"    Counts: subs={ts_s} dels={ts_d} ins={ts_i} / {ts_w} ref words", rank)
+
+    del best_model
+    torch.cuda.empty_cache()
+
+    # Evaluate best-by-loss model if it exists
+    best_loss_path = os.path.join(args.output_dir, "best_model_loss.nemo")
+    if os.path.exists(best_loss_path):
+        print_rank0(f"\n{'='*65}", rank)
+        print_rank0(f"  Final Evaluation — {lang} (best loss checkpoint)", rank)
+        print_rank0(f"{'='*65}", rank)
+
+        print_rank0(f"  Loading best-by-loss model from {best_loss_path}...", rank)
+        best_loss_model = nemo_asr.models.ASRModel.restore_from(best_loss_path, map_location=device)
+        best_loss_model = best_loss_model.to(device)
+        best_loss_model.eval()
+
+        bl_wer, bl_s, bl_d, bl_i, bl_w = evaluate_batch(best_loss_model, args.val_manifest, device, rank=rank)
+        if is_main(rank):
+            print_rank0(f"  {lang} Val Batch WER (loss-best):     {bl_wer:.2f}%  (S={bl_s/max(bl_w,1)*100:.2f}% D={bl_d/max(bl_w,1)*100:.2f}% I={bl_i/max(bl_w,1)*100:.2f}%)", rank)
+
+        if args.test_manifest:
+            tbl_wer, tbl_s, tbl_d, tbl_i, tbl_w = evaluate_batch(best_loss_model, args.test_manifest, device, rank=rank)
+            if is_main(rank):
+                print_rank0(f"  {lang} Test Batch WER (loss-best):    {tbl_wer:.2f}%  (S={tbl_s/max(tbl_w,1)*100:.2f}% D={tbl_d/max(tbl_w,1)*100:.2f}% I={tbl_i/max(tbl_w,1)*100:.2f}%)", rank)
+
+        del best_loss_model
+        torch.cuda.empty_cache()
+
+    # All ranks must wait for rank 0's final eval before destroying process group
+    if is_distributed:
+        dist.barrier()
+
+    cleanup_ddp(is_distributed)
+
+
+if __name__ == "__main__":
+    main()