|
|
| """
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)
|
|
|
|
|
|
|
|
|
|
|
|
|
| def parse_args():
|
| p = argparse.ArgumentParser(
|
| description="Multi-GPU Nemotron Streaming ASR Training (Multilingual)",
|
| formatter_class=argparse.ArgumentDefaultsHelpFormatter,
|
| )
|
|
|
| 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)")
|
|
|
|
|
| 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.")
|
|
|
|
|
| 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)
|
|
|
|
|
| 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)
|
|
|
|
|
| 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])
|
|
|
|
|
| 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()
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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")
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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:
|
|
|
| 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()
|
|
|
|
|
| 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)
|
|
|
|
|
| setup_spec_augment(student, args)
|
|
|
|
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)
|
|
|
|
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)
|
|
|
|
|
| model = student.module if isinstance(student, DDP) else student
|
|
|
|
|
| mel, mel_len = model.preprocessor(input_signal=audio, length=audio_len)
|
|
|
|
|
| if model.spec_augmentation is not None and model.training:
|
| mel = model.spec_augmentation(input_spec=mel, length=mel_len)
|
|
|
|
|
| enc, enc_len = model.encoder(audio_signal=mel, length=mel_len)
|
|
|
|
|
| dec_out = model.decoder(targets=tokens, 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=tokens,
|
| transcript_lengths=token_len, compute_wer=False,
|
| )
|
| loss = result[0]
|
| else:
|
| joint_out = model.joint(encoder_outputs=enc, decoder_outputs=dec_out)
|
| loss = model.loss(
|
| log_probs=joint_out, targets=tokens,
|
| input_lengths=enc_len, target_lengths=token_len,
|
| )
|
|
|
|
|
| if loss.dim() > 0:
|
| loss = loss.mean()
|
|
|
| return loss
|
|
|
|
|
|
|
|
|
|
|
|
|
| @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)
|
|
|
|
|
| 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)
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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()
|
|
|
|
|
| if train_sampler is not None:
|
| train_sampler.set_epoch(epoch)
|
|
|
|
|
| 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)"
|
|
|
|
|
| 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)
|
|
|
|
|
| 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)
|
|
|
|
|
| if is_main(rank) and val_manifest and (epoch + 1) % args.eval_every_epoch == 0:
|
| try:
|
| print_rank0(f"\n Evaluating...", rank)
|
|
|
|
|
| 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)
|
|
|
|
|
| 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)
|
|
|
|
|
| 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)
|
|
|
|
|
| if is_distributed:
|
| dist.barrier()
|
|
|
|
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)
|
|
|
|
|
| print_rank0(f"\n[1/3] Loading model...", rank)
|
| student = load_student(args, device, rank)
|
|
|
|
|
| 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)
|
|
|
|
|
| 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)),
|
| )
|
|
|
|
|
| print_rank0(f"\n[3/3] Starting training...", rank)
|
| student = train(
|
| student, train_loader, train_sampler,
|
| args.val_manifest, device, args, rank, is_distributed,
|
| )
|
|
|
|
|
| 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()
|
|
|
