Added sehaj paath train stream nemo

train-stream-sehaj.py

@@ -0,0 +1,2563 @@
+#!/usr/bin/env python3
+
+# Version: initializes model weights from the [202,100] best checkpoint and
+# fine-tunes using NeMo-valid [72,23] attention context (2.88 s left, 920 ms right).
+
+import argparse
+import copy
+import json
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+import torch
+import pytorch_lightning as pl
+from hydra.utils import instantiate
+from omegaconf import OmegaConf, open_dict
+from pytorch_lightning.callbacks import Callback, TQDMProgressBar
+
+import nemo.collections.asr as nemo_asr
+
+
+###############################################################################
+# DATASET CONFIGURATION
+###############################################################################
+
+# The script lives in /workspace and manifests live in /workspace/training_data.
+DATA_ROOT = Path(__file__).resolve().parent
+
+# Manifest paths are selected at startup. Sehaj Paath is the only validation set.
+# Normal: training_manifest.json
+# --test: training_manifest_test.json (validation remains full Sehaj Paath)
+# Audio paths inside the manifests are used exactly as written.
+TRAIN_MANIFEST = None
+SEHAJ_VAL_MANIFEST = None
+
+
+def configure_manifests(test_mode: bool) -> None:
+    """Use small training data in --test, but always use full validation."""
+    global TRAIN_MANIFEST
+    global SEHAJ_VAL_MANIFEST
+
+    if test_mode:
+        TRAIN_MANIFEST = DATA_ROOT / "training_data/sehaj/training_manifest_test.json"
+    else:
+        TRAIN_MANIFEST = DATA_ROOT / "training_data/sehaj/training_manifest.json"
+
+    # Always score the real/full validation sets, including --test.
+    SEHAJ_VAL_MANIFEST = DATA_ROOT / "training_data/sehaj/sehaj_paath_val_manifest.json"
+
+EXPECTED_SAMPLE_RATE = 16_000
+LANGUAGE_CODE = "pa"
+
+# Use one explicit decoder for validation so the metric is stable across epochs.
+# The model is hybrid RNNT+CTC; CTC is used here only for explicit WER/CER scoring.
+VALIDATION_DECODER = "ctc"
+
+
+###############################################################################
+# MODEL CONFIGURATION
+###############################################################################
+
+# Restore the exported model for its architecture/tokenizer, then initialize its
+# model weights from the previous [202,100] run's best.ckpt. The encoder is
+# rebuilt for the new [72,23] training context before training.
+MODEL_PATH = Path(
+    "/workspace/resume_checkpoint/baniguru_kirtan_stream_v2_224_27.nemo"
+).expanduser().resolve()
+SOURCE_MODEL_ATT_CONTEXT = [224, 27]
+
+# The first [72,23] run initializes model weights from the previous run's best
+# checkpoint (fresh optimizer/scheduler). Subsequent restarts restore the full
+# Lightning state from this new context's own rolling checkpoint.
+START_CHECKPOINT_PATH = Path(
+    "/workspace/asr_stream_training_202_100/checkpoints/best.ckpt"
+).expanduser().resolve()
+
+# Rolling full-Lightning checkpoint produced by THIS NEW [72,23] run.
+LAST_STABLE_CHECKPOINT_PATH = Path(
+    "/workspace/resume_checkpoint/stream_72_23_last_stable.ckpt"
+).expanduser().resolve()
+
+
+###############################################################################
+# CACHE-AWARE / STREAMING ENCODER CONFIGURATION
+
+# Context	Look-ahead	Chunk
+# [112,27]	1080 ms	1120 ms
+# [224,27]	520 ms	560 ms
+# [112,6]	240 ms	280 ms
+# [112,3]	120 ms	160 ms
+# [112,1]	40 ms	80 ms
+# [112,0]	0 ms	40 ms
+
+# Exported MODEL_PATH context: [224,27] (224x40ms left, 27x40ms right).
+# Training context: [72,23] = 72x40ms left (2.88s), 23x40ms right (920ms).
+# NeMo requires left_context % (right_context + 1) == 0; 72 % 24 == 0.
+
+###############################################################################
+
+STREAM_ATT_CONTEXTS = [[72, 23]]
+
+# Train the complete manifest using 2.88 s left context and 920 ms right context.
+
+CAUSAL_CONV_CONTEXT = [30, 0]
+
+###############################################################################
+# TRAINING CONFIGURATION
+###############################################################################
+
+BATCH_SIZE = 8
+
+# Conservative full-model fine-tuning rate for the [72,23] adaptation.
+LEARNING_RATE = 1e-5
+
+# Upper limit.
+# Early stopping can stop training before reaching this.
+MAX_EPOCHS = 50
+
+# Effective batch size:
+#
+# BATCH_SIZE * ACCUMULATE_GRAD_BATCHES
+#
+# 4 * 2 = 8
+ACCUMULATE_GRAD_BATCHES = 1
+
+# Tiny fixed CTC probe during training.
+CTC_PROBE_EVERY_OPTIMIZER_STEPS = 1000
+CTC_STABLE_CHECKPOINT_EVERY_OPTIMIZER_STEPS = 2000
+CTC_PROBE_SAMPLE_COUNT = 2
+
+
+###############################################################################
+# EARLY STOPPING CONFIGURATION
+###############################################################################
+
+# Stop after this many consecutive validation epochs without improvement.
+EARLY_STOP_PATIENCE = 20
+EARLY_STOP_WARMUP_EPOCHS = 0
+
+# Sehaj CER or WER must improve by at least this much to count as a gain.
+#
+# Example:
+#   old WER = 0.1000
+#   new WER = 0.09995
+#
+# Difference = 0.00005
+#
+# The same minimum decrease applies independently to Sehaj CER and WER.
+MIN_METRIC_IMPROVEMENT = 0.0001
+
+###############################################################################
+# CLOUDFLARE R2 BACKUP CONFIGURATION
+###############################################################################
+
+# Upload ONLY best.ckpt when Sehaj Paath CER or WER improves.
+# Credentials are read from environment variables so secrets are not stored
+# inside this training script.
+R2_UPLOAD_ENABLED = True
+R2_OBJECT_KEY = os.environ.get(
+    "R2_OBJECT_KEY",
+    "checkpoints/stream-72_23-best.ckpt",
+)
+R2_UPLOAD_RETRIES = 3
+R2_RETRY_DELAY_SECONDS = 10
+
+
+###############################################################################
+# VAST.AI AUTO-DESTROY CONFIGURATION
+###############################################################################
+
+# Full runs automatically destroy the current Vast instance only after:
+#   1. training has finished (early stopping or max epochs), AND
+#   2. a best.ckpt was successfully uploaded to R2.
+#
+# --test NEVER destroys the instance.
+AUTO_DESTROY_VAST = False
+
+
+###############################################################################
+# OUTPUT / CHECKPOINT / LOG CONFIGURATION
+###############################################################################
+
+# Put large/persistent training outputs under this directory.
+#
+# Vast.ai workspace output directory.
+#
+# Checkpoints, metrics, and the final model stay under OUTPUT_ROOT.
+#
+#   OUTPUT_ROOT/
+#   ├── checkpoints/
+#   │   ├── best.ckpt
+#   │   ├── epoch_XXX.ckpt
+#   │   └── epoch_YYY.ckpt
+#   ├── wer_history.json
+#   └── gurbani_sehaj_paath_v1_base_indicconformer_stt_multi_hybrid_rnnt_600m.nemo
+#
+OUTPUT_ROOT = Path(
+    "/workspace/asr_stream_training_72_23"
+).expanduser().resolve()
+
+# Final .nemo model saved when training finishes / early-stops.
+OUTPUT_MODEL = (
+    OUTPUT_ROOT
+    / "baniguru_kirtan_stream_72_23.nemo"
+)
+
+# Best checkpoint + last two epoch checkpoints.
+CHECKPOINT_DIR = (
+    OUTPUT_ROOT / "checkpoints"
+)
+
+BEST_CHECKPOINT_PATH = (
+    CHECKPOINT_DIR / "best.ckpt"
+)
+
+# Per-epoch Sehaj Paath validation metrics (CER and WER).
+EPOCH_METRICS_PATH = (
+    OUTPUT_ROOT / "epoch_metrics.json"
+)
+
+
+def configure_outputs(test_mode: bool, offline: bool = False) -> None:
+    """Keep test artifacts separate and optionally disable R2 for test runs."""
+    global OUTPUT_ROOT
+    global OUTPUT_MODEL
+    global CHECKPOINT_DIR
+    global BEST_CHECKPOINT_PATH
+    global EPOCH_METRICS_PATH
+    global R2_OBJECT_KEY
+    global R2_UPLOAD_ENABLED
+
+    if test_mode:
+        OUTPUT_ROOT = Path("/workspace/asr_stream_training_72_23_test").expanduser().resolve()
+        OUTPUT_MODEL = OUTPUT_ROOT / "baniguru_kirtan_stream_72_23.nemo"
+        CHECKPOINT_DIR = OUTPUT_ROOT / "checkpoints"
+        BEST_CHECKPOINT_PATH = CHECKPOINT_DIR / "best.ckpt"
+        EPOCH_METRICS_PATH = OUTPUT_ROOT / "epoch_metrics.json"
+
+        # Online test runs use a separate R2 object and never overwrite
+        # the full-run best checkpoint.
+        R2_OBJECT_KEY = "checkpoints/test-72_23-best.ckpt"
+
+    if offline:
+        # --offline is intentionally restricted to --test in parse_args().
+        R2_UPLOAD_ENABLED = False
+
+###############################################################################
+# CALLBACK: PROGRESS BAR WITH HUMAN-READABLE EPOCH NUMBER
+###############################################################################
+
+class EpochProgressBar(TQDMProgressBar):
+    def get_metrics(self, trainer, pl_module):
+        items = super().get_metrics(trainer, pl_module)
+        items["epoch"] = trainer.current_epoch + 1
+        return items
+
+
+###############################################################################
+# CALLBACK: EPOCH TIMER
+###############################################################################
+
+class EpochTimer(Callback):
+    def __init__(self):
+        super().__init__()
+        self.start_time = None
+
+    def on_train_epoch_start(
+        self,
+        trainer,
+        pl_module,
+    ):
+        self.start_time = time.time()
+
+    def on_train_epoch_end(
+        self,
+        trainer,
+        pl_module,
+    ):
+        if self.start_time is None:
+            print(
+                f"\nEpoch {trainer.current_epoch + 1} completed "
+                "(timer unavailable because training resumed mid-epoch)"
+            )
+            return
+
+        elapsed = time.time() - self.start_time
+
+        print(
+            f"\nEpoch {trainer.current_epoch + 1} "
+            f"completed in {elapsed / 60:.2f} minutes"
+        )
+
+
+###############################################################################
+# VALIDATION METRICS HELPERS
+###############################################################################
+
+def levenshtein_ops(reference, hypothesis):
+    """
+    Return (substitutions, deletions, insertions) for two sequences.
+    """
+    n = len(reference)
+    m = len(hypothesis)
+
+    # dp[i][j] = (cost, S, D, I)
+    dp = [[None] * (m + 1) for _ in range(n + 1)]
+
+    dp[0][0] = (0, 0, 0, 0)
+
+    for i in range(1, n + 1):
+        dp[i][0] = (i, 0, i, 0)
+
+    for j in range(1, m + 1):
+        dp[0][j] = (j, 0, 0, j)
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+
+            if reference[i - 1] == hypothesis[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1]
+                continue
+
+            sub_prev = dp[i - 1][j - 1]
+            del_prev = dp[i - 1][j]
+            ins_prev = dp[i][j - 1]
+
+            candidates = [
+                (
+                    sub_prev[0] + 1,
+                    sub_prev[1] + 1,
+                    sub_prev[2],
+                    sub_prev[3],
+                ),
+                (
+                    del_prev[0] + 1,
+                    del_prev[1],
+                    del_prev[2] + 1,
+                    del_prev[3],
+                ),
+                (
+                    ins_prev[0] + 1,
+                    ins_prev[1],
+                    ins_prev[2],
+                    ins_prev[3] + 1,
+                ),
+            ]
+
+            dp[i][j] = min(
+                candidates,
+                key=lambda item: (
+                    item[0],
+                    item[2],  # prefer fewer deletions on ties
+                    item[3],
+                    item[1],
+                ),
+            )
+
+    _, substitutions, deletions, insertions = dp[n][m]
+
+    return substitutions, deletions, insertions
+
+
+def extract_text_from_hypothesis(item):
+    if isinstance(item, str):
+        return item
+
+    if hasattr(item, "text"):
+        return str(item.text)
+
+    if isinstance(item, dict):
+        if "text" in item:
+            return str(item["text"])
+
+        if "pred_text" in item:
+            return str(item["pred_text"])
+
+    return str(item)
+
+
+def select_primary_transcriptions(outputs, expected_count):
+    """
+    Normalize NeMo transcribe() output.
+
+    Hybrid RNNT+CTC models can return more than one decoding branch.
+    We select the first complete branch, which is treated here as the
+    primary transcription stream for BOTH domains and all epochs.
+    """
+    if isinstance(outputs, tuple):
+        outputs = list(outputs)
+
+    if isinstance(outputs, list):
+
+        # Normal case: one hypothesis per input.
+        if len(outputs) == expected_count and (
+            expected_count == 0
+            or not isinstance(outputs[0], (list, tuple))
+        ):
+            return [
+                extract_text_from_hypothesis(item)
+                for item in outputs
+            ]
+
+        # Hybrid case: [rnnt_outputs, ctc_outputs, ...]
+        for branch in outputs:
+            if (
+                isinstance(branch, (list, tuple))
+                and len(branch) == expected_count
+            ):
+                return [
+                    extract_text_from_hypothesis(item)
+                    for item in branch
+                ]
+
+    raise RuntimeError(
+        "Could not identify the primary transcribe() output branch. "
+        f"Expected {expected_count} predictions; got type={type(outputs)}"
+    )
+
+
+def load_validation_manifest(manifest_path: Path):
+    samples = []
+
+    with Path(manifest_path).open(
+        "r",
+        encoding="utf-8",
+    ) as handle:
+
+        for line_number, line in enumerate(
+            handle,
+            start=1,
+        ):
+            line = line.strip()
+
+            if not line:
+                continue
+
+            item = json.loads(line)
+
+            audio_path = item.get(
+                "audio_filepath"
+            )
+
+            text = item.get(
+                "text"
+            )
+
+            if not audio_path:
+                raise RuntimeError(
+                    f"{manifest_path}: line {line_number} "
+                    "has no audio_filepath."
+                )
+
+            if text is None:
+                raise RuntimeError(
+                    f"{manifest_path}: line {line_number} "
+                    "has no text."
+                )
+
+            language = item.get("lang")
+
+            if language != LANGUAGE_CODE:
+                raise RuntimeError(
+                    f"{manifest_path}: line {line_number} "
+                    f"must have lang='{LANGUAGE_CODE}', got {language!r}."
+                )
+
+            samples.append(
+                {
+                    "audio_filepath": str(audio_path),
+                    "text": " ".join(
+                        str(text).strip().split()
+                    ),
+                    "lang": language,
+                }
+            )
+
+    if not samples:
+        raise RuntimeError(
+            f"Validation manifest is empty: {manifest_path}"
+        )
+
+    return samples
+
+
+
+def gpu_safe_transcribe(
+    model,
+    audio_paths,
+    batch_size: int,
+    verbose: bool,
+):
+    """
+    Explicit transcription helper.
+
+    The model is moved to CUDA before the pre-train health check. The patched
+    AI4Bharat hybrid _transcribe_forward() moves file-dataloader audio tensors
+    onto the same model device before forward(), so no runtime monkey-patching
+    is needed here.
+    """
+    return model.transcribe(
+        audio_paths,
+        batch_size=batch_size,
+        return_hypotheses=False,
+        verbose=verbose,
+        language_id=LANGUAGE_CODE,
+    )
+
+def score_validation_manifest(
+    model,
+    manifest_path: Path,
+    batch_size: int,
+):
+    """
+    Explicitly transcribe one validation manifest and return STRICT
+    word-level WER and character-level CER.
+
+    Validation is forced onto one decoder (CTC) for every epoch so a hybrid
+    RNNT+CTC model cannot silently switch decoding branches between calls.
+    The model stays on its existing device (normally CUDA) and its training/eval
+    state and previous decoder are restored even if validation raises.
+
+    Spaces are excluded from CER.
+    """
+
+    samples = load_validation_manifest(manifest_path)
+
+    total_word_substitutions = 0
+    total_word_deletions = 0
+    total_word_insertions = 0
+    total_reference_words = 0
+    total_predicted_words = 0
+
+    total_char_substitutions = 0
+    total_char_deletions = 0
+    total_char_insertions = 0
+    total_reference_chars = 0
+    total_predicted_chars = 0
+
+    special_or_empty_outputs = 0
+    checked_outputs = 0
+
+    was_training = model.training
+    previous_decoder = getattr(model, "cur_decoder", None)
+
+    model.eval()
+
+    if not hasattr(model, "cur_decoder"):
+        raise RuntimeError(
+            "Hybrid validation expected model.cur_decoder, but the restored "
+            "model does not expose it. Refusing to compute an ambiguous WER."
+        )
+
+    model.cur_decoder = VALIDATION_DECODER
+
+    try:
+        with torch.no_grad():
+            for start in range(0, len(samples), batch_size):
+                batch = samples[start:start + batch_size]
+
+                audio_paths = [
+                    item["audio_filepath"]
+                    for item in batch
+                ]
+
+                outputs = gpu_safe_transcribe(
+                    model=model,
+                    audio_paths=audio_paths,
+                    batch_size=batch_size,
+                    verbose=True,
+                )
+
+                hypotheses = select_primary_transcriptions(
+                    outputs,
+                    expected_count=len(batch),
+                )
+
+                normalized_batch = [
+                    " ".join(str(value).strip().split())
+                    for value in hypotheses
+                ]
+
+                checked_outputs += len(normalized_batch)
+                special_or_empty_outputs += sum(
+                    value in {"<unk>", "<blank>", ""}
+                    for value in normalized_batch
+                )
+
+                if start == 0:
+                    print("\nVALIDATION DEBUG")
+                    print(f"Manifest: {manifest_path}")
+                    print(f"Decoder: {getattr(model, 'cur_decoder', None)!r}")
+                    print(f"Device: {next(model.parameters()).device}")
+                    print(f"Outputs type: {type(outputs)}")
+
+                    if normalized_batch and all(
+                        value in {"<unk>", "<blank>", ""}
+                        for value in normalized_batch
+                    ):
+                        raise RuntimeError(
+                            "Validation decoder returned only special/empty "
+                            f"tokens for {manifest_path}: "
+                            f"{normalized_batch[:5]}. "
+                            "Stopping instead of recording a false WER."
+                        )
+
+                for batch_index, (sample, hypothesis) in enumerate(
+                    zip(batch, hypotheses),
+                ):
+                    reference = " ".join(
+                        sample["text"].strip().split()
+                    )
+                    hypothesis = " ".join(
+                        hypothesis.strip().split()
+                    )
+
+                    validation_index = start + batch_index + 1
+                    print(f"  [{validation_index}] REF : {reference}")
+                    print(f"  [{validation_index}] PRED: {hypothesis}")
+
+                    ref_words = reference.split()
+                    hyp_words = hypothesis.split()
+
+                    word_s, word_d, word_i = levenshtein_ops(
+                        ref_words,
+                        hyp_words,
+                    )
+
+                    total_word_substitutions += word_s
+                    total_word_deletions += word_d
+                    total_word_insertions += word_i
+                    total_reference_words += len(ref_words)
+                    total_predicted_words += len(hyp_words)
+
+                    ref_chars = list(reference.replace(" ", ""))
+                    hyp_chars = list(hypothesis.replace(" ", ""))
+
+                    char_s, char_d, char_i = levenshtein_ops(
+                        ref_chars,
+                        hyp_chars,
+                    )
+
+                    total_char_substitutions += char_s
+                    total_char_deletions += char_d
+                    total_char_insertions += char_i
+                    total_reference_chars += len(ref_chars)
+                    total_predicted_chars += len(hyp_chars)
+
+    finally:
+        model.cur_decoder = previous_decoder
+
+        if was_training:
+            model.train()
+        else:
+            model.eval()
+
+    special_ratio = (
+        special_or_empty_outputs / checked_outputs
+        if checked_outputs
+        else 1.0
+    )
+
+    if checked_outputs == 0:
+        raise RuntimeError(
+            f"Validation produced zero hypotheses for {manifest_path}."
+        )
+
+    if special_ratio >= 0.95:
+        raise RuntimeError(
+            "CTC VALIDATION COLLAPSE DETECTED: "
+            f"{special_or_empty_outputs}/{checked_outputs} "
+            f"({special_ratio * 100.0:.2f}%) hypotheses were "
+            f"<unk>/<blank>/empty for {manifest_path}. "
+            "Training is being aborted. No checkpoint from this epoch "
+            "will be promoted or uploaded."
+        )
+
+    word_errors = (
+        total_word_substitutions
+        + total_word_deletions
+        + total_word_insertions
+    )
+
+    char_errors = (
+        total_char_substitutions
+        + total_char_deletions
+        + total_char_insertions
+    )
+
+    wer = (
+        word_errors / total_reference_words
+        if total_reference_words
+        else 0.0
+    )
+
+    cer = (
+        char_errors / total_reference_chars
+        if total_reference_chars
+        else 0.0
+    )
+
+    return {
+        "samples": len(samples),
+        "ctc_special_or_empty_outputs": special_or_empty_outputs,
+        "ctc_checked_outputs": checked_outputs,
+        "ctc_special_or_empty_ratio": special_ratio,
+        "wer": wer,
+        "wer_percent": wer * 100.0,
+        "word_errors": word_errors,
+        "total_reference_words": total_reference_words,
+        "total_predicted_words": total_predicted_words,
+        "word_substitutions": total_word_substitutions,
+        "word_deletions": total_word_deletions,
+        "word_insertions": total_word_insertions,
+        "cer": cer,
+        "cer_percent": cer * 100.0,
+        "char_errors": char_errors,
+        "total_reference_characters": total_reference_chars,
+        "total_predicted_characters": total_predicted_chars,
+        "char_substitutions": total_char_substitutions,
+        "char_deletions": total_char_deletions,
+        "char_insertions": total_char_insertions,
+    }
+
+
+###############################################################################
+# PRE-TRAIN CTC HEALTH CHECK
+###############################################################################
+
+def run_pretrain_ctc_health_check(model, batch_size: int) -> None:
+    """
+    Refuse to begin training unless the model decodes the full Sehaj Paath
+    validation manifest through the same CTC path used after every epoch.
+    """
+
+    print("\n======================================")
+    print("PRE-TRAIN CTC HEALTH CHECK")
+    print("======================================")
+    print("No training has happened yet.")
+    print("Sehaj Paath must decode successfully before trainer.fit().")
+
+    print("\nPre-train SEHAJ PAATH CTC validation...")
+    sehaj = score_validation_manifest(
+        model=model,
+        manifest_path=SEHAJ_VAL_MANIFEST,
+        batch_size=batch_size,
+    )
+
+    print("\nPRE-TRAIN CTC HEALTH CHECK PASSED")
+    print(
+        f"Sehaj WER: {sehaj['wer']:.6f} "
+        f"({sehaj['wer_percent']:.3f}%)"
+    )
+    print(
+        f"Sehaj CTC special/empty: "
+        f"{sehaj['ctc_special_or_empty_outputs']}/"
+        f"{sehaj['ctc_checked_outputs']}"
+    )
+    print("✓ Safe to begin training")
+
+
+###############################################################################
+# CLOUDFLARE R2 HELPERS
+###############################################################################
+
+def get_r2_config():
+    """Read and validate Cloudflare R2 connection settings."""
+    account_id = os.environ.get("R2_ACCOUNT_ID")
+    access_key_id = os.environ.get("R2_ACCESS_KEY_ID")
+    secret_access_key = os.environ.get("R2_SECRET_ACCESS_KEY")
+    bucket = os.environ.get("R2_BUCKET")
+
+    missing = [
+        name
+        for name, value in (
+            ("R2_ACCOUNT_ID", account_id),
+            ("R2_ACCESS_KEY_ID", access_key_id),
+            ("R2_SECRET_ACCESS_KEY", secret_access_key),
+            ("R2_BUCKET", bucket),
+        )
+        if not value
+    ]
+
+    if missing:
+        raise RuntimeError(
+            "R2 upload is enabled but these environment variables are "
+            f"missing: {', '.join(missing)}"
+        )
+
+    return {
+        "account_id": account_id,
+        "access_key_id": access_key_id,
+        "secret_access_key": secret_access_key,
+        "bucket": bucket,
+        "endpoint_url": (
+            f"https://{account_id}.r2.cloudflarestorage.com"
+        ),
+    }
+
+
+def upload_best_checkpoint_to_r2(checkpoint_path: Path) -> None:
+    """Upload the completed local best.ckpt to Cloudflare R2."""
+    if not R2_UPLOAD_ENABLED:
+        return
+
+    checkpoint_path = Path(checkpoint_path)
+
+    if not checkpoint_path.is_file():
+        raise FileNotFoundError(
+            f"Cannot upload missing checkpoint: {checkpoint_path}"
+        )
+
+    try:
+        import boto3
+    except ImportError as exc:
+        raise RuntimeError(
+            "R2 upload requires boto3. Install it with: pip install boto3"
+        ) from exc
+
+    config = get_r2_config()
+
+    client = boto3.client(
+        "s3",
+        endpoint_url=config["endpoint_url"],
+        aws_access_key_id=config["access_key_id"],
+        aws_secret_access_key=config["secret_access_key"],
+        region_name="auto",
+    )
+
+    last_error = None
+
+    for attempt in range(1, R2_UPLOAD_RETRIES + 1):
+        try:
+            print(
+                f"Uploading best checkpoint to R2 "
+                f"(attempt {attempt}/{R2_UPLOAD_RETRIES})..."
+            )
+
+            client.upload_file(
+                str(checkpoint_path),
+                config["bucket"],
+                R2_OBJECT_KEY,
+            )
+
+            print(
+                "✓ R2 upload complete: "
+                f"r2://{config['bucket']}/{R2_OBJECT_KEY}"
+            )
+            return
+
+        except Exception as exc:
+            last_error = exc
+            print(
+                f"R2 upload attempt {attempt} failed: {exc}"
+            )
+
+            if attempt < R2_UPLOAD_RETRIES:
+                time.sleep(R2_RETRY_DELAY_SECONDS)
+
+    raise RuntimeError(
+        "best.ckpt was saved locally, but R2 upload failed after "
+        f"{R2_UPLOAD_RETRIES} attempts."
+    ) from last_error
+
+
+###############################################################################
+# VAST.AI AUTO-DESTROY HELPERS
+###############################################################################
+
+def get_vast_instance_id():
+    """
+    Return the current Vast instance ID.
+
+    Vast may expose CONTAINER_ID directly. Older/current environments may
+    instead expose VAST_CONTAINERLABEL in the form C.123456.
+    """
+    container_id = os.environ.get("CONTAINER_ID")
+
+    if container_id:
+        value = str(container_id).strip()
+        if value.isdigit():
+            return value
+
+    label = os.environ.get("VAST_CONTAINERLABEL")
+
+    if label:
+        value = str(label).strip()
+
+        if value.startswith("C."):
+            value = value[2:]
+
+        if value.isdigit():
+            return value
+
+    return None
+
+
+def validate_vast_auto_destroy_config(test_mode: bool) -> None:
+    """
+    Fail before a FULL training run if auto-destroy cannot be attempted.
+
+    Test mode deliberately skips this because --test never destroys.
+    """
+    if test_mode or not AUTO_DESTROY_VAST:
+        return
+
+    if shutil.which("vastai") is None:
+        raise RuntimeError(
+            "AUTO_DESTROY_VAST is enabled, but the Vast CLI is not installed. "
+            "Install it before the full run with: pip install vastai"
+        )
+
+    instance_id = get_vast_instance_id()
+
+    if instance_id is None:
+        raise RuntimeError(
+            "AUTO_DESTROY_VAST is enabled, but the current Vast instance ID "
+            "could not be determined from CONTAINER_ID or VAST_CONTAINERLABEL."
+        )
+
+
+def destroy_current_vast_instance() -> None:
+    """
+    Permanently destroy this Vast instance.
+
+    This is intentionally called only at the very end of a successful FULL
+    run and only after best.ckpt has already been uploaded successfully to R2.
+    """
+    if not AUTO_DESTROY_VAST:
+        print("\nVast auto-destroy is disabled.")
+        return
+
+    instance_id = get_vast_instance_id()
+
+    if instance_id is None:
+        raise RuntimeError(
+            "Cannot auto-destroy Vast instance: instance ID is unavailable."
+        )
+
+    command = [
+        "vastai",
+        "destroy",
+        "instance",
+        instance_id,
+        "-y",  # non-interactive confirmation
+    ]
+
+    # Vast images may expose a per-instance API key. If it is present,
+    # pass it explicitly. Otherwise the Vast CLI uses its configured key.
+    container_api_key = os.environ.get("CONTAINER_API_KEY")
+
+    if container_api_key:
+        command.extend(
+            [
+                "--api-key",
+                container_api_key,
+            ]
+        )
+
+    print(
+        "\n======================================"
+    )
+    print(
+        "AUTO-DESTROYING VAST INSTANCE"
+    )
+    print(
+        "======================================"
+    )
+    print(
+        f"Instance ID: {instance_id}"
+    )
+    print(
+        "best.ckpt has already been uploaded successfully to R2."
+    )
+    print(
+        "This instance and its local files will now be permanently destroyed."
+    )
+
+    # Make sure the final messages are visible before the container disappears.
+    import sys
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    try:
+        result = subprocess.run(
+            command,
+            check=False,
+            text=True,
+            capture_output=True,
+            timeout=60,
+        )
+    except Exception as exc:
+        raise RuntimeError(
+            f"Failed to execute Vast destroy command: {exc}"
+        ) from exc
+
+    if result.stdout:
+        print(result.stdout.strip())
+
+    if result.returncode != 0:
+        if result.stderr:
+            print(result.stderr.strip())
+
+        raise RuntimeError(
+            "Vast auto-destroy command failed. "
+            "The instance was NOT intentionally destroyed by this script."
+        )
+
+    print(
+        f"✓ Vast destroy request accepted for instance {instance_id}"
+    )
+
+
+
+###############################################################################
+# DURING-TRAINING CTC HEALTH PROBE
+###############################################################################
+
+class CTCHealthProbe(Callback):
+    """Run a fixed CTC probe and overwrite one last-known-good checkpoint."""
+
+    def __init__(
+        self,
+        manifest_path: Path,
+        stable_checkpoint_path: Path,
+        every_optimizer_steps: int = 500,
+        save_every_optimizer_steps: int = 2000,
+        sample_count: int = 4,
+    ):
+        super().__init__()
+        self.manifest_path = Path(manifest_path)
+        self.stable_checkpoint_path = Path(stable_checkpoint_path)
+        self.every_optimizer_steps = int(every_optimizer_steps)
+        self.save_every_optimizer_steps = int(save_every_optimizer_steps)
+        self.sample_count = int(sample_count)
+        self.probe_samples = None
+        self.last_probed_global_step = -1
+
+        if self.every_optimizer_steps <= 0:
+            raise ValueError("CTC probe interval must be > 0")
+        if self.save_every_optimizer_steps <= 0:
+            raise ValueError("Stable checkpoint interval must be > 0")
+        if self.save_every_optimizer_steps % self.every_optimizer_steps != 0:
+            raise ValueError(
+                "Stable checkpoint interval must be a multiple of the CTC probe interval."
+            )
+        if self.sample_count <= 0:
+            raise ValueError("CTC probe sample_count must be > 0")
+
+    def setup(self, trainer, pl_module, stage=None):
+        samples = load_validation_manifest(self.manifest_path)
+        if len(samples) < self.sample_count:
+            raise RuntimeError(
+                f"CTC probe requested {self.sample_count} samples but only "
+                f"{len(samples)} are available."
+            )
+
+        self.probe_samples = samples[:self.sample_count]
+
+        print("\n======================================")
+        print("CTC DURING-TRAINING PROBE ENABLED")
+        print("======================================")
+        print(f"Probe interval: every {self.every_optimizer_steps} optimizer steps")
+        print(
+            f"Stable checkpoint interval: every "
+            f"{self.save_every_optimizer_steps} optimizer steps, after a healthy probe"
+        )
+        print(f"Fixed probe samples: {self.sample_count}")
+        print(f"Rolling stable checkpoint: {self.stable_checkpoint_path}")
+        for i, sample in enumerate(self.probe_samples, 1):
+            print(f"  Probe {i}: {sample['audio_filepath']}")
+
+    def _run_probe(
+        self,
+        trainer,
+        pl_module,
+        global_step: int,
+    ):
+        if not self.probe_samples:
+            raise RuntimeError(
+                "CTC probe samples were not initialized."
+            )
+
+        if not hasattr(pl_module, "cur_decoder"):
+            raise RuntimeError(
+                "CTC probe expected model.cur_decoder."
+            )
+
+        was_training = pl_module.training
+        previous_decoder = getattr(
+            pl_module,
+            "cur_decoder",
+            None,
+        )
+
+        audio_paths = [
+            sample["audio_filepath"]
+            for sample in self.probe_samples
+        ]
+
+        references = [
+            sample["text"]
+            for sample in self.probe_samples
+        ]
+
+        # Keep the training model on CUDA. gpu_safe_transcribe() moves only
+        # transcription-batch tensors to the model device before NeMo forward.
+        pl_module.eval()
+        pl_module.cur_decoder = VALIDATION_DECODER
+
+        try:
+            with torch.no_grad():
+                outputs = gpu_safe_transcribe(
+                    model=pl_module,
+                    audio_paths=audio_paths,
+                    batch_size=len(audio_paths),
+                    verbose=False,
+                )
+
+                hypotheses = select_primary_transcriptions(
+                    outputs,
+                    expected_count=len(audio_paths),
+                )
+
+                normalized = [
+                    " ".join(str(value).strip().split())
+                    for value in hypotheses
+                ]
+
+        finally:
+            pl_module.cur_decoder = previous_decoder
+
+            if was_training:
+                pl_module.train()
+            else:
+                pl_module.eval()
+
+        special_values = {"<unk>", "<blank>", ""}
+        special_count = sum(
+            value in special_values
+            for value in normalized
+        )
+
+        epoch_number = trainer.current_epoch + 1
+
+        print("\n======================================")
+        print(
+            f"EPOCH {epoch_number} - "
+            f"CTC PROBE @ OPTIMIZER STEP {global_step}"
+        )
+        print("======================================")
+        print(f"CTC probe device: {next(pl_module.parameters()).device}")
+
+        for i, (reference, hypothesis) in enumerate(
+            zip(references, normalized),
+            1,
+        ):
+            print(f"  [{i}] REF : {reference}")
+            print(f"  [{i}] PRED: {hypothesis}")
+
+        print(
+            f"CTC probe special/empty: "
+            f"{special_count}/{len(normalized)}"
+        )
+
+        if normalized and special_count == len(normalized):
+            raise RuntimeError(
+                "CTC TRAINING COLLAPSE DETECTED at optimizer step "
+                f"{global_step}: all {len(normalized)} fixed probe "
+                f"hypotheses were <unk>/<blank>/empty: {normalized}."
+            )
+
+        print(
+            f"CTC probe HEALTHY at optimizer step {global_step}"
+        )
+
+        if global_step % self.save_every_optimizer_steps != 0:
+            print(
+                f"No checkpoint save at step {global_step}; "
+                f"next stable save is on a multiple of "
+                f"{self.save_every_optimizer_steps} optimizer steps."
+            )
+            return
+
+        self.stable_checkpoint_path.parent.mkdir(
+            parents=True,
+            exist_ok=True,
+        )
+
+        temp_path = self.stable_checkpoint_path.with_suffix(
+            self.stable_checkpoint_path.suffix + ".tmp"
+        )
+
+        trainer.save_checkpoint(str(temp_path))
+        os.replace(temp_path, self.stable_checkpoint_path)
+
+        print(
+            f"✓ Updated last stable checkpoint at optimizer step "
+            f"{global_step}: {self.stable_checkpoint_path}"
+        )
+
+    def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx):
+        global_step = int(trainer.global_step)
+
+        if global_step <= 0:
+            return
+        if global_step % self.every_optimizer_steps != 0:
+            return
+        if global_step == self.last_probed_global_step:
+            return
+
+        self.last_probed_global_step = global_step
+        self._run_probe(trainer, pl_module, global_step)
+
+
+###############################################################################
+# POST-EPOCH SEHAJ WER/CER + BEST CHECKPOINT + EARLY STOPPING
+###############################################################################
+
+class DomainValidationAndEarlyStopping(Callback):
+    """Validate Sehaj Paath only; keep best.ckpt on Sehaj CER or WER gains."""
+
+    def __init__(
+        self,
+        metrics_path: Path,
+        best_checkpoint_path: Path,
+        sehaj_manifest: Path,
+        batch_size: int,
+        patience: int = 5,
+        min_delta: float = 0.0001,
+    ):
+        super().__init__()
+        self.metrics_path = Path(metrics_path)
+        self.best_checkpoint_path = Path(best_checkpoint_path)
+        self.sehaj_manifest = Path(sehaj_manifest)
+        self.batch_size = int(batch_size)
+        self.patience = int(patience)
+        self.min_delta = float(min_delta)
+
+        self.best_sehaj_cer = float("inf")
+        self.best_sehaj_wer = float("inf")
+        self.selected_sehaj_cer = float("inf")
+        self.selected_sehaj_wer = float("inf")
+        self.best_epoch = None
+        self.bad_epochs = 0
+        self.history = []
+        self.r2_best_uploaded = False
+        self._seed_from_existing_metrics_json()
+
+    @staticmethod
+    def _finite_or_inf(value):
+        if value is None:
+            return float("inf")
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return float("inf")
+
+    def _seed_from_existing_metrics_json(self):
+        if not self.metrics_path.is_file():
+            return
+        try:
+            with self.metrics_path.open("r", encoding="utf-8") as handle:
+                data = json.load(handle)
+        except Exception as exc:
+            print(f"WARNING: could not seed validation history from {self.metrics_path}: {exc}")
+            return
+
+        history = data.get("history")
+        self.history = history if isinstance(history, list) else []
+        sehaj_cers = []
+        sehaj_wers = []
+        for record in self.history:
+            try:
+                sehaj = record.get("sehaj", {})
+                if sehaj.get("cer") is not None:
+                    sehaj_cers.append(float(sehaj["cer"]))
+                if sehaj.get("wer") is not None:
+                    sehaj_wers.append(float(sehaj["wer"]))
+            except (TypeError, ValueError, AttributeError):
+                continue
+
+        self.best_sehaj_cer = min(sehaj_cers) if sehaj_cers else self._finite_or_inf(
+            data.get("best_sehaj_cer")
+        )
+        self.best_sehaj_wer = min(sehaj_wers) if sehaj_wers else self._finite_or_inf(
+            data.get("best_sehaj_wer")
+        )
+        self.best_epoch = data.get("best_epoch")
+        self.bad_epochs = int(data.get("epochs_without_improvement", 0) or 0)
+
+        for record in reversed(self.history):
+            if record.get("epoch") == self.best_epoch:
+                sehaj = record.get("sehaj", {})
+                self.selected_sehaj_cer = self._finite_or_inf(sehaj.get("cer"))
+                self.selected_sehaj_wer = self._finite_or_inf(sehaj.get("wer"))
+                break
+
+        print("\nRestored Sehaj validation history from:", self.metrics_path)
+        print(f"  best-ever Sehaj CER: {self.best_sehaj_cer}")
+        print(f"  best-ever Sehaj WER: {self.best_sehaj_wer}")
+        print(f"  selected best epoch: {self.best_epoch}")
+        print(f"  epochs without improvement: {self.bad_epochs}")
+
+    def state_dict(self):
+        return {
+            "best_sehaj_cer": self.best_sehaj_cer,
+            "best_sehaj_wer": self.best_sehaj_wer,
+            "selected_sehaj_cer": self.selected_sehaj_cer,
+            "selected_sehaj_wer": self.selected_sehaj_wer,
+            "best_epoch": self.best_epoch,
+            "bad_epochs": self.bad_epochs,
+            "history": self.history,
+            "r2_best_uploaded": self.r2_best_uploaded,
+        }
+
+    def load_state_dict(self, state_dict):
+        if not state_dict:
+            return
+        # Keep JSON-seeded values when resuming a checkpoint written by an older
+        # callback version that did not yet store Sehaj CER.
+        self.best_sehaj_cer = self._finite_or_inf(
+            state_dict.get("best_sehaj_cer", self.best_sehaj_cer)
+        )
+        self.best_sehaj_wer = self._finite_or_inf(
+            state_dict.get("best_sehaj_wer", self.best_sehaj_wer)
+        )
+        self.selected_sehaj_cer = self._finite_or_inf(
+            state_dict.get("selected_sehaj_cer", self.selected_sehaj_cer)
+        )
+        self.selected_sehaj_wer = self._finite_or_inf(
+            state_dict.get("selected_sehaj_wer", self.selected_sehaj_wer)
+        )
+        self.best_epoch = state_dict.get("best_epoch", self.best_epoch)
+        self.bad_epochs = int(state_dict.get("bad_epochs", self.bad_epochs) or 0)
+        restored_history = state_dict.get("history")
+        if isinstance(restored_history, list):
+            self.history = restored_history
+        self.r2_best_uploaded = bool(
+            state_dict.get("r2_best_uploaded", self.r2_best_uploaded)
+        )
+        print("\n✓ Restored Sehaj-only validation callback state")
+        print(f"  best-ever Sehaj CER: {self.best_sehaj_cer}")
+        print(f"  best-ever Sehaj WER: {self.best_sehaj_wer}")
+        print(f"  selected best epoch: {self.best_epoch}")
+        print(f"  epochs without improvement: {self.bad_epochs}")
+
+    def write_history(self):
+        # Put the two headline percentages first inside each nested Sehaj result.
+        # Existing history entries are reordered as well when the JSON is saved.
+        for record in self.history:
+            if not isinstance(record, dict):
+                continue
+            sehaj = record.get("sehaj", {})
+            if not isinstance(sehaj, dict):
+                continue
+            sehaj = dict(sehaj)
+            if "wer_percent" not in sehaj and sehaj.get("wer") is not None:
+                sehaj["wer_percent"] = float(sehaj["wer"]) * 100.0
+            if "cer_percent" not in sehaj and sehaj.get("cer") is not None:
+                sehaj["cer_percent"] = float(sehaj["cer"]) * 100.0
+            ordered_sehaj = {
+                key: sehaj[key]
+                for key in ("wer_percent", "cer_percent")
+                if key in sehaj
+            }
+            ordered_sehaj.update(
+                (key, value)
+                for key, value in sehaj.items()
+                if key not in ("wer_percent", "cer_percent")
+            )
+            record["sehaj"] = ordered_sehaj
+
+        def optional(value):
+            return None if value == float("inf") else value
+
+        data = {
+            "selection_metric": "any_improvement_sehaj_cer_or_sehaj_wer",
+            "best_epoch": self.best_epoch,
+            "best_sehaj_cer": optional(self.best_sehaj_cer),
+            "best_sehaj_cer_percent": (
+                None if optional(self.best_sehaj_cer) is None
+                else self.best_sehaj_cer * 100.0
+            ),
+            "best_sehaj_wer": optional(self.best_sehaj_wer),
+            "best_sehaj_wer_percent": (
+                None if optional(self.best_sehaj_wer) is None
+                else self.best_sehaj_wer * 100.0
+            ),
+            "selected_checkpoint_sehaj_cer": optional(self.selected_sehaj_cer),
+            "selected_checkpoint_sehaj_wer": optional(self.selected_sehaj_wer),
+            "patience": self.patience,
+            "min_metric_improvement": self.min_delta,
+            "epochs_without_improvement": self.bad_epochs,
+            "history": self.history,
+        }
+        self.metrics_path.parent.mkdir(parents=True, exist_ok=True)
+        temp_path = self.metrics_path.with_suffix(self.metrics_path.suffix + ".tmp")
+        with temp_path.open("w", encoding="utf-8") as handle:
+            json.dump(data, handle, indent=2, ensure_ascii=False)
+        temp_path.replace(self.metrics_path)
+
+    def on_train_epoch_end(self, trainer, pl_module):
+        epoch_number = trainer.current_epoch + 1
+        print("\n======================================")
+        print("SEHAJ PAATH VALIDATION ONLY")
+        print("======================================")
+        sehaj = score_validation_manifest(
+            model=pl_module,
+            manifest_path=self.sehaj_manifest,
+            batch_size=self.batch_size,
+        )
+
+        sehaj_cer_improved = sehaj["cer"] < self.best_sehaj_cer - self.min_delta
+        sehaj_wer_improved = sehaj["wer"] < self.best_sehaj_wer - self.min_delta
+        improved = sehaj_cer_improved or sehaj_wer_improved
+        reasons = []
+        if sehaj_cer_improved:
+            reasons.append("sehaj_cer")
+        if sehaj_wer_improved:
+            reasons.append("sehaj_wer")
+        improvement_reason = "+".join(reasons) if reasons else None
+
+        if sehaj_cer_improved:
+            self.best_sehaj_cer = sehaj["cer"]
+        if sehaj_wer_improved:
+            self.best_sehaj_wer = sehaj["wer"]
+
+        if improved:
+            self.best_epoch = epoch_number
+            self.bad_epochs = 0
+            self.selected_sehaj_cer = sehaj["cer"]
+            self.selected_sehaj_wer = sehaj["wer"]
+            self.best_checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+            pl_module.train()
+            trainer.save_checkpoint(str(self.best_checkpoint_path))
+            upload_best_checkpoint_to_r2(self.best_checkpoint_path)
+            self.r2_best_uploaded = bool(R2_UPLOAD_ENABLED)
+            if not R2_UPLOAD_ENABLED:
+                print("R2 upload skipped: offline test mode.")
+            print("\nNEW BEST CHECKPOINT — SEHAJ METRIC IMPROVEMENT")
+            print(f"Epoch: {epoch_number}")
+            print(f"Sehaj CER: {sehaj['cer']:.6f} ({sehaj['cer_percent']:.3f}%)")
+            print(f"Sehaj WER: {sehaj['wer']:.6f} ({sehaj['wer_percent']:.3f}%)")
+            print(f"Selection reason: {improvement_reason}")
+            print("Saved best checkpoint:", self.best_checkpoint_path)
+        else:
+            self.bad_epochs += 1
+            print("\nNo Sehaj CER or WER improvement.")
+            print(f"Current Sehaj CER: {sehaj['cer']:.6f} ({sehaj['cer_percent']:.3f}%)")
+            print(f"Best-ever Sehaj CER: {self.best_sehaj_cer:.6f} ({self.best_sehaj_cer * 100:.3f}%)")
+            print(f"Current Sehaj WER: {sehaj['wer']:.6f} ({sehaj['wer_percent']:.3f}%)")
+            print(f"Best-ever Sehaj WER: {self.best_sehaj_wer:.6f} ({self.best_sehaj_wer * 100:.3f}%)")
+            print(f"Epochs without improvement: {self.bad_epochs}/{self.patience}")
+
+        epoch_record = {
+            "epoch": epoch_number,
+            "sehaj": sehaj,
+            "selection_metric": "any_improvement_sehaj_cer_or_sehaj_wer",
+            "improved": improved,
+            "improvement_reason": improvement_reason,
+            "sehaj_cer_improved": sehaj_cer_improved,
+            "sehaj_wer_improved": sehaj_wer_improved,
+            "best_epoch": self.best_epoch,
+            "best_sehaj_cer": self.best_sehaj_cer,
+            "best_sehaj_cer_percent": self.best_sehaj_cer * 100.0,
+            "best_sehaj_wer": self.best_sehaj_wer,
+            "best_sehaj_wer_percent": self.best_sehaj_wer * 100.0,
+            "selected_checkpoint_sehaj_cer": self.selected_sehaj_cer,
+            "selected_checkpoint_sehaj_wer": self.selected_sehaj_wer,
+            "epochs_without_improvement": self.bad_epochs,
+        }
+        self.history.append(epoch_record)
+        self.write_history()
+
+        print("\n--------------------------------------")
+        print(
+            f"Epoch {epoch_number} SEHAJ: CER {sehaj['cer_percent']:.3f}% | "
+            f"WER {sehaj['wer_percent']:.3f}%"
+        )
+        print("Checkpoint rule: promote when Sehaj CER OR Sehaj WER improves.")
+        print(f"Minimum required improvement: {self.min_delta}")
+        print(f"Metrics JSON: {self.metrics_path}")
+        print("--------------------------------------")
+
+        if self.bad_epochs >= self.patience:
+            print("\n########################################")
+            print("EARLY STOPPING: NO SEHAJ METRIC IMPROVEMENT")
+            print("########################################")
+            print(f"No Sehaj CER or WER improvement for {self.bad_epochs} epochs.")
+            print(f"Selected best epoch: {self.best_epoch}")
+            print(f"Best-ever Sehaj CER: {self.best_sehaj_cer:.6f} ({self.best_sehaj_cer * 100:.3f}%)")
+            print(f"Best-ever Sehaj WER: {self.best_sehaj_wer:.6f} ({self.best_sehaj_wer * 100:.3f}%)")
+            trainer.should_stop = True
+
+
+###############################################################################
+# POST-EPOCH: KEEP LAST TWO EPOCH CHECKPOINTS
+###############################################################################
+
+class LastTwoEpochCheckpoints(Callback):
+    """
+    Save one checkpoint after every completed training epoch.
+
+    Keep only the latest two:
+
+        epoch_004.ckpt
+        epoch_005.ckpt
+
+    When epoch 6 finishes:
+
+        epoch_004.ckpt -> deleted
+        epoch_005.ckpt -> kept
+        epoch_006.ckpt -> saved
+
+    best.ckpt is NOT deleted by this callback.
+    """
+
+    def __init__(
+        self,
+        dirpath: Path,
+    ):
+        super().__init__()
+
+        self.dirpath = Path(
+            dirpath
+        )
+
+    def on_train_epoch_end(
+        self,
+        trainer,
+        pl_module,
+    ):
+
+        self.dirpath.mkdir(
+            parents=True,
+            exist_ok=True,
+        )
+
+        epoch_number = (
+            trainer.current_epoch + 1
+        )
+
+        checkpoint_path = (
+            self.dirpath
+            / f"epoch_{epoch_number:03d}.ckpt"
+        )
+
+        trainer.save_checkpoint(
+            str(checkpoint_path)
+        )
+
+        print(
+            "\nSaved epoch checkpoint:"
+        )
+
+        print(
+            checkpoint_path
+        )
+
+        # Only look at epoch_XXX.ckpt files.
+        # best.ckpt will therefore never be removed.
+        checkpoints = sorted(
+            self.dirpath.glob(
+                "epoch_*.ckpt"
+            )
+        )
+
+        while len(checkpoints) > 2:
+
+            oldest_checkpoint = (
+                checkpoints.pop(0)
+            )
+
+            try:
+                oldest_checkpoint.unlink()
+
+                print(
+                    "Removed old epoch checkpoint:"
+                )
+
+                print(
+                    oldest_checkpoint
+                )
+
+            except FileNotFoundError:
+                pass
+
+
+###############################################################################
+# DATASET CONFIGURATION
+###############################################################################
+
+def make_dataset_config(
+    manifest_path: Path,
+    shuffle: bool,
+):
+    """
+    Build a fresh NeMo dataset configuration for Punjabi ('pa') fine-tuning
+    of the multilingual Gurbani model.
+
+    Fresh train_ds and validation_ds configs are created here at fine-tuning
+    time. The manifests provide lang='pa' and NeMo is asked to return the
+    language ID so the multilingual model uses the Punjabi path.
+    """
+
+    return OmegaConf.create({
+        "manifest_filepath": [
+            str(manifest_path)
+        ],
+        "sample_rate": EXPECTED_SAMPLE_RATE,
+        "batch_size": BATCH_SIZE,
+        "shuffle": shuffle,
+        "num_workers": 2,
+        "pin_memory": False,
+        "persistent_workers": False,
+        "max_duration": None,
+        "min_duration": 0.0,
+        "is_tarred": False,
+        "tarred_audio_filepaths": None,
+        "use_start_end_token": False,
+
+        # IMPORTANT: this is a multilingual model. The manifests contain
+        # lang="pa", and the dataset must return the language ID.
+        "return_language_id": True,
+    })
+
+
+
+###############################################################################
+# PATH VALIDATION
+###############################################################################
+
+def validate_paths() -> None:
+
+    if not DATA_ROOT.exists():
+        raise FileNotFoundError(
+            f"DATA_ROOT does not exist: "
+            f"{DATA_ROOT}"
+        )
+
+    if not DATA_ROOT.is_dir():
+        raise ValueError(
+            f"DATA_ROOT is not a directory: "
+            f"{DATA_ROOT}"
+        )
+
+    if not TRAIN_MANIFEST.exists():
+        raise FileNotFoundError(
+            "Training manifest not found: "
+            f"{TRAIN_MANIFEST}"
+        )
+
+    if not SEHAJ_VAL_MANIFEST.exists():
+        raise FileNotFoundError(
+            "Sehaj validation manifest not found: "
+            f"{SEHAJ_VAL_MANIFEST}"
+        )
+
+    if not MODEL_PATH.exists():
+        raise FileNotFoundError(
+            "NeMo model not found: "
+            f"{MODEL_PATH}"
+        )
+
+    # A brand-new [72,23] run initializes from START_CHECKPOINT_PATH. Later
+    # restarts resume from its own rolling stable checkpoint.
+    if not LAST_STABLE_CHECKPOINT_PATH.exists():
+        if (
+            START_CHECKPOINT_PATH is not None
+            and not START_CHECKPOINT_PATH.exists()
+        ):
+            raise FileNotFoundError(
+                "Optional initialization checkpoint not found: "
+                f"{START_CHECKPOINT_PATH}"
+            )
+
+    if R2_UPLOAD_ENABLED:
+        # Validate required R2 environment variables before long training starts.
+        get_r2_config()
+
+
+###############################################################################
+# LOAD STAGE-2 BEST CHECKPOINT WEIGHTS ONLY
+###############################################################################
+
+def load_start_checkpoint_weights(model) -> None:
+    """Optionally load checkpoint model weights without optimizer state."""
+
+    if START_CHECKPOINT_PATH is None:
+        print(
+            "\nNo starting checkpoint configured. "
+            "Using MODEL_PATH weights directly."
+        )
+        return
+
+    print("\n======================================")
+    print("LOADING OPTIONAL START CHECKPOINT WEIGHTS")
+    print("======================================")
+    print(START_CHECKPOINT_PATH)
+
+    checkpoint = torch.load(
+        str(START_CHECKPOINT_PATH),
+        map_location="cpu",
+    )
+
+    state_dict = checkpoint.get(
+        "state_dict",
+        checkpoint,
+    )
+
+    result = model.load_state_dict(
+        state_dict,
+        strict=False,
+    )
+
+    missing = list(result.missing_keys)
+    unexpected = list(result.unexpected_keys)
+
+    print(f"Missing keys: {len(missing)}")
+    print(f"Unexpected keys: {len(unexpected)}")
+
+    if missing:
+        for key in missing[:30]:
+            print("  MISSING:", key)
+
+    if unexpected:
+        for key in unexpected[:30]:
+            print("  UNEXPECTED:", key)
+
+    if missing or unexpected:
+        raise RuntimeError(
+            "Starting checkpoint does not cleanly match "
+            "the restored .nemo model."
+        )
+
+    print("✓ Starting checkpoint weights loaded cleanly")
+    print("✓ Old optimizer state NOT restored")
+    print("✓ Old scheduler state NOT restored")
+
+
+###############################################################################
+# CACHE-AWARE ENCODER CONVERSION
+###############################################################################
+
+def rebuild_encoder_cache_aware(model, attention_context) -> None:
+    """
+    Rebuild the existing Conformer encoder for one cache-aware/chunked-limited
+    attention context while preserving all learned encoder weights.
+
+    This helper rebuilds the encoder for the requested cache-aware context
+    while preserving the learned encoder weights.
+    """
+
+    attention_context = list(attention_context)
+
+    print("\n======================================")
+    print("CACHE-AWARE ENCODER CONVERSION")
+    print("======================================")
+
+    old_cfg = copy.deepcopy(model.cfg.encoder)
+
+    print("Original attention context:", old_cfg.get("att_context_size"))
+    print("Original attention probabilities:", old_cfg.get("att_context_probs", None))
+    print("Original attention style:", old_cfg.get("att_context_style", "regular"))
+    print("Original convolution context:", old_cfg.get("conv_context_size", None))
+
+    old_state = copy.deepcopy(model.encoder.state_dict())
+    new_cfg = copy.deepcopy(old_cfg)
+
+    with open_dict(new_cfg):
+        new_cfg.att_context_size = attention_context
+        new_cfg.att_context_probs = None
+        new_cfg.att_context_style = "chunked_limited"
+        new_cfg.conv_context_size = CAUSAL_CONV_CONTEXT
+
+    print("\nRebuilding encoder...")
+    print("Attention context:", attention_context)
+    print("Attention style: chunked_limited")
+    print("Convolution context:", CAUSAL_CONV_CONTEXT)
+
+    new_encoder = instantiate(new_cfg)
+    new_encoder.load_state_dict(old_state, strict=True)
+
+    model.encoder = new_encoder
+
+    with open_dict(model.cfg):
+        model.cfg.encoder = new_cfg
+
+    print("✓ Existing encoder weights loaded strict=True")
+    print(f"✓ Full-data streaming context: {attention_context}")
+    print("✓ Causal convolution: [30,0]")
+    print("======================================\n")
+
+
+###############################################################################
+# MODEL INFORMATION
+###############################################################################
+
+def print_model_information(
+    model,
+) -> None:
+
+    total_parameters = sum(
+        parameter.numel()
+        for parameter
+        in model.parameters()
+    )
+
+    trainable_parameters = sum(
+        parameter.numel()
+        for parameter
+        in model.parameters()
+        if parameter.requires_grad
+    )
+
+    frozen_parameters = (
+        total_parameters
+        - trainable_parameters
+    )
+
+    print(
+        "\n======================================"
+    )
+
+    print(
+        "MODEL INFORMATION"
+    )
+
+    print(
+        "======================================"
+    )
+
+    print(
+        f"Total parameters: "
+        f"{total_parameters:,}"
+    )
+
+    print(
+        f"Trainable parameters: "
+        f"{trainable_parameters:,}"
+    )
+
+    print(
+        f"Frozen parameters: "
+        f"{frozen_parameters:,}"
+    )
+
+    print(
+        "======================================"
+    )
+
+
+###############################################################################
+# COMMAND LINE
+###############################################################################
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune the Gurbani/Punjabi NeMo ASR model."
+    )
+    parser.add_argument(
+        "--test",
+        action="store_true",
+        help=(
+            "Use the small *-test.json manifests for an infrastructure "
+            "test run. Test artifacts are written under "
+            "/workspace/asr_training_test."
+        ),
+    )
+    parser.add_argument(
+        "--offline",
+        action="store_true",
+        help=(
+            "TEST MODE ONLY: disable all Cloudflare R2 validation/uploads. "
+            "Use as: python train.py --test --offline"
+        ),
+    )
+
+    args = parser.parse_args()
+
+    if args.offline and not args.test:
+        parser.error("--offline is only allowed together with --test")
+
+    return args
+
+
+###############################################################################
+# MAIN
+###############################################################################
+
+def main() -> None:
+
+    args = parse_args()
+    configure_manifests(test_mode=args.test)
+    configure_outputs(
+        test_mode=args.test,
+        offline=args.offline,
+    )
+
+    # Test mode runs only 2 epochs.
+    max_epochs = 2 if args.test else MAX_EPOCHS
+
+    if args.test and args.offline:
+        run_mode = "TEST OFFLINE (*-test.json manifests, 2 epochs, NO R2)"
+    elif args.test:
+        run_mode = "TEST (*-test.json manifests, 2 epochs, separate R2 test checkpoint)"
+    else:
+        run_mode = "FULL"
+
+    print(
+        "\nRUN MODE:",
+        run_mode,
+    )
+
+    validate_vast_auto_destroy_config(
+        test_mode=args.test
+    )
+    validate_paths()
+
+    if not torch.cuda.is_available():
+        raise RuntimeError(
+            "CUDA GPU is not available. This script is configured for Vast GPU training."
+        )
+
+    print("\nGPU:", torch.cuda.get_device_name(0))
+    print("CUDA version:", torch.version.cuda)
+
+    # Create all output directories under /workspace.
+    OUTPUT_ROOT.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    CHECKPOINT_DIR.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    print(
+        "======================================"
+    )
+
+    print(
+        "GURBANI PUNJABI (pa) STREAMING FINE-TUNING"
+    )
+
+    print(
+        "======================================"
+    )
+
+    print(
+        f"Training manifest:"
+    )
+
+    print(
+        TRAIN_MANIFEST
+    )
+
+    print("\nSehaj Paath validation manifest:")
+
+    print(
+        SEHAJ_VAL_MANIFEST
+    )
+
+    print(
+        f"\nBase model:"
+    )
+
+    print(
+        MODEL_PATH
+    )
+
+    print(
+        f"\nStarting checkpoint:"
+    )
+
+    print(
+        START_CHECKPOINT_PATH
+        if START_CHECKPOINT_PATH is not None
+        else "None — using MODEL_PATH only"
+    )
+
+    print(
+        f"\nOutput model:"
+    )
+
+    print(
+        OUTPUT_MODEL
+    )
+
+    print(
+        f"\nEpoch metrics JSON:"
+    )
+
+    print(
+        EPOCH_METRICS_PATH
+    )
+
+    print(
+        f"\nOutput root:"
+    )
+
+    print(
+        OUTPUT_ROOT
+    )
+
+    print(
+        f"\nCheckpoint directory:"
+    )
+
+    print(
+        CHECKPOINT_DIR
+    )
+
+    if R2_UPLOAD_ENABLED:
+        r2_config = get_r2_config()
+        print(
+            f"\nR2 best-checkpoint backup: "
+            f"r2://{r2_config['bucket']}/{R2_OBJECT_KEY}"
+        )
+    else:
+        print(
+            "\nR2 backup: DISABLED (--test --offline)"
+        )
+
+    print(
+        "\nLoading Gurbani/Punjabi multilingual model..."
+    )
+
+    model = (
+        nemo_asr.models.ASRModel.restore_from(
+            restore_path=str(
+                MODEL_PATH
+            )
+        )
+    )
+
+    # Fail early if the architecture/tokenizer model is not the expected export.
+    # Its weights are initialized from best.ckpt before rebuilding to [72,23].
+    loaded_context = model.cfg.encoder.get("att_context_size", None)
+    if loaded_context is None:
+        raise RuntimeError(
+            "Starting model does not specify encoder.att_context_size; "
+            f"expected {SOURCE_MODEL_ATT_CONTEXT} from {MODEL_PATH}."
+        )
+    loaded_context = [int(value) for value in loaded_context]
+    print("Starting model attention context:", loaded_context)
+    if loaded_context != SOURCE_MODEL_ATT_CONTEXT:
+        raise RuntimeError(
+            "Wrong starting model context: "
+            f"expected {SOURCE_MODEL_ATT_CONTEXT}, got {loaded_context}. "
+            f"Model path: {MODEL_PATH}"
+        )
+
+    # Decide whether this is the first [72,23] run or a restart of that run.
+    resume_ckpt = (
+        LAST_STABLE_CHECKPOINT_PATH
+        if LAST_STABLE_CHECKPOINT_PATH.exists()
+        else None
+    )
+
+    if resume_ckpt is None:
+        print(
+            "\nNo [72,23] stable checkpoint exists. "
+            "This is the FIRST [72,23] run; initializing weights from the prior best.ckpt."
+        )
+        load_start_checkpoint_weights(model)
+    else:
+        print(
+            "\nFound [72,23] rolling stable checkpoint. "
+            "Lightning will restore the full [72,23] training state."
+        )
+        print(resume_ckpt)
+
+    # --------------------------------------------------------
+    # Verify that the restored multilingual model supports Punjabi ('pa').
+    # Keep the original multilingual vocabulary and language masks intact.
+    # --------------------------------------------------------
+
+    tokenizer_vocab_size = getattr(
+        model.tokenizer,
+        "vocab_size",
+        None,
+    )
+
+    print(
+        "\nLoaded tokenizer vocabulary:",
+        tokenizer_vocab_size,
+    )
+
+    if tokenizer_vocab_size is None:
+        raise RuntimeError(
+            "Could not determine tokenizer vocabulary size."
+        )
+
+    tokenizer_langs = getattr(
+        model.tokenizer,
+        "langs",
+        None,
+    )
+
+    print(
+        "Tokenizer languages:",
+        tokenizer_langs,
+    )
+
+    if tokenizer_langs is None or LANGUAGE_CODE not in tokenizer_langs:
+        raise RuntimeError(
+            f"Restored multilingual tokenizer does not contain "
+            f"Punjabi ({LANGUAGE_CODE!r})."
+        )
+
+    rnnt_vocab_size = getattr(
+        model.decoder,
+        "vocab_size",
+        None,
+    )
+
+    print(
+        "RNNT decoder vocabulary:",
+        rnnt_vocab_size,
+    )
+
+    if rnnt_vocab_size is None:
+        raise RuntimeError(
+            "Could not determine RNNT decoder vocabulary size."
+        )
+
+    if hasattr(model, "ctc_decoder"):
+        ctc_vocab_size = len(
+            getattr(
+                model.ctc_decoder,
+                "vocabulary",
+                [],
+            )
+        )
+
+        print(
+            "CTC decoder vocabulary:",
+            ctc_vocab_size,
+        )
+
+        language_masks = getattr(
+            model.ctc_decoder,
+            "language_masks",
+            None,
+        )
+
+        print(
+            "CTC language masks present:",
+            language_masks is not None,
+        )
+
+    print(
+        f"✓ Multilingual model with Punjabi ({LANGUAGE_CODE!r}) support verified"
+    )
+
+    print_model_information(
+        model
+    )
+
+    print(
+        "\nCreating fresh Punjabi (pa) training "
+        "and validation dataset configs..."
+    )
+
+    train_cfg = make_dataset_config(
+        manifest_path=TRAIN_MANIFEST,
+        shuffle=True,
+    )
+
+    # Validation is performed explicitly by DomainValidationAndEarlyStopping
+    # at on_train_epoch_end().
+    #
+    # IMPORTANT:
+    # NeMo's model.transcribe() still reads model.cfg.validation_ds internally
+    # (for fields such as use_start_end_token), so validation_ds must NOT be None.
+    # Keep a valid Sehaj validation config here, but Lightning's built-in
+    # validation loop remains disabled with limit_val_batches=0 below.
+    validation_cfg = make_dataset_config(
+        manifest_path=SEHAJ_VAL_MANIFEST,
+        shuffle=False,
+    )
+
+    OmegaConf.set_struct(
+        train_cfg,
+        False,
+    )
+
+    OmegaConf.set_struct(
+        validation_cfg,
+        False,
+    )
+
+    with open_dict(
+        model.cfg
+    ):
+
+        model.cfg.train_ds = train_cfg
+        model.cfg.validation_ds = validation_cfg
+        model.cfg.test_ds = None
+
+        # Keep the conservative fine-tuning LR.
+        model.cfg.optim.lr = (
+            LEARNING_RATE
+        )
+
+    print(
+        "\nTraining dataset config:"
+    )
+    print(
+        OmegaConf.to_yaml(
+            model.cfg.train_ds
+        )
+    )
+
+    print(
+        "\nValidation mode: explicit post-epoch transcription "
+        "(Lightning validation disabled)"
+    )
+    print(f"Sehaj Paath validation only: {SEHAJ_VAL_MANIFEST}")
+
+    print(
+        "\nTraining configuration:"
+    )
+
+    print(
+        f"Batch size: "
+        f"{BATCH_SIZE}"
+    )
+
+    print(
+        f"Gradient accumulation: "
+        f"{ACCUMULATE_GRAD_BATCHES}"
+    )
+
+    print(
+        f"Effective batch size: "
+        f"{BATCH_SIZE * ACCUMULATE_GRAD_BATCHES}"
+    )
+
+    print(
+        f"Learning rate: "
+        f"{LEARNING_RATE}"
+    )
+
+    print(
+        f"Maximum epochs: "
+        f"{max_epochs}"
+    )
+
+    print(
+        f"Early-stop patience: "
+        f"{EARLY_STOP_PATIENCE}"
+    )
+
+    print(
+        f"Minimum WER improvement: "
+        f"{MIN_METRIC_IMPROVEMENT}"
+    )
+
+    print(
+        f"Streaming attention context (full data): "
+        f"{STREAM_ATT_CONTEXTS}"
+    )
+
+    print(
+        f"Causal convolution context: "
+        f"{CAUSAL_CONV_CONTEXT}"
+    )
+
+    # ------------------------------------------------------------------
+    # Full-data streaming training
+    # ------------------------------------------------------------------
+    # Train the complete selected manifest using the configured [72,23]
+    # streaming attention context.
+    # ------------------------------------------------------------------
+
+    for stage_index, attention_context in enumerate(STREAM_ATT_CONTEXTS, start=1):
+        context_tag = f"{attention_context[0]}_{attention_context[1]}"
+        stage_root = OUTPUT_ROOT
+        stage_checkpoint_dir = stage_root / "checkpoints"
+        stage_best_checkpoint = stage_checkpoint_dir / "best.ckpt"
+        stage_metrics_path = stage_root / "epoch_metrics.json"
+        stage_stable_checkpoint = LAST_STABLE_CHECKPOINT_PATH
+
+        stage_root.mkdir(parents=True, exist_ok=True)
+        stage_checkpoint_dir.mkdir(parents=True, exist_ok=True)
+
+        print("\n############################################################")
+        print(
+            f"FULL-DATA STREAMING TRAINING - ATTENTION {attention_context}"
+        )
+        print("############################################################")
+
+        rebuild_encoder_cache_aware(
+            model,
+            attention_context=attention_context,
+        )
+
+        # Keep the dataset config unchanged, so this stage consumes the entire
+        # selected training manifest once per epoch.
+        model.setup_training_data(
+            model.cfg.train_ds
+        )
+
+        # The pre-train transcription health check runs before trainer.fit().
+        # Lightning has therefore not yet moved the model to the GPU. Move the
+        # full hybrid model explicitly so model parameters, preprocessor/STFT
+        # buffers, and the patched transcribe input tensors all use cuda:0.
+        model.to(torch.device("cuda:0"))
+        print(f"Pre-train health-check model device: {next(model.parameters()).device}")
+
+        # Verify CTC after changing the streaming attention context and before
+        # the first optimizer step of this stage.
+        run_pretrain_ctc_health_check(
+            model=model,
+            batch_size=BATCH_SIZE,
+        )
+
+        stage_domain_validation_callback = DomainValidationAndEarlyStopping(
+            metrics_path=stage_metrics_path,
+            best_checkpoint_path=stage_best_checkpoint,
+            sehaj_manifest=SEHAJ_VAL_MANIFEST,
+            batch_size=BATCH_SIZE,
+            patience=EARLY_STOP_PATIENCE,
+            min_delta=MIN_METRIC_IMPROVEMENT,
+        )
+
+        stage_checkpoint_callback = LastTwoEpochCheckpoints(
+            dirpath=stage_checkpoint_dir
+        )
+
+        stage_ctc_probe_callback = CTCHealthProbe(
+            manifest_path=SEHAJ_VAL_MANIFEST,
+            stable_checkpoint_path=stage_stable_checkpoint,
+            every_optimizer_steps=CTC_PROBE_EVERY_OPTIMIZER_STEPS,
+            save_every_optimizer_steps=CTC_STABLE_CHECKPOINT_EVERY_OPTIMIZER_STEPS,
+            sample_count=CTC_PROBE_SAMPLE_COUNT,
+        )
+
+        trainer = pl.Trainer(
+            accelerator="gpu",
+            devices=1,
+            max_epochs=max_epochs,
+            precision=16,
+            accumulate_grad_batches=ACCUMULATE_GRAD_BATCHES,
+            log_every_n_steps=100,
+            limit_val_batches=0,
+            default_root_dir=str(stage_root / "lightning"),
+            enable_checkpointing=False,
+            callbacks=[
+                EpochProgressBar(),
+                EpochTimer(),
+                stage_ctc_probe_callback,
+                stage_domain_validation_callback,
+                stage_checkpoint_callback,
+            ],
+        )
+
+        model.set_trainer(trainer)
+
+        print("\n======================================")
+        print(
+            f"STARTING FULL-DATA STREAM TRAINING "
+            f"FOR ATTENTION {attention_context}"
+        )
+        print("======================================")
+
+        if resume_ckpt is not None:
+            print(
+                "\nResuming FULL [72,23] Lightning state from: "
+                f"{resume_ckpt}"
+            )
+        else:
+            print(
+                "\nStarting fresh [72,23] training with model weights from: "
+                f"{START_CHECKPOINT_PATH}"
+            )
+            print("Optimizer/scheduler state: FRESH")
+
+        try:
+            trainer.fit(
+                model,
+                ckpt_path=str(resume_ckpt)
+                if resume_ckpt is not None
+                else None,
+            )
+        except Exception:
+            print("\n======================================")
+            print("STREAM TRAINING STOPPED / FAILED")
+            print("======================================")
+            print("Attention context:", attention_context)
+            print("Last CTC-verified stable checkpoint:")
+            print(stage_stable_checkpoint)
+            raise
+
+        print(
+            f"\n✓ Completed full-data streaming training: "
+            f"attention {attention_context}"
+        )
+
+        # Restore the best streaming weights before final export.
+        if stage_best_checkpoint.exists():
+            print("Loading best streaming checkpoint before continuing:")
+            print(stage_best_checkpoint)
+            checkpoint = torch.load(
+                str(stage_best_checkpoint),
+                map_location="cpu",
+            )
+            state_dict = checkpoint.get("state_dict", checkpoint)
+            result = model.load_state_dict(state_dict, strict=False)
+
+            missing = list(result.missing_keys)
+            unexpected = list(result.unexpected_keys)
+
+            if missing or unexpected:
+                print("Missing keys:", missing[:30])
+                print("Unexpected keys:", unexpected[:30])
+                raise RuntimeError(
+                    "Best streaming checkpoint did not cleanly reload."
+                )
+
+            print("✓ Best streaming weights restored")
+
+    print(
+        "\n======================================"
+    )
+
+    print(
+        "TRAINING FINISHED"
+    )
+
+    print(
+        "======================================"
+    )
+
+    print("Last CTC-verified stable checkpoint:")
+    print(LAST_STABLE_CHECKPOINT_PATH)
+    print("This checkpoint resumes the full [72,23] Lightning training state.")
+
+    if (
+        stage_domain_validation_callback.best_epoch
+        is not None
+    ):
+
+        print(
+            f"Best epoch: "
+            f"{stage_domain_validation_callback.best_epoch}"
+        )
+
+        print(
+            f"Best Sehaj validation CER: "
+            f"{stage_domain_validation_callback.best_sehaj_cer:.6f} "
+            f"({stage_domain_validation_callback.best_sehaj_cer * 100:.3f}%)"
+        )
+
+        print(
+            f"Best Sehaj validation WER: "
+            f"{stage_domain_validation_callback.best_sehaj_wer:.6f} "
+            f"({stage_domain_validation_callback.best_sehaj_wer * 100:.3f}%)"
+        )
+
+        print(
+            f"Best checkpoint: "
+            f"{BEST_CHECKPOINT_PATH}"
+        )
+
+    print(
+        "\nLast two epoch checkpoints:"
+    )
+
+    last_checkpoints = sorted(
+        CHECKPOINT_DIR.glob(
+            "epoch_*.ckpt"
+        )
+    )
+
+    for checkpoint in last_checkpoints:
+        print(
+            f"  {checkpoint}"
+        )
+
+    print(
+        "\nSaving final training-state "
+        ".nemo model to:"
+    )
+
+    print(
+        OUTPUT_MODEL
+    )
+
+    model.save_to(
+        str(
+            OUTPUT_MODEL
+        )
+    )
+
+    print(
+        "\n======================================"
+    )
+
+    print(
+        "COMPLETE"
+    )
+
+    print(
+        "======================================"
+    )
+
+    print(
+        f"Final model: "
+        f"{OUTPUT_MODEL}"
+    )
+
+    print(
+        f"Best checkpoint: "
+        f"{BEST_CHECKPOINT_PATH}"
+    )
+
+    print(
+        f"Epoch metrics: "
+        f"{EPOCH_METRICS_PATH}"
+    )
+
+    # Never destroy during infrastructure testing.
+    if args.test:
+        if args.offline:
+            print(
+                "\nTEST OFFLINE MODE: no R2 upload was attempted."
+            )
+        print(
+            "TEST MODE: Vast instance will NOT be destroyed."
+        )
+
+    elif not AUTO_DESTROY_VAST:
+        print(
+            "\nAUTO_DESTROY_VAST is disabled; instance will remain running."
+        )
+
+    elif stage_domain_validation_callback.best_epoch is None:
+        print(
+            "\nVast instance NOT destroyed: no best checkpoint was produced."
+        )
+
+    elif not stage_domain_validation_callback.r2_best_uploaded:
+        print(
+            "\nVast instance NOT destroyed: best.ckpt was not confirmed "
+            "uploaded to R2."
+        )
+
+    else:
+        destroy_current_vast_instance()
+
+
+###############################################################################
+# ENTRY POINT
+###############################################################################
+
+if __name__ == "__main__":
+    main()