scripts/eval_multilang.py

#!/usr/bin/env python3
"""
Multilingual Script-Fidelity Evaluation.

Evaluates ASR models on FLEURS test splits for ten languages and computes:
  - WER, CER (standard metrics)
  - Script Fidelity (SF): fraction of hypothesis characters in the target script
  - Dominant script label per utterance

Output: analysis/sf_results.csv  (one row per model × language)
        analysis/sf_utterances/   (per-utterance JSONs for qualitative analysis)

All ten FLEURS test splits, including Pashto (ps_af), are loaded via
Hugging Face datasets.

Usage
-----
  uv run python scripts/eval_multilang.py \\
      --hf-token hf_xxx \\
      --results-dir /workspace/results_multilang \\
      --hub-repo ANONYMIZED_OUTPUT_REPO \\
      --languages pashto hindi bengali malayalam somali georgian urdu arabic persian tamil \\
      --whisper-sizes tiny base small medium large-v2 large-v3 turbo \\
      --run-mms --run-seamless

Environment variables (fallbacks):
  HF_TOKEN, RESULTS_DIR, HUB_REPO
"""

import argparse, os, sys, json, re, time, unicodedata, logging
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(Path(__file__).parent))
from runtime_cache import configure_runtime_cache

configure_runtime_cache(ROOT)

import numpy as np
import pandas as pd
import torch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
from tqdm import tqdm
from datasets import load_dataset, Audio
from evaluate import load as load_metric
from huggingface_hub import login, HfApi

# Script fidelity module (co-located in this scripts/ directory)
from script_fidelity import (
    compute_sfr, compute_sfr_batch, dominant_script, SCRIPT_CONFIGS
)

# ── LOGGING ───────────────────────────────────────────────────────────────────
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s %(levelname)s %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)],
)
log = logging.getLogger(__name__)


# ── ARGUMENT PARSING ──────────────────────────────────────────────────────────
def parse_args():
    p = argparse.ArgumentParser(description='Multilingual script-fidelity ASR benchmark')
    p.add_argument('--hf-token',    default=os.environ.get('HF_TOKEN', ''))
    p.add_argument('--results-dir', default=os.environ.get('RESULTS_DIR', './results_multilang'))
    p.add_argument('--hub-repo',    default=os.environ.get('HUB_REPO', ''))
    p.add_argument('--hub-private', action='store_true')
    p.add_argument('--languages',   nargs='+',
                   default=['pashto', 'hindi', 'bengali', 'malayalam', 'somali',
                            'georgian', 'urdu', 'arabic', 'persian', 'tamil'],
                   help='Languages to evaluate')
    p.add_argument('--whisper-sizes', nargs='*',
                   default=['tiny', 'base', 'small', 'medium', 'large-v2', 'large-v3', 'turbo'])
    p.add_argument('--run-mms',       action='store_true')
    p.add_argument('--run-seamless',  action='store_true')
    p.add_argument('--run-gemma4',    action='store_true',
                   help='Evaluate Gemma 4 E2B (requires transformers>=5.0, '
                        'soundfile; runs on MPS on Apple Silicon)')
    p.add_argument('--sample-size',   type=int, default=None,
                   help='Utterances per dataset per language (None = full set)')
    p.add_argument('--batch-size',    type=int, default=16)
    p.add_argument('--force',         action='store_true',
                   help='Rerun selected model-language pairs even if present')
    return p.parse_args()


# ── HF HUB ────────────────────────────────────────────────────────────────────
def push_to_hub(results_dir: Path, hub_repo: str, api: HfApi, private: bool = False):
    if not hub_repo:
        return
    try:
        api.create_repo(hub_repo, repo_type='dataset', private=private, exist_ok=True)
        api.upload_folder(
            folder_path=str(results_dir),
            repo_id=hub_repo,
            repo_type='dataset',
            commit_message='Update script-fidelity results',
            ignore_patterns=['*.pyc', '__pycache__'],
        )
        log.info(f'Pushed results to: {hub_repo}')
    except Exception as e:
        log.warning(f'Hub push failed: {e}')


# ── NORMALIZATION ─────────────────────────────────────────────────────────────
# Per-language normalization: strip diacritics, punctuation, numerals.
# We normalise ONLY for WER/CER computation; the raw hypothesis is used for SF.

_DIACRITIC_RE   = re.compile(r'[\u064B-\u065F\u0670]')   # Arabic diacritics
_PUNCT_ARABIC   = re.compile(r'[،؟؛!.«»()\[\]{}\u060C\u061B\u061F\u066D\u06D4\u200C\u200D]')
_DIGITS_ALL     = re.compile(r'[0-9٠-٩]')
_TATWEEL        = '\u0640'

def normalize_arabic_script(text: str) -> str:
    if not isinstance(text, str): return ''
    text = unicodedata.normalize('NFC', text)
    text = text.replace(_TATWEEL, '')
    text = _DIACRITIC_RE.sub('', text)
    text = _PUNCT_ARABIC.sub('', text)
    text = _DIGITS_ALL.sub('', text)
    return ' '.join(text.split())

def normalize_latin(text: str) -> str:
    if not isinstance(text, str): return ''
    text = unicodedata.normalize('NFC', text).lower()
    text = re.sub(r"[^\w\s'-]", '', text)
    text = _DIGITS_ALL.sub('', text)
    return ' '.join(text.split())

def normalize_indic(text: str) -> str:
    if not isinstance(text, str): return ''
    text = unicodedata.normalize('NFC', text)
    text = re.sub(r'[।॥!?,.:;()\[\]{}"\']', '', text)
    text = _DIGITS_ALL.sub('', text)
    return ' '.join(text.split())

def normalize_georgian(text: str) -> str:
    # Lowercase converts rare Asomtavruli capitals to standard Mkhedruli.
    # \w is Unicode-aware in Python re, so Georgian letters are preserved.
    if not isinstance(text, str): return ''
    text = unicodedata.normalize('NFC', text).lower()
    text = re.sub(r"[^\w\s'-]", '', text)
    text = _DIGITS_ALL.sub('', text)
    return ' '.join(text.split())

NORMALIZERS = {
    'pashto':    normalize_arabic_script,
    'urdu':      normalize_arabic_script,
    'hindi':     normalize_indic,
    'bengali':   normalize_indic,
    'malayalam': normalize_indic,
    'somali':    normalize_latin,
    'arabic':    normalize_arabic_script,
    'persian':   normalize_arabic_script,
    'tamil':     normalize_indic,
    'georgian':  normalize_georgian,
}


# ── DATASET LOADING ───────────────────────────────────────────────────────────
def load_fleurs(language: str, sample_size: int | None) -> dict:
    cfg  = SCRIPT_CONFIGS[language]
    code = cfg.fleurs_code
    log.info(f'Loading FLEURS {code} test...')
    ds = load_dataset('google/fleurs', code, split='test', trust_remote_code=True)
    ds = ds.cast_column('audio', Audio(sampling_rate=16_000))
    refs   = [ex['transcription'] for ex in ds]
    audios = [ex['audio']['array'] for ex in ds]
    if sample_size:
        import random; random.seed(42)
        idx    = sorted(random.sample(range(len(refs)), min(sample_size, len(refs))))
        refs   = [refs[i]   for i in idx]
        audios = [audios[i] for i in idx]
    log.info(f'  FLEURS {code}: {len(refs)} utterances')
    return {'refs': refs, 'audios': audios, 'language': language, 'fleurs_code': code}


# ── RESULT STORE ──────────────────────────────────────────────────────────────
class ResultStore:
    def __init__(self, csv_path: Path, force: bool = False):
        self.csv_path = csv_path
        self.force = force
        if csv_path.exists():
            self.df = pd.read_csv(csv_path)
            completed_df = self.df
            if 'source' in completed_df.columns:
                source = completed_df['source'].fillna('')
                completed_df = completed_df[source != 'paper_a_' + 'import']
            self.completed = set(zip(completed_df['model'], completed_df['language']))
            log.info(f'Resuming — {len(self.completed)} model×language combos done')
        else:
            self.df       = pd.DataFrame()
            self.completed = set()

    def is_done(self, model_id: str, language: str) -> bool:
        if self.force:
            return False
        return (model_id, language) in self.completed

    def add(self, row: dict):
        if not self.df.empty and {'model', 'language'}.issubset(self.df.columns):
            same = (
                (self.df['model'] == row['model'])
                & (self.df['language'] == row['language'])
            )
            self.df = self.df.loc[~same].copy()
        self.df = pd.concat([self.df, pd.DataFrame([row])], ignore_index=True)
        self.df.to_csv(self.csv_path, index=False)
        self.completed.add((row['model'], row['language']))
        log.info(
            f"  Saved: {row['model']:45s} / {row['language']:12s} "
            f"WER={row.get('wer_pct')}%  SFR={row.get('sfr_mean')}%"
        )


# ── COMPUTE METRICS ───────────────────────────────────────────────────────────
def compute_metrics(
    refs: list[str],
    preds: list[str],
    language: str,
    wer_metric,
    cer_metric,
) -> dict:
    norm_fn   = NORMALIZERS[language]
    refs_norm = [norm_fn(r) for r in refs]
    pred_norm = [norm_fn(p) for p in preds]

    # WER/CER — skip empty references
    pairs = [(r, p) for r, p in zip(refs_norm, pred_norm) if r.strip()]
    wer_val = cer_val = None
    if pairs:
        refs_f, preds_f = zip(*pairs)
        wer_val = round(wer_metric.compute(
            references=list(refs_f), predictions=list(preds_f)) * 100, 2)
        cer_val = round(cer_metric.compute(
            references=list(refs_f), predictions=list(preds_f)) * 100, 2)

    # Script Fidelity — computed on RAW hypothesis (before normalisation)
    sfr_scores, dom_scripts = compute_sfr_batch(preds, language)
    sfr_valid  = [s for s in sfr_scores if s is not None]
    sfr_empty  = sum(1 for s in sfr_scores if s is None)
    sfr_mean   = round(np.mean(sfr_valid) * 100, 2) if sfr_valid else None
    sfr_full   = sum(1 for s in sfr_valid if s == 1.0)   # utterances with SFR=100%
    sfr_zero   = sum(1 for s in sfr_valid if s == 0.0)   # script collapse utterances

    dom_counts = pd.Series(dom_scripts).value_counts().to_dict()

    return {
        'n':             len(refs),
        'n_pairs':       len(pairs),
        'wer_pct':       wer_val,
        'cer_pct':       cer_val,
        'sfr_mean':      sfr_mean,
        'sfr_full_pct':  round(sfr_full / max(len(sfr_valid), 1) * 100, 1),
        'sfr_zero_pct':  round(sfr_zero / max(len(sfr_valid), 1) * 100, 1),
        'sfr_empty_n':   sfr_empty,
        **{f'dom_{k}': v for k, v in dom_counts.items()},
    }, sfr_scores, dom_scripts


# ── WHISPER EVALUATION ────────────────────────────────────────────────────────
_WHISPER_MODEL_IDS = {
    'turbo': 'openai/whisper-large-v3-turbo',
}

# Whisper language token names (from Whisper tokenizer vocabulary)
# These are the forced-language token strings, not BCP-47 codes.
WHISPER_LANG_TOKENS = {
    'pashto':    'pashto',
    'urdu':      'urdu',
    'hindi':     'hindi',
    'bengali':   'bengali',
    'malayalam': 'malayalam',
    'somali':    'somali',
    'arabic':    'arabic',
    'persian':   'persian',
    'tamil':     'tamil',
    'georgian':  'georgian',
}


def eval_whisper_language(
    size: str,
    language: str,
    dataset: dict,
    store: ResultStore,
    preds_dir: Path,
    batch_size: int,
    wer_metric,
    cer_metric,
    device: str,
) -> None:
    from transformers import pipeline as hf_pipeline

    model_id   = _WHISPER_MODEL_IDS.get(size, f'openai/whisper-{size}')
    lang_token = WHISPER_LANG_TOKENS[language]

    if store.is_done(model_id, language):
        log.info(f'  Skipping {model_id}/{language} (done)'); return

    log.info(f'  Loading {model_id} for {language}...')
    pipe = hf_pipeline(
        'automatic-speech-recognition',
        model=model_id,
        device=0 if device == 'cuda' else -1,
        torch_dtype=torch.float16 if device == 'cuda' else torch.float32,
    )

    refs, audios = dataset['refs'], dataset['audios']
    log.info(f'  {model_id} on FLEURS {language} ({len(audios)} utterances)...')
    t0   = time.time()
    preds = []
    for i in tqdm(range(0, len(audios), batch_size), desc=f'W-{size}/{language}', leave=False):
        batch = audios[i:i+batch_size]
        outs  = pipe(batch, batch_size=batch_size, chunk_length_s=30,
                     generate_kwargs={'language': lang_token, 'task': 'transcribe'})
        preds.extend([o['text'] for o in outs])
    elapsed = time.time() - t0

    # Persist predictions
    pred_file = preds_dir / f'whisper_{size}_{language}_predictions.json'
    with open(pred_file, 'w', encoding='utf-8') as f:
        json.dump({'model': model_id, 'language': language,
                   'references': refs, 'predictions': preds},
                  f, ensure_ascii=False)

    metrics, sfr_scores, dom = compute_metrics(refs, preds, language, wer_metric, cer_metric)
    total_s = sum(len(a) / 16_000 for a in audios)
    store.add({
        'model':    model_id,
        'family':   'Whisper',
        'size':     size,
        'language': language,
        'rtf':      round(elapsed / total_s, 4),
        **metrics,
    })

    del pipe
    if device == 'cuda': torch.cuda.empty_cache()


# ── MMS EVALUATION ────────────────────────────────────────────────────────────
def eval_mms_language(
    language: str,
    dataset: dict,
    store: ResultStore,
    preds_dir: Path,
    batch_size: int,
    wer_metric,
    cer_metric,
    device: str,
) -> None:
    from transformers import Wav2Vec2ForCTC, AutoProcessor

    model_id = 'facebook/mms-1b-all'
    if store.is_done(model_id, language):
        log.info(f'  Skipping MMS/{language} (done)'); return

    cfg        = SCRIPT_CONFIGS[language]
    lang_codes = cfg.mms_lang

    log.info(f'  Loading {model_id} for {language}...')
    proc  = AutoProcessor.from_pretrained(model_id)
    model = Wav2Vec2ForCTC.from_pretrained(model_id, torch_dtype=torch.float16)
    model = model.to(device).eval()

    mms_lang = None
    for code in lang_codes:
        try:
            proc.tokenizer.set_target_lang(code)
            model.load_adapter(code)
            mms_lang = code
            log.info(f'  MMS adapter: {code}')
            break
        except Exception as e:
            log.warning(f'  MMS lang={code} failed: {e}')

    if mms_lang is None:
        log.error(f'  No MMS adapter for {language} — skipping')
        del model, proc
        if device == 'cuda': torch.cuda.empty_cache()
        return

    refs, audios = dataset['refs'], dataset['audios']
    log.info(f'  MMS on FLEURS {language} ({len(audios)} utterances)...')
    t0    = time.time()
    preds = []
    for i in tqdm(range(0, len(audios), batch_size), desc=f'MMS/{language}', leave=False):
        batch  = audios[i:i+batch_size]
        inputs = proc(batch, sampling_rate=16_000, return_tensors='pt', padding=True)
        inputs = {k: (v.to(device, dtype=torch.float16) if v.is_floating_point() else v.to(device))
                  for k, v in inputs.items()}
        with torch.no_grad():
            logits = model(**inputs).logits
        pred_ids = torch.argmax(logits, dim=-1)
        preds.extend(proc.batch_decode(pred_ids))
    elapsed = time.time() - t0

    pred_file = preds_dir / f'mms_1b_{language}_predictions.json'
    with open(pred_file, 'w', encoding='utf-8') as f:
        json.dump({'model': model_id, 'language': language,
                   'references': refs, 'predictions': preds},
                  f, ensure_ascii=False)

    metrics, _, _ = compute_metrics(refs, preds, language, wer_metric, cer_metric)
    total_s = sum(len(a) / 16_000 for a in audios)
    store.add({
        'model':    model_id,
        'family':   'MMS',
        'size':     '1B',
        'language': language,
        'rtf':      round(elapsed / total_s, 4),
        **metrics,
    })

    del model, proc
    if device == 'cuda': torch.cuda.empty_cache()


# ── SEAMLESSM4T EVALUATION ────────────────────────────────────────────────────
# SeamlessM4T language codes for target languages (tgt_lang parameter)
SEAMLESS_LANG_CODES = {
    'pashto':    'pbt',    # Southern Pashto (FLORES-200)
    'urdu':      'urd',
    'hindi':     'hin',
    'bengali':   'ben',
    'malayalam': 'mal',
    'somali':    'som',
    'arabic':    'arb',    # Modern Standard Arabic
    'persian':   'pes',    # Western Persian
    'tamil':     'tam',
    'georgian':  'kat',
}


def eval_seamless_language(
    language: str,
    dataset: dict,
    store: ResultStore,
    preds_dir: Path,
    batch_size: int,
    wer_metric,
    cer_metric,
    device: str,
) -> None:
    from transformers import AutoProcessor, SeamlessM4Tv2ForSpeechToText

    model_id  = 'facebook/seamless-m4t-v2-large'
    tgt_lang  = SEAMLESS_LANG_CODES.get(language)
    if tgt_lang is None:
        log.warning(f'  SeamlessM4T: no lang code for {language} — skipping')
        return

    if store.is_done(model_id, language):
        log.info(f'  Skipping SeamlessM4T/{language} (done)'); return

    log.info(f'  Loading {model_id} (~10 GB VRAM) for {language}...')
    try:
        proc = AutoProcessor.from_pretrained(model_id, use_fast=False)
    except Exception as e:
        log.warning(f'  Processor load failed ({e}); retrying with force_download...')
        proc = AutoProcessor.from_pretrained(model_id, force_download=True)

    try:
        model = SeamlessM4Tv2ForSpeechToText.from_pretrained(
            model_id, torch_dtype=torch.float16)
    except Exception as e:
        log.warning(f'  Model load failed ({e}); retrying with force_download=True...')
        model = SeamlessM4Tv2ForSpeechToText.from_pretrained(
            model_id, torch_dtype=torch.float16, force_download=True)

    model = model.to(device).eval()

    refs, audios = dataset['refs'], dataset['audios']
    s4t_batch    = max(1, batch_size // 4)
    log.info(f'  SeamlessM4T on FLEURS {language} ({len(audios)} utterances)...')
    t0    = time.time()
    preds = []
    for i in tqdm(range(0, len(audios), s4t_batch), desc=f'S4T/{language}', leave=False):
        batch  = audios[i:i+s4t_batch]
        inputs = proc(audios=batch, sampling_rate=16_000,
                      return_tensors='pt', padding=True)
        inputs = {k: (v.to(device, dtype=torch.float16) if v.is_floating_point() else v.to(device))
                  for k, v in inputs.items()}
        with torch.no_grad():
            out = model.generate(**inputs, tgt_lang=tgt_lang)
        sequences = out.sequences if hasattr(out, 'sequences') else out
        preds.extend(proc.batch_decode(sequences, skip_special_tokens=True))
    elapsed = time.time() - t0

    pred_file = preds_dir / f'seamless_m4t_v2_{language}_predictions.json'
    with open(pred_file, 'w', encoding='utf-8') as f:
        json.dump({'model': model_id, 'language': language,
                   'references': refs, 'predictions': preds},
                  f, ensure_ascii=False)

    metrics, _, _ = compute_metrics(refs, preds, language, wer_metric, cer_metric)
    total_s = sum(len(a) / 16_000 for a in audios)
    store.add({
        'model':    model_id,
        'family':   'SeamlessM4T',
        'size':     'v2-large',
        'language': language,
        'rtf':      round(elapsed / total_s, 4),
        **metrics,
    })

    del model, proc
    if device == 'cuda': torch.cuda.empty_cache()


# ── GEMMA 4 EVALUATION ───────────────────────────────────────────────────────
# Exact transcription prompt from the Gemma 4 model card.
_GEMMA4_PROMPT = (
    'Transcribe the following speech segment in its original language. '
    'Follow these specific instructions for formatting the answer:\n'
    '* Only output the transcription, with no newlines.\n'
    '* When transcribing numbers, write the digits, '
    'i.e. write 1.7 and not one point seven, and write 3 instead of three.'
)
# unsloth/gemma-4-E2B-it: Apache-2.0, no HF license gate, same weights as
# google/gemma-4-E2B-it but accessible without agreeing to Google's terms.
# E2B = Effective 2B; ~10 GB BF16, ~4 GB at 4-bit. Audio supported on E2B/E4B only.
_GEMMA4_MODEL_ID = 'unsloth/gemma-4-E2B-it'


def eval_gemma4_language(
    language: str,
    dataset: dict,
    store: ResultStore,
    preds_dir: Path,
    wer_metric,
    cer_metric,
    device: str,
) -> None:
    """Evaluate Gemma 4 E2B on one language.

    Audio arrays are written to per-utterance temp WAV files because
    processor.apply_chat_template only accepts file paths, not numpy arrays.
    Runs at batch_size=1; Gemma 4 is an autoregressive multimodal LLM.
    device_map='auto' handles placement; the device param is used for cleanup only.
    """
    import tempfile
    import soundfile as sf

    try:
        from transformers import AutoModelForMultimodalLM, AutoProcessor
    except ImportError:
        log.error('transformers>=5.0 required for AutoModelForMultimodalLM; skipping')
        return

    if store.is_done(_GEMMA4_MODEL_ID, language):
        log.info(f'  Skipping Gemma4/{language} (done)'); return

    # E2B at dtype='auto': ~10 GB BF16 on CUDA, ~10 GB float16 on MPS.
    # AutoModelForMultimodalLM is required — AutoModelForCausalLM does not
    # correctly initialise the audio encoder in Gemma 4's architecture.
    log.info(f'  Loading {_GEMMA4_MODEL_ID} (~10 GB)...')
    proc  = AutoProcessor.from_pretrained(_GEMMA4_MODEL_ID)
    model = AutoModelForMultimodalLM.from_pretrained(
        _GEMMA4_MODEL_ID,
        dtype='auto',
        device_map='auto',
    )
    model.eval()

    refs, audios = dataset['refs'], dataset['audios']
    log.info(f'  Gemma 4 on FLEURS {language} ({len(audios)} utterances)...')
    t0    = time.time()
    preds = []

    with tempfile.TemporaryDirectory() as tmpdir:
        for i, audio_array in enumerate(
                tqdm(audios, desc=f'Gemma4/{language}', leave=False)):
            wav_path = str(Path(tmpdir) / f'utt_{i}.wav')
            sf.write(wav_path, audio_array, 16_000)

            messages = [{
                'role': 'user',
                'content': [
                    {'type': 'audio', 'audio': wav_path},
                    {'type': 'text',  'text': _GEMMA4_PROMPT},
                ],
            }]
            try:
                inputs = proc.apply_chat_template(
                    messages,
                    tokenize=True,
                    return_dict=True,
                    return_tensors='pt',
                    add_generation_prompt=True,
                ).to(model.device)
                input_len = inputs['input_ids'].shape[-1]

                with torch.no_grad():
                    out = model.generate(
                        **inputs,
                        max_new_tokens=256,
                        do_sample=False,
                    )
                text = proc.decode(out[0][input_len:], skip_special_tokens=True)
                preds.append(text.strip())
            except Exception as exc:
                log.warning(f'  Gemma4 utterance {i} failed: {exc}')
                preds.append('')

    elapsed = time.time() - t0

    pred_file = preds_dir / f'gemma4_{language}_predictions.json'
    with open(pred_file, 'w', encoding='utf-8') as f:
        json.dump({'model': _GEMMA4_MODEL_ID, 'language': language,
                   'references': refs, 'predictions': preds},
                  f, ensure_ascii=False)

    metrics, _, _ = compute_metrics(refs, preds, language, wer_metric, cer_metric)
    total_s = sum(len(a) / 16_000 for a in audios)
    store.add({
        'model':    _GEMMA4_MODEL_ID,
        'family':   'Gemma4',
        'size':     'E2B',
        'language': language,
        'rtf':      round(elapsed / total_s, 4),
        **metrics,
    })

    del model, proc
    if device == 'cuda':
        torch.cuda.empty_cache()
    elif device == 'mps':
        torch.mps.empty_cache()


# ── FIGURES ───────────────────────────────────────────────────────────────────
_PAPER_FAMILIES = {'Whisper', 'MMS', 'SeamlessM4T', 'Gemma4'}


def _paper_rows(df: pd.DataFrame) -> pd.DataFrame:
    """Rows included in the main paper benchmark."""
    if 'family' not in df.columns:
        return df
    return df[df['family'].isin(_PAPER_FAMILIES)].copy()


def make_sf_heatmap(store: ResultStore, figures_dir: Path) -> None:
    """Model × language SF% heatmap — the paper's main figure."""
    df = _paper_rows(store.df)
    if df.empty or 'sfr_mean' not in df.columns:
        return

    pivot = df.pivot_table(
        index='model', columns='language', values='sfr_mean', aggfunc='first')
    if pivot.empty:
        return

    # Short model names for display
    short_names = (
        pivot.index
        .str.replace('openai/whisper-large-v3-turbo', 'Whisper turbo')
        .str.replace('openai/whisper-', 'Whisper ')
        .str.replace('facebook/mms-1b-all', 'MMS 1B')
        .str.replace('facebook/seamless-m4t-v2-large', 'SeamlessM4T v2')
        .str.replace('unsloth/gemma-4-E2B-it', 'Gemma 4 E2B')
        .str.replace('google/gemma-4-E2B-it',  'Gemma 4 E2B')
    )

    fig, ax = plt.subplots(figsize=(max(8, len(pivot.columns) * 1.5),
                                    max(5, len(pivot) * 0.5)))
    sns.heatmap(
        pivot.values,
        xticklabels=pivot.columns.tolist(),
        yticklabels=short_names.tolist(),
        annot=True, fmt='.1f',
        cmap='RdYlGn', vmin=0, vmax=100,
        linewidths=0.5, ax=ax,
        cbar_kws={'label': 'Script Fidelity (%)'},
    )
    ax.set_title('Script Fidelity (%) by Model and Language — FLEURS Test Sets')
    ax.set_xlabel('Language')
    ax.set_ylabel('Model')
    plt.tight_layout()
    out = figures_dir / 'sfr_heatmap.pdf'
    fig.savefig(out, bbox_inches='tight')
    plt.close(fig)
    log.info(f'Saved: {out}')


def make_wer_vs_sf_scatter(store: ResultStore, figures_dir: Path) -> None:
    """WER vs SF scatter — shows decoupling cases."""
    df = _paper_rows(store.df)
    if df.empty or 'sfr_mean' not in df.columns:
        return

    languages = sorted(df['language'].unique())
    n         = len(languages)
    ncols     = 5
    nrows     = int(np.ceil(n / ncols))
    fig, axes = plt.subplots(nrows, ncols, figsize=(17, 7.5), sharex=True, sharey=False)
    axes = np.array(axes).reshape(-1)

    zone_colors = {
        'collapse': '#d73027',
        'mixed': '#fdae61',
        'high': '#1a9850',
    }
    for ax, lang in zip(axes, languages):
        sub = df[df['language'] == lang].dropna(subset=['wer_pct', 'sfr_mean'])
        if sub.empty:
            ax.set_title(lang); continue
        point_colors = [
            zone_colors['collapse'] if v < 10 else
            zone_colors['mixed'] if v <= 90 else
            zone_colors['high']
            for v in sub['sfr_mean']
        ]
        ax.scatter(sub['sfr_mean'], sub['wer_pct'], color=point_colors,
                   s=55, zorder=5, edgecolor='black', linewidth=0.25)
        ax.axvline(10, color=zone_colors['collapse'], linestyle='--', linewidth=1)
        ax.axvline(90, color=zone_colors['high'], linestyle='--', linewidth=1)
        ax.set_xlabel('Script Fidelity (%)')
        ax.set_ylabel('WER (%)')
        ax.set_title(lang.capitalize())
        ax.set_xlim(-5, 105)

    for ax in axes[n:]:
        ax.axis('off')

    handles = [
        plt.Line2D([0], [0], marker='o', color='w', label='SFR < 10%',
                   markerfacecolor=zone_colors['collapse'], markeredgecolor='black', markersize=7),
        plt.Line2D([0], [0], marker='o', color='w', label='10-90%',
                   markerfacecolor=zone_colors['mixed'], markeredgecolor='black', markersize=7),
        plt.Line2D([0], [0], marker='o', color='w', label='> 90%',
                   markerfacecolor=zone_colors['high'], markeredgecolor='black', markersize=7),
    ]
    fig.legend(handles=handles, loc='lower center', ncol=3, frameon=False)
    plt.suptitle('WER vs Script Fidelity - FLEURS test sets', y=0.98)
    plt.tight_layout(rect=(0, 0.05, 1, 0.95))
    out = figures_dir / 'wer_vs_sfr_scatter.pdf'
    fig.savefig(out, bbox_inches='tight')
    plt.close(fig)
    log.info(f'Saved: {out}')


# ── MAIN ──────────────────────────────────────────────────────────────────────
def main():
    args   = parse_args()
    if torch.cuda.is_available():
        device = 'cuda'
    elif torch.backends.mps.is_available():
        device = 'mps'
    else:
        device = 'cpu'
    log.info(f'Device: {device}')
    if device == 'cuda':
        log.info(f'GPU: {torch.cuda.get_device_name(0)}  '
                 f'VRAM: {torch.cuda.get_device_properties(0).total_memory/1e9:.1f} GB')
    elif device == 'mps':
        log.info(f'MPS RAM available: {torch.mps.recommended_max_memory()/1e9:.1f} GB')

    if args.hf_token:
        login(token=args.hf_token)
    api = HfApi(token=args.hf_token or None)

    results_dir = Path(args.results_dir)
    preds_dir   = results_dir / 'predictions'
    results_dir.mkdir(parents=True, exist_ok=True)
    preds_dir.mkdir(exist_ok=True)

    fh = logging.FileHandler(results_dir / 'eval_multilang.log')
    fh.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
    log.addHandler(fh)

    wer_metric = load_metric('wer')
    cer_metric = load_metric('cer')

    store = ResultStore(results_dir / 'sf_results.csv', force=args.force)

    # Step 1: load FLEURS for each requested language.
    datasets = {}
    for lang in args.languages:
        if lang not in SCRIPT_CONFIGS:
            log.warning(f'Unknown language: {lang} — skipping')
            continue
        datasets[lang] = load_fleurs(lang, args.sample_size)

    # Step 2: Whisper
    for size in args.whisper_sizes:
        for lang, dataset in datasets.items():
            eval_whisper_language(
                size, lang, dataset, store, preds_dir,
                args.batch_size, wer_metric, cer_metric, device)
            push_to_hub(results_dir, args.hub_repo, api, args.hub_private)

    # Step 3: MMS
    if args.run_mms:
        for lang, dataset in datasets.items():
            eval_mms_language(
                lang, dataset, store, preds_dir,
                args.batch_size, wer_metric, cer_metric, device)
            push_to_hub(results_dir, args.hub_repo, api, args.hub_private)

    # Step 4: SeamlessM4T
    if args.run_seamless:
        for lang, dataset in datasets.items():
            eval_seamless_language(
                lang, dataset, store, preds_dir,
                args.batch_size, wer_metric, cer_metric, device)
            push_to_hub(results_dir, args.hub_repo, api, args.hub_private)

    # Step 5: Gemma 4
    if args.run_gemma4:
        gemma_datasets = dict(datasets)  # copy; already loaded above
        for lang, dataset in gemma_datasets.items():
            eval_gemma4_language(
                lang, dataset, store, preds_dir, wer_metric, cer_metric, device)
            push_to_hub(results_dir, args.hub_repo, api, args.hub_private)

    # Step 6: figures
    figures_dir = Path(__file__).parent.parent / 'figures'
    figures_dir.mkdir(parents=True, exist_ok=True)
    make_sf_heatmap(store, figures_dir)
    make_wer_vs_sf_scatter(store, figures_dir)

    # Final push + summary
    push_to_hub(results_dir, args.hub_repo, api, args.hub_private)
    log.info('=== DONE ===')

    if not store.df.empty and 'sfr_mean' in store.df.columns:
        pivot = store.df.pivot_table(
            index='model', columns='language', values='sfr_mean', aggfunc='first')
        log.info(f'\nSF% summary:\n{pivot.to_string()}')

        pivot_wer = store.df.pivot_table(
            index='model', columns='language', values='wer_pct', aggfunc='first')
        log.info(f'\nWER% summary:\n{pivot_wer.to_string()}')


if __name__ == '__main__':
    main()