Function evaluate

pytorch-conformer-train-quantize/training/train.py:197–238

Return (WER %, mean validation loss).

(
        model: nn.Module,
        loader: DataLoader,
        device: torch.device,
        loss_fn: nn.Module,
)

@torch.no_grad()
def evaluate(
        model: nn.Module,
        loader: DataLoader,
        device: torch.device,
        loss_fn: nn.Module,
) -> tuple[float, float]:
    """Return (WER %, mean validation loss)."""
    model.eval()
    total_edits = total_words = 0
    val_loss_sum = 0.0
    val_steps = 0
    first_batch_done = False
    for feats, feat_lens, tgts, tgt_lens, refs in tqdm(loader, leave=False):
        feats     = feats.to(device, non_blocking=True)
        feat_lens = feat_lens.to(device, non_blocking=True)
        tgts      = tgts.to(device, non_blocking=True)
        tgt_lens  = tgt_lens.to(device, non_blocking=True)

        logits, logit_lens = model(feats, feat_lens)

        vloss = loss_fn(
            logits.transpose(0, 1),
            tgts, logit_lens, tgt_lens
        )
        val_loss_sum += vloss.item()
        val_steps += 1

        hyps = greedy_decode(logits.cpu(), logit_lens.cpu())

        if not first_batch_done:
            print("\n── Decoding debug (first batch) ──")
            for ref, hyp in list(zip(refs, hyps)):
                print(f"REF: {ref.lower()}", f"\nHYP: {hyp}")
            first_batch_done = True

        for ref, hyp in zip(refs, hyps):
            total_edits += F.edit_distance(ref.split(), hyp.split())
            total_words += len(ref.split())

    wer = 100 * total_edits / total_words if total_words else 0.0
    val_loss = val_loss_sum / max(val_steps, 1)
    return wer, val_loss

# -----------------------------------------------------------------------------
# Argument parsing