scripts/eval_sfr_lid_hybrid.py

#!/usr/bin/env python3
"""SFR plus language-identification analysis from saved Gemma predictions."""

from __future__ import annotations

import argparse
import json
import sys
from collections import Counter
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 pandas as pd
from langdetect import DetectorFactory, LangDetectException, detect

from script_fidelity import SCRIPT_CONFIGS, compute_sfr, dominant_script


DetectorFactory.seed = 42

LANGUAGES = [
    "pashto",
    "urdu",
    "arabic",
    "persian",
    "hindi",
    "bengali",
    "malayalam",
    "tamil",
    "somali",
    "georgian",
]

EXPECTED_LID = {
    "arabic": "ar",
    "bengali": "bn",
    "georgian": "ka",
    "hindi": "hi",
    "malayalam": "ml",
    "persian": "fa",
    "somali": "so",
    "tamil": "ta",
    "urdu": "ur",
}

VARIANTS = {
    "baseline": ("results_gemma4/predictions", "gemma4_{language}_predictions.json"),
    "script_hint": (
        "results_gemma4_prompt_mitigation/predictions",
        "gemma4_script_hint_{language}_predictions.json",
    ),
}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Run SFR plus LID analysis over saved Gemma prediction JSONs."
    )
    parser.add_argument("--summary-csv", default=str(ROOT / "analysis" / "sfr_lid_hybrid_summary.csv"))
    parser.add_argument("--utterance-csv", default=str(ROOT / "analysis" / "sfr_lid_hybrid_utterances.csv"))
    parser.add_argument("--languages", nargs="+", default=LANGUAGES)
    return parser.parse_args()


def prediction_path(variant: str, language: str) -> Path:
    directory, template = VARIANTS[variant]
    return ROOT / directory / template.format(language=language)


def load_predictions(path: Path) -> tuple[list[str], list[str]]:
    with open(path, encoding="utf-8") as handle:
        data = json.load(handle)
    refs = data.get("references", [])
    preds = data.get("predictions", [])
    if not refs or not preds:
        raise ValueError(f"Missing references/predictions in {path}")
    return refs, preds


def lid_label(text: str) -> str:
    text = (text or "").strip()
    if not text:
        return "empty"
    try:
        return detect(text)
    except LangDetectException:
        return "unknown"


def utterance_rows(languages: list[str]) -> list[dict]:
    rows = []
    for language in languages:
        if language not in SCRIPT_CONFIGS:
            raise ValueError(f"Unknown language: {language}")
        expected_lid = EXPECTED_LID.get(language, "")
        for variant in VARIANTS:
            refs, preds = load_predictions(prediction_path(variant, language))
            for idx, (ref, pred) in enumerate(zip(refs, preds)):
                sfr = compute_sfr(pred, language)
                lid = lid_label(pred)
                dom = dominant_script(pred)
                rows.append(
                    {
                        "language": language,
                        "prompt_variant": variant,
                        "utterance_index": idx,
                        "sfr": None if sfr is None else round(sfr * 100, 2),
                        "dominant_script": dom,
                        "lid_label": lid,
                        "expected_lid_label": expected_lid,
                        "lid_matches_expected": bool(expected_lid and lid == expected_lid),
                        "is_low_sfr": bool(sfr is not None and sfr < 0.10),
                        "is_high_sfr": bool(sfr is not None and sfr >= 0.90),
                        "reference": ref,
                        "prediction": pred,
                    }
                )
    return rows


def top_labels(labels: pd.Series, k: int = 3) -> list[tuple[str, float]]:
    counts = Counter(labels.dropna().tolist())
    total = sum(counts.values()) or 1
    return [(label, round(count / total * 100, 1)) for label, count in counts.most_common(k)]


def summarize(df: pd.DataFrame) -> pd.DataFrame:
    rows = []
    for (language, variant), group in df.groupby(["language", "prompt_variant"], sort=False):
        tops = top_labels(group["lid_label"], 3)
        while len(tops) < 3:
            tops.append(("", 0.0))
        expected = EXPECTED_LID.get(language, "")
        low = group[group["is_low_sfr"]]
        high = group[group["is_high_sfr"]]
        rows.append(
            {
                "language": language,
                "prompt_variant": variant,
                "n": len(group),
                "mean_sfr": round(group["sfr"].dropna().mean(), 2),
                "low_sfr_pct": round(group["is_low_sfr"].mean() * 100, 1),
                "high_sfr_pct": round(group["is_high_sfr"].mean() * 100, 1),
                "expected_lid_label": expected,
                "lid_expected_pct": round(group["lid_matches_expected"].mean() * 100, 1)
                if expected else "",
                "low_sfr_expected_lid_pct": round(low["lid_matches_expected"].mean() * 100, 1)
                if expected and len(low) else "",
                "high_sfr_expected_lid_pct": round(high["lid_matches_expected"].mean() * 100, 1)
                if expected and len(high) else "",
                "top_lid_1": tops[0][0],
                "top_lid_1_pct": tops[0][1],
                "top_lid_2": tops[1][0],
                "top_lid_2_pct": tops[1][1],
                "top_lid_3": tops[2][0],
                "top_lid_3_pct": tops[2][1],
            }
        )
    return pd.DataFrame(rows)


def main() -> None:
    args = parse_args()
    rows = utterance_rows(args.languages)
    utterances = pd.DataFrame(rows)
    summary = summarize(utterances)

    Path(args.utterance_csv).parent.mkdir(parents=True, exist_ok=True)
    utterances.to_csv(args.utterance_csv, index=False)
    summary.to_csv(args.summary_csv, index=False)
    print(f"Wrote {args.summary_csv}")
    print(f"Wrote {args.utterance_csv}")


if __name__ == "__main__":
    main()