scripts/eval_gemma4_prompt_mitigation.py

#!/usr/bin/env python3
"""Gemma 4 script-aware prompting mitigation experiment.

This script runs only the script-aware prompt arm. It compares the results
against the existing Gemma 4 baseline outputs in results_gemma4/.
"""

from __future__ import annotations

import argparse
import json
import logging
import os
import sys
import tempfile
import time
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
import soundfile as sf
import torch
from evaluate import load as load_metric
from tqdm import tqdm
from transformers import AutoModelForMultimodalLM, AutoProcessor

from eval_multilang import compute_metrics, load_fleurs


MODEL_ID = "unsloth/gemma-4-E2B-it"

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

LANGUAGE_NAMES = {
    "pashto": ("Pashto", "Pashto Perso-Arabic"),
    "urdu": ("Urdu", "Urdu Perso-Arabic"),
    "arabic": ("Arabic", "Arabic"),
    "persian": ("Persian", "Persian"),
    "hindi": ("Hindi", "Devanagari"),
    "bengali": ("Bengali", "Bengali"),
    "malayalam": ("Malayalam", "Malayalam"),
    "tamil": ("Tamil", "Tamil"),
    "somali": ("Somali", "Latin"),
    "georgian": ("Georgian", "Georgian Mkhedruli"),
}

SCRIPT_HINT_TEMPLATE = (
    "Transcribe the following speech segment in {language_name}. "
    "Use {script_name} script only. "
    "Do not translate, romanize, or add explanations.\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."
)


logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)],
)
log = logging.getLogger("gemma4_prompt_mitigation")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Run Gemma 4 script-aware prompting mitigation on FLEURS."
    )
    parser.add_argument("--baseline-results", default=str(ROOT / "results_gemma4" / "sf_results.csv"))
    parser.add_argument("--baseline-predictions-dir", default=str(ROOT / "results_gemma4" / "predictions"))
    parser.add_argument("--results-dir", default=str(ROOT / "results_gemma4_prompt_mitigation"))
    parser.add_argument("--summary-csv", default=str(ROOT / "analysis" / "gemma4_prompt_mitigation_summary.csv"))
    parser.add_argument("--languages", nargs="+", default=LANGUAGES)
    parser.add_argument("--sample-size", type=int, default=None)
    parser.add_argument("--max-new-tokens", type=int, default=256)
    parser.add_argument("--summarize-only", action="store_true")
    return parser.parse_args()


def prediction_path(preds_dir: Path, language: str) -> Path:
    return preds_dir / f"gemma4_script_hint_{language}_predictions.json"


def baseline_prediction_path(preds_dir: Path, language: str) -> Path:
    return preds_dir / f"gemma4_{language}_predictions.json"


def read_rows(csv_path: Path) -> pd.DataFrame:
    if csv_path.exists():
        return pd.read_csv(csv_path)
    return pd.DataFrame()


def write_rows(csv_path: Path, rows: list[dict]) -> None:
    df = pd.DataFrame(rows)
    csv_path.parent.mkdir(parents=True, exist_ok=True)
    df.to_csv(csv_path, index=False)


def ensure_baseline_complete(args: argparse.Namespace) -> pd.DataFrame:
    baseline_csv = Path(args.baseline_results)
    baseline_preds = Path(args.baseline_predictions_dir)
    if not baseline_csv.exists():
        raise SystemExit(f"Missing Gemma 4 baseline CSV: {baseline_csv}")

    baseline = pd.read_csv(baseline_csv)
    gemma = baseline[baseline["model"].eq(MODEL_ID)].copy()
    present = set(gemma["language"].dropna())
    missing_rows = [lang for lang in args.languages if lang not in present]
    missing_preds = [
        lang for lang in args.languages
        if not baseline_prediction_path(baseline_preds, lang).exists()
    ]
    if missing_rows or missing_preds:
        pieces = []
        if missing_rows:
            pieces.append(f"missing baseline rows: {', '.join(missing_rows)}")
        if missing_preds:
            pieces.append(f"missing baseline prediction files: {', '.join(missing_preds)}")
        raise SystemExit(
            "Gemma 4 baseline must be complete before mitigation; "
            + "; ".join(pieces)
        )
    return gemma


def dominant_script(row: pd.Series) -> str:
    dom_cols = [col for col in row.index if col.startswith("dom_")]
    values = {
        col.removeprefix("dom_"): float(row[col])
        for col in dom_cols
        if pd.notna(row[col])
    }
    if not values:
        return ""
    return max(values, key=values.get)


def outcome(baseline_sfr: float, hint_sfr: float) -> str:
    delta = hint_sfr - baseline_sfr
    if baseline_sfr < 10 and hint_sfr >= 90:
        return "fixed_collapse"
    if baseline_sfr < 90 and hint_sfr >= 90:
        return "recovered_to_high"
    if delta >= 10:
        return "improved"
    if delta <= -10:
        return "worsened"
    return "unchanged"


def load_existing_prediction(pred_file: Path) -> tuple[list[str], list[str]]:
    with open(pred_file, 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"Prediction file has no references/predictions: {pred_file}")
    return refs, preds


def append_or_replace_row(csv_path: Path, row: dict) -> None:
    existing = read_rows(csv_path)
    if not existing.empty and {"model", "language", "prompt_variant"}.issubset(existing.columns):
        keep = ~(
            existing["model"].eq(row["model"])
            & existing["language"].eq(row["language"])
            & existing["prompt_variant"].eq(row["prompt_variant"])
        )
        existing = existing[keep]
    out = pd.concat([existing, pd.DataFrame([row])], ignore_index=True)
    out.to_csv(csv_path, index=False)


def compute_row_from_predictions(
    refs: list[str],
    preds: list[str],
    language: str,
    elapsed: float | None,
    audios: list | None,
    wer_metric,
    cer_metric,
) -> dict:
    metrics, _, _ = compute_metrics(refs, preds, language, wer_metric, cer_metric)
    rtf = None
    if elapsed is not None and audios:
        total_s = sum(len(a) / 16_000 for a in audios)
        rtf = round(elapsed / total_s, 4) if total_s else None
    return {
        "model": MODEL_ID,
        "family": "Gemma4",
        "size": "E2B",
        "language": language,
        "prompt_variant": "script_hint",
        "rtf": rtf,
        **metrics,
    }


def run_language(
    language: str,
    model,
    processor,
    results_dir: Path,
    wer_metric,
    cer_metric,
    sample_size: int | None,
    max_new_tokens: int,
) -> dict:
    preds_dir = results_dir / "predictions"
    pred_file = prediction_path(preds_dir, language)
    csv_path = results_dir / "sf_results.csv"

    if pred_file.exists():
        refs, preds = load_existing_prediction(pred_file)
        row = compute_row_from_predictions(refs, preds, language, None, None, wer_metric, cer_metric)
        append_or_replace_row(csv_path, row)
        log.info("Recomputed existing script-hint row for %s", language)
        return row

    dataset = load_fleurs(language, sample_size)
    refs = dataset["refs"]
    audios = dataset["audios"]
    language_name, script_name = LANGUAGE_NAMES[language]
    prompt = SCRIPT_HINT_TEMPLATE.format(
        language_name=language_name,
        script_name=script_name,
    )
    preds: list[str] = []
    t0 = time.time()

    with tempfile.TemporaryDirectory(dir=os.environ["TMPDIR"]) as tmpdir:
        for i, audio_array in enumerate(tqdm(audios, desc=f"Gemma4-hint/{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": prompt},
                ],
            }]
            try:
                inputs = processor.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=max_new_tokens,
                        do_sample=False,
                    )
                text = processor.decode(out[0][input_len:], skip_special_tokens=True)
                preds.append(text.strip())
            except Exception as exc:
                log.warning("Gemma4 script-hint %s utterance %s failed: %s", language, i, exc)
                preds.append("")

    elapsed = time.time() - t0
    preds_dir.mkdir(parents=True, exist_ok=True)
    with open(pred_file, "w", encoding="utf-8") as handle:
        json.dump(
            {
                "model": MODEL_ID,
                "language": language,
                "prompt_variant": "script_hint",
                "prompt": prompt,
                "references": refs,
                "predictions": preds,
            },
            handle,
            ensure_ascii=False,
        )

    row = compute_row_from_predictions(refs, preds, language, elapsed, audios, wer_metric, cer_metric)
    append_or_replace_row(csv_path, row)
    log.info(
        "Saved script-hint %s: WER=%s SFR=%s",
        language,
        row.get("wer_pct"),
        row.get("sfr_mean"),
    )
    return row


def write_summary(
    baseline: pd.DataFrame,
    script_hint: pd.DataFrame,
    summary_path: Path,
    languages: list[str],
) -> pd.DataFrame:
    rows: list[dict] = []
    for language in languages:
        b = baseline[baseline["language"].eq(language)]
        h = script_hint[script_hint["language"].eq(language)]
        if b.empty or h.empty:
            continue
        b_row = b.iloc[0]
        h_row = h.iloc[0]
        baseline_sfr = float(b_row["sfr_mean"])
        hint_sfr = float(h_row["sfr_mean"])
        baseline_wer = float(b_row["wer_pct"])
        hint_wer = float(h_row["wer_pct"])
        rows.append({
            "language": language,
            "baseline_sfr_mean": round(baseline_sfr, 2),
            "script_hint_sfr_mean": round(hint_sfr, 2),
            "delta_sfr": round(hint_sfr - baseline_sfr, 2),
            "baseline_wer_pct": round(baseline_wer, 2),
            "script_hint_wer_pct": round(hint_wer, 2),
            "delta_wer": round(hint_wer - baseline_wer, 2),
            "baseline_dominant_script": dominant_script(b_row),
            "script_hint_dominant_script": dominant_script(h_row),
            "mitigation_outcome": outcome(baseline_sfr, hint_sfr),
        })
    summary = pd.DataFrame(rows)
    summary_path.parent.mkdir(parents=True, exist_ok=True)
    summary.to_csv(summary_path, index=False)
    log.info("Saved mitigation summary: %s", summary_path)
    return summary


def main() -> None:
    args = parse_args()
    results_dir = Path(args.results_dir)
    results_dir.mkdir(parents=True, exist_ok=True)
    (results_dir / "predictions").mkdir(exist_ok=True)

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

    baseline = ensure_baseline_complete(args)
    wer_metric = load_metric("wer")
    cer_metric = load_metric("cer")

    if not args.summarize_only:
        log.info("Loading Gemma 4 model for script-aware prompt arm")
        processor = AutoProcessor.from_pretrained(MODEL_ID)
        model = AutoModelForMultimodalLM.from_pretrained(
            MODEL_ID,
            dtype="auto",
            device_map="auto",
        )
        model.eval()
        for language in args.languages:
            run_language(
                language,
                model,
                processor,
                results_dir,
                wer_metric,
                cer_metric,
                args.sample_size,
                args.max_new_tokens,
            )
        del model, processor
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
        elif torch.backends.mps.is_available():
            torch.mps.empty_cache()

    script_hint = read_rows(results_dir / "sf_results.csv")
    expected = set(args.languages)
    present = set(script_hint["language"].dropna()) if not script_hint.empty else set()
    missing = sorted(expected - present)
    if missing:
        raise SystemExit(
            "Script-hint rows are incomplete; missing: " + ", ".join(missing)
        )
    write_summary(baseline, script_hint, Path(args.summary_csv), args.languages)


if __name__ == "__main__":
    main()