Blame for train_multilingual_nemotron.py

#!/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()