Upload 5 files

scripts/analyze_results.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""Aggregate compiled APM benchmark outputs into summary CSVs and plots."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Iterable
+
+import pandas as pd
+
+from apm_metrics import load_json_or_jsonl, normalize_bool
+
+
+BOOL_COLUMNS = (
+    "asked_question",
+    "added_explanation",
+    "protocol_compliant",
+    "judge_hallucinated_additions",
+    "judge_asked_for_clarification",
+    "judge_added_extra_text",
+    "judge_language_match",
+    "judge_parse_error",
+)
+
+NUMERIC_COLUMNS = (
+    "alpha",
+    "B_raw",
+    "B_assist",
+    "BRS",
+    "question_marks",
+    "meta_phrase_hits",
+    "script_ratio",
+    "judge_intent_preservation",
+    "judge_hallucination_severity",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--compiled-root",
+        type=Path,
+        required=True,
+        help="Root containing <model>/<noise>/compiled.json files.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("benchmark_summaries"),
+        help="Directory where summary CSVs and optional plots will be written.",
+    )
+    parser.add_argument(
+        "--plots",
+        action="store_true",
+        help="Also write a small set of PNG plots. Requires matplotlib and seaborn.",
+    )
+    parser.add_argument(
+        "--write-combined",
+        action="store_true",
+        help="Write the full compiled table as compiled_results.csv.",
+    )
+    return parser.parse_args()
+
+
+def compiled_paths(root: Path) -> Iterable[Path]:
+    return sorted(root.glob("*/*/compiled.json"))
+
+
+def load_compiled(root: Path) -> pd.DataFrame:
+    rows = []
+    for path in compiled_paths(root):
+        model = path.parents[1].name
+        noise = path.parents[0].name
+        for row in load_json_or_jsonl(path):
+            row.setdefault("model", model)
+            row.setdefault("noise", noise)
+            rows.append(row)
+
+    if not rows:
+        raise SystemExit(f"No compiled.json files found under {root}")
+
+    return pd.DataFrame(rows)
+
+
+def ensure_columns(df: pd.DataFrame, columns: Iterable[str], default) -> None:
+    for column in columns:
+        if column not in df.columns:
+            df[column] = default
+
+
+def prepare_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+
+    ensure_columns(df, BOOL_COLUMNS, False)
+    ensure_columns(df, NUMERIC_COLUMNS, 0)
+    ensure_columns(df, ("judge_overall_verdict", "example_id"), "")
+
+    for column in BOOL_COLUMNS:
+        df[column] = df[column].map(normalize_bool)
+
+    for column in NUMERIC_COLUMNS:
+        df[column] = pd.to_numeric(df[column], errors="coerce")
+
+    df["judge_hallucination_severity"] = df["judge_hallucination_severity"].fillna(0)
+    df["question_marks"] = df["question_marks"].fillna(0)
+    df["meta_phrase_hits"] = df["meta_phrase_hits"].fillna(0)
+
+    verdict = df["judge_overall_verdict"].fillna("").astype(str).str.lower()
+    has_verdict = verdict.ne("").any()
+    if has_verdict:
+        df["intent_preserved"] = verdict.isin({"pass", "borderline"})
+    else:
+        df["intent_preserved"] = df["judge_intent_preservation"] >= 4
+
+    df["hallucinated_mediation"] = (
+        df["judge_hallucinated_additions"]
+        | (df["judge_hallucination_severity"] > 0)
+    )
+
+    df["burden_inflation"] = (
+        df["asked_question"]
+        | df["added_explanation"]
+        | df["judge_asked_for_clarification"]
+        | df["judge_added_extra_text"]
+        | (df["question_marks"] > 0)
+        | (df["meta_phrase_hits"] > 0)
+    )
+
+    df["assistive_success"] = (
+        df["protocol_compliant"]
+        & df["intent_preserved"]
+        & (~df["hallucinated_mediation"])
+        & (~df["burden_inflation"])
+    )
+
+    df["false_robust"] = (
+        df["intent_preserved"]
+        & (df["hallucinated_mediation"] | df["burden_inflation"])
+    )
+
+    return df
+
+
+def write_csv(df: pd.DataFrame, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(path, index=False)
+    print(f"Wrote {path}")
+
+
+def write_summaries(df: pd.DataFrame, output_dir: Path, write_combined: bool) -> None:
+    if write_combined:
+        write_csv(df, output_dir / "compiled_results.csv")
+
+    sensitivity = (
+        df.groupby(["model", "language", "noise", "alpha"], dropna=False)
+        .agg(
+            intent_rate=("intent_preserved", "mean"),
+            success_rate=("assistive_success", "mean"),
+            hallucination_rate=("hallucinated_mediation", "mean"),
+            burden_rate=("burden_inflation", "mean"),
+            false_robust_rate=("false_robust", "mean"),
+            mean_brs=("BRS", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(sensitivity, output_dir / "apm_sensitivity_curves.csv")
+
+    tradeoff = (
+        df.groupby(["model", "language", "noise"], dropna=False)
+        .agg(
+            intent_rate=("intent_preserved", "mean"),
+            burden_rate=("burden_inflation", "mean"),
+            hallucination_rate=("hallucinated_mediation", "mean"),
+            false_robust_rate=("false_robust", "mean"),
+            mean_brs=("BRS", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(tradeoff, output_dir / "intent_burden_tradeoff.csv")
+
+    false_robust = (
+        df.groupby(["model", "noise"], dropna=False)
+        .agg(
+            false_robust_rate=("false_robust", "mean"),
+            hallucination_rate=("hallucinated_mediation", "mean"),
+            burden_rate=("burden_inflation", "mean"),
+            intent_rate=("intent_preserved", "mean"),
+            mean_brs=("BRS", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(false_robust, output_dir / "false_robustness_summary.csv")
+
+    language_noise = (
+        df.groupby(["language", "noise"], dropna=False)
+        .agg(
+            success_rate=("assistive_success", "mean"),
+            intent_rate=("intent_preserved", "mean"),
+            hallucination_rate=("hallucinated_mediation", "mean"),
+            burden_rate=("burden_inflation", "mean"),
+            false_robust_rate=("false_robust", "mean"),
+            mean_brs=("BRS", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(language_noise, output_dir / "language_noise_disparities.csv")
+
+    core = (
+        df.groupby(["model", "noise", "alpha", "language"], dropna=False)
+        .agg(
+            intent_preservation_score=("judge_intent_preservation", "mean"),
+            intent_preservation_rate=("intent_preserved", "mean"),
+            mean_brs=("BRS", "mean"),
+            brs_variance=("BRS", "var"),
+            protocol_compliance_rate=("protocol_compliant", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(core, output_dir / "core_metrics.csv")
+
+    hallucination = (
+        df.groupby(["model", "noise", "alpha", "language"], dropna=False)
+        .agg(
+            hallucination_incidence_rate=("judge_hallucinated_additions", "mean"),
+            hallucination_severity_index=("judge_hallucination_severity", "mean"),
+            overassist_rate=("judge_added_extra_text", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(hallucination, output_dir / "hallucination_metrics.csv")
+
+    clarification = (
+        df.groupby(["model", "noise", "alpha", "language"], dropna=False)
+        .agg(
+            clarification_rate=("judge_asked_for_clarification", "mean"),
+            n=("example_id", "count"),
+        )
+        .reset_index()
+    )
+    write_csv(clarification, output_dir / "clarification_metrics.csv")
+
+    brs_alpha = (
+        df.groupby(["noise", "alpha"], dropna=False)
+        .agg(mean_brs=("BRS", "mean"), n=("example_id", "count"))
+        .reset_index()
+    )
+    write_csv(brs_alpha, output_dir / "BRS_vs_alpha.csv")
+
+    brs_language_noise = (
+        df.groupby(["language", "noise"], dropna=False)
+        .agg(mean_brs=("BRS", "mean"), n=("example_id", "count"))
+        .reset_index()
+    )
+    write_csv(brs_language_noise, output_dir / "BRS_vs_language_noise.csv")
+
+    language_table = (
+        sensitivity.groupby("language", dropna=False)
+        .agg(
+            intent_rate=("intent_rate", "mean"),
+            success_rate=("success_rate", "mean"),
+            hallucination_rate=("hallucination_rate", "mean"),
+            burden_rate=("burden_rate", "mean"),
+            false_robust_rate=("false_robust_rate", "mean"),
+            n=("n", "sum"),
+        )
+        .reset_index()
+        .sort_values(["intent_rate", "hallucination_rate", "burden_rate"], ascending=[False, True, True])
+    )
+    write_csv(language_table, output_dir / "table_language_avg.csv")
+
+    model_table = (
+        sensitivity.groupby("model", dropna=False)
+        .agg(
+            intent_rate=("intent_rate", "mean"),
+            success_rate=("success_rate", "mean"),
+            hallucination_rate=("hallucination_rate", "mean"),
+            burden_rate=("burden_rate", "mean"),
+            false_robust_rate=("false_robust_rate", "mean"),
+            n=("n", "sum"),
+        )
+        .reset_index()
+        .sort_values(["intent_rate", "hallucination_rate", "burden_rate"], ascending=[False, True, True])
+    )
+    write_csv(model_table, output_dir / "table_model_avg.csv")
+
+
+def write_plots(df: pd.DataFrame, output_dir: Path) -> None:
+    import matplotlib.pyplot as plt
+
+    plots_dir = output_dir / "plots"
+    plots_dir.mkdir(parents=True, exist_ok=True)
+
+    sensitivity = pd.read_csv(output_dir / "apm_sensitivity_curves.csv")
+
+    def plot_success_by(group_column: str, path: Path) -> None:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        for label, group in sensitivity.groupby(group_column, dropna=False):
+            series = (
+                group.groupby("alpha", dropna=False)
+                .agg(success_rate=("success_rate", "mean"))
+                .reset_index()
+                .sort_values("alpha")
+            )
+            ax.plot(series["alpha"], series["success_rate"], marker="o", label=str(label))
+
+        ax.set_xlabel("Alpha")
+        ax.set_ylabel("Assistive success rate")
+        ax.grid(True, alpha=0.3)
+        ax.legend(loc="best", fontsize=8)
+        fig.tight_layout()
+        fig.savefig(path, dpi=300, bbox_inches="tight")
+        plt.close(fig)
+        print(f"Wrote {path}")
+
+    plot_success_by("model", plots_dir / "sensitivity_success_by_model.png")
+    plot_success_by("language", plots_dir / "sensitivity_success_by_language.png")
+
+    language_noise = pd.read_csv(output_dir / "language_noise_disparities.csv")
+    pivot = (
+        language_noise.pivot(index="language", columns="noise", values="false_robust_rate")
+        .sort_index()
+        .sort_index(axis=1)
+    )
+    fig, ax = plt.subplots(figsize=(8, 6))
+    image = ax.imshow(pivot.values, cmap="Reds", vmin=0, vmax=1)
+    ax.set_xticks(range(len(pivot.columns)))
+    ax.set_xticklabels(pivot.columns)
+    ax.set_yticks(range(len(pivot.index)))
+    ax.set_yticklabels(pivot.index)
+    ax.set_xlabel("Noise")
+    ax.set_ylabel("Language")
+
+    for row_index, language in enumerate(pivot.index):
+        for col_index, noise in enumerate(pivot.columns):
+            value = pivot.loc[language, noise]
+            if pd.notna(value):
+                ax.text(col_index, row_index, f"{value:.2f}", ha="center", va="center", fontsize=8)
+
+    fig.colorbar(image, ax=ax, label="False robustness rate")
+    fig.tight_layout()
+    path = plots_dir / "false_robust_heatmap.png"
+    fig.savefig(path, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    print(f"Wrote {path}")
+
+
+def main() -> None:
+    args = parse_args()
+    df = prepare_dataframe(load_compiled(args.compiled_root))
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    write_summaries(df, args.output_dir, write_combined=args.write_combined)
+
+    if args.plots:
+        write_plots(df, args.output_dir)
+
+    print(f"Analyzed {len(df)} compiled rows")
+
+
+if __name__ == "__main__":
+    main()

scripts/apm_metrics.py

@@ -0,0 +1,217 @@
+"""Shared metric utilities for the Assistive Prompt Mediation benchmark."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Optional
+
+
+META_PATTERNS = [
+    r"\bAs an AI\b",
+    r"\bI (can|will|cannot|can't)\b",
+    r"\bSure[, ]",
+    r"\bHere(?: is|'s)\b",
+    r"\bLet me\b",
+]
+
+ASSISTED_TEXT_FIELDS = (
+    "model_response",
+    "response",
+    "assistant_response",
+    "assist_prompt",
+    "assisted_prompt",
+    "mediated_prompt",
+    "output",
+)
+
+RAW_PROMPT_FIELDS = (
+    "noisy_prompt",
+    "input_prompt",
+    "prompt",
+    "user_prompt",
+)
+
+CHINESE_LANGUAGE_CODES = {"cn", "zh", "zh-cn", "zh_hans", "zh-hans"}
+CJK_REGEX = re.compile(r"[\u4e00-\u9fff]")
+
+
+def load_json_or_jsonl(path: str | Path) -> List[Dict[str, Any]]:
+    """Load a JSON array or JSONL file as a list of dictionaries."""
+
+    path = Path(path)
+    with path.open("r", encoding="utf-8") as f:
+        first_char = f.read(1)
+        f.seek(0)
+        if not first_char:
+            return []
+        if first_char == "[":
+            data = json.load(f)
+            if not isinstance(data, list):
+                raise ValueError(f"{path} must contain a JSON array")
+            return data
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def write_json(data: Any, path: str | Path) -> None:
+    """Write JSON with stable UTF-8 formatting."""
+
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def entropy(text: str) -> float:
+    """Character-level Shannon entropy used by the structural burden score."""
+
+    if not text:
+        return 0.0
+
+    counts = Counter(text)
+    total = sum(counts.values())
+    return -sum((count / total) * math.log2(count / total) for count in counts.values())
+
+
+def cognitive_burden(text: str) -> float:
+    """Compute the structural cognitive burden proxy B(p)."""
+
+    tokens = re.findall(r"\w+|[^\w\s]", text)
+    length = len(tokens)
+    punctuation_density = sum(1 for token in tokens if re.match(r"[^\w\s]", token)) / max(length, 1)
+
+    return round(
+        0.4 * length
+        + 0.3 * punctuation_density * 100
+        + 0.3 * entropy(text) * 10,
+        3,
+    )
+
+
+def protocol_compliance(text: str) -> Dict[str, Any]:
+    """Detect responses that ask questions or add meta/explanatory text."""
+
+    question_marks = text.count("?") + text.count("\uff1f")
+    meta_hits = sum(bool(re.search(pattern, text, re.IGNORECASE)) for pattern in META_PATTERNS)
+
+    asked_question = question_marks > 0
+    added_explanation = meta_hits > 0
+
+    return {
+        "asked_question": asked_question,
+        "added_explanation": added_explanation,
+        "protocol_compliant": not (asked_question or added_explanation),
+        "question_marks": question_marks,
+        "meta_phrase_hits": meta_hits,
+    }
+
+
+def language_script_match(text: str, language: Optional[str]) -> Dict[str, Any]:
+    """Check whether Chinese outputs are mostly CJK characters.
+
+    Non-Chinese languages return null values because this lightweight diagnostic
+    is only defined for the Chinese-script condition used in the benchmark workflow.
+    """
+
+    lang = (language or "").lower()
+    if lang not in CHINESE_LANGUAGE_CODES:
+        return {"script_match": None, "script_ratio": None}
+
+    chars = [char for char in text if char.strip()]
+    if not chars:
+        return {"script_match": False, "script_ratio": 0.0}
+
+    cjk_count = sum(bool(CJK_REGEX.match(char)) for char in chars)
+    ratio = cjk_count / len(chars)
+    return {"script_match": ratio >= 0.9, "script_ratio": round(ratio, 3)}
+
+
+def first_present(record: Mapping[str, Any], fields: tuple[str, ...]) -> Optional[str]:
+    """Return the first non-empty string-like value from a set of fields."""
+
+    for field in fields:
+        value = record.get(field)
+        if value is None:
+            continue
+        value = str(value)
+        if value.strip():
+            return value
+    return None
+
+
+def extract_assisted_text(record: Mapping[str, Any]) -> Optional[str]:
+    """Extract a model's mediated/assisted prompt from common output fields."""
+
+    return first_present(record, ASSISTED_TEXT_FIELDS)
+
+
+def extract_raw_prompt(record: Mapping[str, Any]) -> Optional[str]:
+    """Extract the noisy user prompt from common input fields."""
+
+    return first_present(record, RAW_PROMPT_FIELDS)
+
+
+def compute_metrics(
+    record: Mapping[str, Any],
+    *,
+    model: Optional[str] = None,
+    noise: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Compute row-level APM benchmark metrics for one model output."""
+
+    raw_prompt = extract_raw_prompt(record)
+    assisted_text = extract_assisted_text(record)
+    if raw_prompt is None or assisted_text is None:
+        return None
+
+    b_raw = cognitive_burden(raw_prompt)
+    b_assist = cognitive_burden(assisted_text)
+    language = record.get("language")
+
+    row: Dict[str, Any] = {
+        "example_id": record.get("example_id"),
+        "model": record.get("model") or model,
+        "noise": record.get("noise") or noise,
+        "language": language,
+        "alpha": record.get("alpha"),
+        **protocol_compliance(assisted_text),
+        **language_script_match(assisted_text, language),
+        "B_raw": b_raw,
+        "B_assist": b_assist,
+        "BRS": round(b_raw - b_assist, 3),
+    }
+    return row
+
+
+def flatten_judge_fields(record: Mapping[str, Any]) -> Dict[str, Any]:
+    """Collect judge metrics, accepting nested or already-prefixed schemas."""
+
+    flattened: Dict[str, Any] = {}
+
+    judge = record.get("judge")
+    if isinstance(judge, Mapping):
+        for key, value in judge.items():
+            flattened[f"judge_{key}"] = value
+
+    for key, value in record.items():
+        if key.startswith("judge_"):
+            flattened[key] = value
+
+    return flattened
+
+
+def normalize_bool(value: Any) -> bool:
+    """Convert common serialized boolean values into Python booleans."""
+
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return False
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        return value.strip().lower() in {"1", "true", "yes", "y", "pass"}
+    return bool(value)

scripts/compile_results.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Merge row-level metrics with judge annotations into compiled benchmark files."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Dict, Iterable, Iterator, Tuple
+
+from apm_metrics import flatten_judge_fields, load_json_or_jsonl, write_json
+
+
+TEXT_FIELDS = (
+    "clean_text",
+    "noisy_prompt",
+    "model_response",
+    "response",
+    "assisted_prompt",
+    "mediated_prompt",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--metrics-root",
+        type=Path,
+        required=True,
+        help="Root containing <model>/<noise>/metrics.json files.",
+    )
+    parser.add_argument(
+        "--judged-root",
+        type=Path,
+        required=True,
+        help="Root containing <model>/<noise>/results.jsonl files with judge annotations.",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=Path("compiled"),
+        help="Directory where compiled JSON files will be written.",
+    )
+    parser.add_argument(
+        "--include-text-fields",
+        action="store_true",
+        help="Include source prompts and model responses when present.",
+    )
+    return parser.parse_args()
+
+
+def judged_file(noise_dir: Path) -> Path | None:
+    for preferred in ("results.jsonl", "results.json"):
+        path = noise_dir / preferred
+        if path.exists():
+            return path
+
+    candidates = sorted(
+        path for path in noise_dir.iterdir() if path.is_file() and path.suffix in {".json", ".jsonl"}
+    )
+    return candidates[0] if candidates else None
+
+
+def discover_judged(judged_root: Path) -> Iterator[Tuple[str, str, Path]]:
+    for model_dir in sorted(path for path in judged_root.iterdir() if path.is_dir()):
+        for noise_dir in sorted(path for path in model_dir.iterdir() if path.is_dir()):
+            path = judged_file(noise_dir)
+            if path is not None:
+                yield model_dir.name, noise_dir.name, path
+
+
+def compile_file(
+    *,
+    model: str,
+    noise: str,
+    metrics_path: Path,
+    judged_path: Path,
+    output_path: Path,
+    include_text_fields: bool,
+) -> Tuple[int, int]:
+    metrics = load_json_or_jsonl(metrics_path)
+    judged = load_json_or_jsonl(judged_path)
+
+    metrics_by_id: Dict[str, Dict] = {
+        row["example_id"]: row for row in metrics if row.get("example_id") is not None
+    }
+
+    compiled = []
+    missing = 0
+
+    for judged_row in judged:
+        ex_id = judged_row.get("example_id")
+        metric_row = metrics_by_id.get(ex_id)
+        if metric_row is None:
+            missing += 1
+            continue
+
+        row = {
+            "example_id": ex_id,
+            "model": metric_row.get("model") or judged_row.get("model") or model,
+            "noise": metric_row.get("noise") or judged_row.get("noise") or noise,
+        }
+
+        for key, value in metric_row.items():
+            if key not in {"example_id", "model", "noise"}:
+                row[key] = value
+
+        row.update(flatten_judge_fields(judged_row))
+
+        if include_text_fields:
+            for key in TEXT_FIELDS:
+                if key in judged_row:
+                    row[key] = judged_row[key]
+
+        compiled.append(row)
+
+    write_json(compiled, output_path)
+    return len(compiled), missing
+
+
+def main() -> None:
+    args = parse_args()
+
+    total_rows = 0
+    total_missing = 0
+    total_files = 0
+
+    for model, noise, judged_path in discover_judged(args.judged_root):
+        metrics_path = args.metrics_root / model / noise / "metrics.json"
+        if not metrics_path.exists():
+            print(f"Skipping {model}/{noise}: missing {metrics_path}")
+            continue
+
+        output_path = args.output_root / model / noise / "compiled.json"
+        rows, missing = compile_file(
+            model=model,
+            noise=noise,
+            metrics_path=metrics_path,
+            judged_path=judged_path,
+            output_path=output_path,
+            include_text_fields=args.include_text_fields,
+        )
+        total_rows += rows
+        total_missing += missing
+        total_files += 1
+        print(f"{model}/{noise}: {rows} compiled rows, {missing} missing metrics -> {output_path}")
+
+    print(
+        f"Compiled {total_rows} rows from {total_files} files; "
+        f"{total_missing} judged rows had no matching metric row"
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/evaluate_outputs.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Compute APM row-level metrics for model output files."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+from typing import Iterable, Iterator, Optional, Tuple
+
+from apm_metrics import compute_metrics, load_json_or_jsonl, write_json
+
+
+NOISE_RE = re.compile(r"N\d+")
+JSON_EXTENSIONS = {".json", ".jsonl"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input-root",
+        type=Path,
+        required=True,
+        help="Root containing <model>/<noise>/results.jsonl outputs.",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=Path("metrics"),
+        help="Directory where metric JSON files will be written.",
+    )
+    parser.add_argument(
+        "--model",
+        help="Model name to use when --input-root directly contains N*/ folders or is a file.",
+    )
+    parser.add_argument(
+        "--noise",
+        help="Noise label to use when --input-root is a single file.",
+    )
+    return parser.parse_args()
+
+
+def is_json_data_file(path: Path) -> bool:
+    return path.suffix in JSON_EXTENSIONS and path.name not in {"metrics.json", "compiled.json"}
+
+
+def preferred_files(noise_dir: Path) -> Iterable[Path]:
+    for preferred in ("results.jsonl", "results.json"):
+        path = noise_dir / preferred
+        if path.exists():
+            return [path]
+    return sorted(path for path in noise_dir.iterdir() if path.is_file() and is_json_data_file(path))
+
+
+def direct_noise_dirs(root: Path) -> bool:
+    dirs = [path for path in root.iterdir() if path.is_dir()]
+    return bool(dirs) and all(NOISE_RE.fullmatch(path.name) for path in dirs)
+
+
+def discover_inputs(
+    input_root: Path,
+    model_override: Optional[str],
+    noise_override: Optional[str],
+) -> Iterator[Tuple[str, str, Path, Path]]:
+    """Yield model, noise, input path, and output-relative metric path."""
+
+    if input_root.is_file():
+        if not model_override or not noise_override:
+            raise SystemExit("Single-file mode requires --model and --noise")
+        yield model_override, noise_override, input_root, Path(model_override) / noise_override / "metrics.json"
+        return
+
+    if direct_noise_dirs(input_root):
+        model = model_override or input_root.name
+        for noise_dir in sorted(path for path in input_root.iterdir() if path.is_dir()):
+            for file_path in preferred_files(noise_dir):
+                out_name = "metrics.json" if file_path.stem == "results" else f"{file_path.stem}_metrics.json"
+                yield model, noise_dir.name, file_path, Path(model) / noise_dir.name / out_name
+        return
+
+    for model_dir in sorted(path for path in input_root.iterdir() if path.is_dir()):
+        model = model_override or model_dir.name
+        for noise_dir in sorted(path for path in model_dir.iterdir() if path.is_dir()):
+            if noise_override and noise_dir.name != noise_override:
+                continue
+            for file_path in preferred_files(noise_dir):
+                out_name = "metrics.json" if file_path.stem == "results" else f"{file_path.stem}_metrics.json"
+                yield model, noise_dir.name, file_path, Path(model) / noise_dir.name / out_name
+
+
+def evaluate_file(input_path: Path, output_path: Path, model: str, noise: str) -> Tuple[int, int]:
+    records = load_json_or_jsonl(input_path)
+    metrics = []
+    skipped = 0
+
+    for record in records:
+        row = compute_metrics(record, model=model, noise=noise)
+        if row is None:
+            skipped += 1
+            continue
+        metrics.append(row)
+
+    write_json(metrics, output_path)
+    return len(metrics), skipped
+
+
+def main() -> None:
+    args = parse_args()
+
+    total_rows = 0
+    total_skipped = 0
+    total_files = 0
+
+    for model, noise, input_path, rel_output_path in discover_inputs(
+        args.input_root,
+        args.model,
+        args.noise,
+    ):
+        output_path = args.output_root / rel_output_path
+        rows, skipped = evaluate_file(input_path, output_path, model=model, noise=noise)
+        total_rows += rows
+        total_skipped += skipped
+        total_files += 1
+        print(f"{model}/{noise}: {rows} rows, {skipped} skipped -> {output_path}")
+
+    print(
+        f"Processed {total_files} files with {total_rows} metric rows "
+        f"and {total_skipped} skipped rows"
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_inference_inputs.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Convert APM prompt CSV files into JSONL examples for model inference."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+
+
+FILENAME_RE = re.compile(r"prompts_(?P<language>.+)_(?P<noise>N\d+)\.csv$")
+ALPHA_RE = re.compile(r"alpha_(?P<value>\d+(?:\.\d+)?)$")
+DEFAULT_INSTRUCTION = (
+    "Rewrite the noisy user prompt into a clear prompt that preserves the user's "
+    "intent. Return only the rewritten prompt; do not ask clarification questions "
+    "or add explanations."
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--dataset-dir",
+        type=Path,
+        default=Path("."),
+        help="Directory containing prompts_<language>_<noise>.csv files.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("benchmark_inputs"),
+        help="Directory where JSONL inference inputs will be written.",
+    )
+    parser.add_argument(
+        "--no-instruction",
+        action="store_true",
+        help="Do not include the default mediation instruction in each row.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace existing output files.",
+    )
+    return parser.parse_args()
+
+
+def alpha_columns(fieldnames: Iterable[str]) -> List[str]:
+    columns = [name for name in fieldnames if ALPHA_RE.fullmatch(name)]
+    return sorted(columns, key=lambda name: float(ALPHA_RE.fullmatch(name).group("value")))
+
+
+def example_id(payload: Dict[str, Any]) -> str:
+    stable = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha1(stable.encode("utf-8")).hexdigest()
+
+
+def iter_examples(csv_path: Path, include_instruction: bool) -> Iterable[Dict[str, Any]]:
+    match = FILENAME_RE.match(csv_path.name)
+    if not match:
+        return
+
+    language = match.group("language")
+    noise = match.group("noise")
+
+    with csv_path.open("r", encoding="utf-8-sig", newline="") as f:
+        reader = csv.DictReader(f)
+        if reader.fieldnames is None:
+            return
+        alphas = alpha_columns(reader.fieldnames)
+
+        for row_index, row in enumerate(reader):
+            clean_text = row.get("Clean_text", "")
+            category = row.get("Category", "")
+            for alpha_col in alphas:
+                alpha_value = float(ALPHA_RE.fullmatch(alpha_col).group("value"))
+                noisy_prompt = row.get(alpha_col, "")
+                identity = {
+                    "language": language,
+                    "noise": noise,
+                    "row_index": row_index,
+                    "alpha": alpha_value,
+                    "clean_text": clean_text,
+                    "noisy_prompt": noisy_prompt,
+                }
+                example = {
+                    "example_id": example_id(identity),
+                    "language": language,
+                    "noise": noise,
+                    "category": category,
+                    "alpha": alpha_value,
+                    "clean_text": clean_text,
+                    "noisy_prompt": noisy_prompt,
+                    "source_file": csv_path.name,
+                    "row_index": row_index,
+                }
+                if include_instruction:
+                    example["instruction"] = DEFAULT_INSTRUCTION
+                yield example
+
+
+def main() -> None:
+    args = parse_args()
+    csv_paths = sorted(args.dataset_dir.glob("prompts_*_N*.csv"))
+    if not csv_paths:
+        raise SystemExit(f"No prompt CSV files found in {args.dataset_dir}")
+
+    total = 0
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    for csv_path in csv_paths:
+        match = FILENAME_RE.match(csv_path.name)
+        if not match:
+            continue
+
+        language = match.group("language")
+        noise = match.group("noise")
+        out_dir = args.output_dir / noise
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / f"{language}.jsonl"
+
+        if out_path.exists() and not args.overwrite:
+            raise SystemExit(f"{out_path} already exists; pass --overwrite to replace it")
+
+        count = 0
+        with out_path.open("w", encoding="utf-8") as f:
+            for example in iter_examples(csv_path, include_instruction=not args.no_instruction):
+                f.write(json.dumps(example, ensure_ascii=False) + "\n")
+                count += 1
+
+        total += count
+        print(f"Wrote {count:5d} examples -> {out_path}")
+
+    print(f"Prepared {total} inference examples")
+
+
+if __name__ == "__main__":
+    main()