update

analyze_prompt_number_coverage.py

@@ -1,5 +1,5 @@
 # /// script
-# dependencies = ["inspect-ai"]
+# dependencies = ["inspect-ai", "matplotlib", "numpy"]
 # ///
 """Measure whether every number in each prompt appears in the model response.
 
@@ -8,7 +8,7 @@ Numbers are matched as complete numeric tokens and normalized by value, so
 values are treated as one distinct number.
 
 Example:
-    uv run hf_dataset/analyze_prompt_number_coverage.py hf_dataset/logs/example.eval
+    uv run hf_dataset/analyze_prompt_number_coverage.py
 """
 
 from __future__ import annotations
@@ -16,18 +16,54 @@ from __future__ import annotations
 import argparse
 import csv
 import json
-import os
+import math
 import re
+from collections import defaultdict
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from decimal import Decimal, InvalidOperation
 from pathlib import Path
 from typing import Any
 
+import matplotlib.pyplot as plt
+import numpy as np
 from inspect_ai.log import read_eval_log
+from matplotlib.ticker import PercentFormatter
 
+DEFAULT_LOG_DIR = Path(__file__).resolve().parent / "logs"
 NUMBER_RE = re.compile(
     r"(?<![\w.])[-+]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?!\w|\.\d)"
 )
+LANGUAGE_LABELS = {
+    "dan": "Danish",
+    "deu": "German",
+    "eng": "English",
+    "fra": "French",
+    "isl": "Icelandic",
+    "ita": "Italian",
+    "nob": "Norwegian Bokmal",
+    "por": "Portuguese",
+    "rus": "Russian",
+    "spa": "Spanish",
+    "ukr": "Ukrainian",
+    "zho": "Chinese",
+}
+LANGUAGE_SPEAKERS = {
+    "eng": 380_000_000,
+    "deu": 100_000_000,
+    "dan": 6_000_000,
+    "nob": 5_000_000,
+    "isl": 370_000,
+}
+HUMAN_VERIFIED_LANGUAGES = {"eng", "dan"}
+
+plt.rcParams.update(
+    {
+        "axes.spines.right": False,
+        "axes.spines.top": False,
+        "figure.dpi": 160,
+        "font.family": "sans-serif",
+    }
+)
 
 
 def normalize_number(token: str) -> Decimal | None:
@@ -175,7 +211,7 @@ def discover_logs(inputs: list[Path]) -> list[Path]:
 def resolve_worker_count(requested: int | None, log_count: int) -> int:
     if requested is not None and requested < 1:
         raise ValueError("--workers must be at least 1.")
-    default = min(4, os.cpu_count() or 1)
+    default = 128
     return min(requested or default, log_count)
 
 
@@ -214,6 +250,143 @@ def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
         writer.writerows(rows)
 
 
+def model_name(raw_model: str) -> str:
+    """Drop provider and organization prefixes while preserving the model id."""
+    return raw_model.rstrip("/").split("/")[-1]
+
+
+def model_sort_key(raw_model: str) -> tuple[int, float, str]:
+    """Keep common model families and sizes together in the heatmap."""
+    name = model_name(raw_model)
+    lower = name.lower()
+    family_order = 4
+    if "qwen" in lower:
+        family_order = 0
+    elif "llama" in lower:
+        family_order = 1
+    elif "gemma" in lower:
+        family_order = 2
+    elif raw_model.lower().startswith("openai/") or lower.startswith(("gpt-", "o1", "o3", "o4")):
+        family_order = 3
+
+    size_match = re.search(r"(?<![\d.])(\d+(?:\.\d+)?)\s*b(?:\b|[-_])", lower)
+    size = float(size_match.group(1)) if size_match else math.inf
+    return family_order, size, name
+
+
+def format_speaker_count(count: int) -> str:
+    if count >= 1_000_000:
+        return f"{count / 1_000_000:g}M"
+    if count >= 1_000:
+        return f"{count / 1_000:g}K"
+    return str(count)
+
+
+def heatmap_language_label(language: str) -> str:
+    name = LANGUAGE_LABELS.get(language, language)
+    speakers = LANGUAGE_SPEAKERS.get(language)
+    return f"{name}\n({format_speaker_count(speakers)} speakers)" if speakers is not None else name
+
+
+def number_coverage_grid(
+    rows: list[dict[str, Any]],
+) -> tuple[list[str], list[str], np.ndarray, np.ndarray]:
+    """Aggregate sample-level number coverage into model-by-language cells."""
+    counts: dict[tuple[str, str], list[int]] = defaultdict(lambda: [0, 0])
+    for row in rows:
+        model = str(row.get("model") or "").strip()
+        language = str(row.get("language") or "").strip()
+        if not model or not language:
+            continue
+        cell = counts[(model, language)]
+        cell[0] += int(bool(row["all_prompt_numbers_present"]))
+        cell[1] += 1
+
+    models = sorted({model for model, _ in counts}, key=model_sort_key)
+    languages = sorted(
+        {language for _, language in counts},
+        key=lambda language: (-LANGUAGE_SPEAKERS.get(language, -1), language),
+    )
+    rates = np.full((len(models), len(languages)), np.nan)
+    samples = np.zeros((len(models), len(languages)), dtype=int)
+    for model_index, model in enumerate(models):
+        for language_index, language in enumerate(languages):
+            covered, total = counts.get((model, language), (0, 0))
+            if total:
+                rates[model_index, language_index] = covered / total
+                samples[model_index, language_index] = total
+    return models, languages, rates, samples
+
+
+def plot_number_coverage_heatmap(rows: list[dict[str, Any]], path: Path) -> bool:
+    """Plot the sample-level coverage results by evaluated model and language."""
+    models, languages, rates, samples = number_coverage_grid(rows)
+    if not models or not languages:
+        return False
+
+    display_names = [model_name(model) for model in models]
+    if len(set(display_names)) != len(display_names):
+        display_names = models
+
+    cmap = plt.colormaps["viridis"].copy()
+    cmap.set_bad("#E0E0E0")
+    fig, ax = plt.subplots(
+        figsize=(max(7, 1.35 * len(languages) + 3.5), max(4, 0.6 * len(models) + 1.8))
+    )
+    image = ax.imshow(rates, aspect="auto", cmap=cmap, vmin=0, vmax=1)
+    ax.set_xticks(
+        range(len(languages)),
+        [heatmap_language_label(language) for language in languages],
+        rotation=40,
+        ha="right",
+    )
+    for column_index, language in enumerate(languages):
+        if language not in HUMAN_VERIFIED_LANGUAGES:
+            continue
+        ax.annotate(
+            "*",
+            xy=(column_index, 0),
+            xycoords=ax.get_xaxis_transform(),
+            xytext=(1, -4),
+            textcoords="offset points",
+            color="#FFC107",
+            fontweight="bold",
+            rotation=40,
+            ha="left",
+            va="top",
+            annotation_clip=False,
+        )
+    ax.set_yticks(range(len(models)), display_names)
+    ax.set_xlabel("Problem language")
+    ax.set_ylabel("Evaluated instruction-tuned model")
+    ax.set_title("Prompt number coverage by model and language")
+
+    for row_index in range(len(models)):
+        for column_index in range(len(languages)):
+            rate = rates[row_index, column_index]
+            if np.isnan(rate):
+                continue
+            text_color = "white" if rate < 0.45 else "black"
+            ax.text(
+                column_index,
+                row_index,
+                f"{rate:.1%}\n(n={samples[row_index, column_index]:,})",
+                ha="center",
+                va="center",
+                color=text_color,
+                fontsize=7,
+            )
+
+    colorbar = fig.colorbar(image, ax=ax, label="Samples containing every prompt number")
+    colorbar.ax.yaxis.set_major_formatter(PercentFormatter(1))
+    fig.text(0.47, 0.015, "*", color="#FFC107", fontweight="bold", ha="right", fontsize=8)
+    fig.text(0.472, 0.015, "Human verified", ha="left", fontsize=8)
+    fig.subplots_adjust(left=0.22, right=0.88, bottom=0.31, top=0.9)
+    fig.savefig(path, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
 def run_self_test() -> None:
     cases = [
         ("Use 10, 10.0, and 1,000.", "10 and 1000", True),
@@ -228,14 +401,34 @@ def run_self_test() -> None:
             raise AssertionError(
                 f"Failed: prompt={prompt!r}, response={response!r}, expected={expected}, got={actual}"
             )
+    models, languages, rates, samples = number_coverage_grid(
+        [
+            {"model": "provider/model-1B", "language": "eng", "all_prompt_numbers_present": True},
+            {"model": "provider/model-1B", "language": "eng", "all_prompt_numbers_present": False},
+            {"model": "provider/model-1B", "language": "dan", "all_prompt_numbers_present": True},
+        ]
+    )
+    if models != ["provider/model-1B"] or languages != ["eng", "dan"]:
+        raise AssertionError("Failed to build the expected model-language coverage grid.")
+    if rates.tolist() != [[0.5, 1.0]] or samples.tolist() != [[2, 1]]:
+        raise AssertionError("Failed to aggregate model-language coverage rates.")
     print(f"Self-test passed ({len(cases)} cases).")
 
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("inputs", nargs="*", type=Path, help="Inspect .eval logs or directories containing logs.")
+    parser.add_argument(
+        "inputs",
+        nargs="*",
+        type=Path,
+        help=f"Inspect .eval logs or directories containing logs. Defaults to {DEFAULT_LOG_DIR}.",
+    )
     parser.add_argument("--out-dir", type=Path, default=Path("prompt_number_coverage"))
-    parser.add_argument("--max-samples", type=int)
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        help="Maximum samples to analyze per log. Defaults to all samples.",
+    )
     parser.add_argument(
         "--workers",
         type=int,
@@ -249,7 +442,8 @@ def main() -> None:
         if not args.inputs:
             return
 
-    logs = discover_logs(args.inputs)
+    inputs = args.inputs or [DEFAULT_LOG_DIR]
+    logs = discover_logs(inputs)
     if not logs:
         raise SystemExit("No non-empty .eval logs found.")
 
@@ -271,6 +465,8 @@ def main() -> None:
         encoding="utf-8",
     )
     write_csv(args.out_dir / "samples.csv", sample_rows)
+    heatmap_path = args.out_dir / "number_coverage_heatmap.png"
+    wrote_heatmap = plot_number_coverage_heatmap(sample_rows, heatmap_path)
 
     for summary in summaries:
         breakdown = summary["number_coverage_breakdown"]
@@ -280,6 +476,8 @@ def main() -> None:
             f"right={breakdown['final_correct']['all_prompt_numbers_present_rate']!s}, "
             f"wrong={breakdown['final_incorrect']['all_prompt_numbers_present_rate']!s}"
         )
+    if wrote_heatmap:
+        print(f"Wrote {heatmap_path}")
     print(f"Wrote {args.out_dir}")
 
 

analyze_transfer_features.py

@@ -345,6 +345,7 @@ def relationship_plot(
     xlabel: str,
     title: str,
     out: Path,
+    shared_xlabel: bool = False,
 ) -> bool:
     """Plot a descriptive feature relationship separately for each split."""
     plot_data = data.dropna(subset=[x_column, "transfer_gap"])
@@ -402,16 +403,26 @@ def relationship_plot(
 
         ax.axhline(0, color="black", linewidth=0.8, alpha=0.4)
         ax.grid(alpha=0.2)
-        ax.set_xlabel(xlabel)
+        ax.set_xlabel("" if shared_xlabel else xlabel)
         ax.set_ylabel("Accuracy gap: English - target language")
         ax.yaxis.set_major_formatter(PercentFormatter(1))
         ax.set_title(SPLIT_LABELS[split])
 
     handles, labels = axes[0].get_legend_handles_labels()
     if handles:
-        fig.legend(handles, labels, loc="lower center", ncol=len(labels), frameon=False)
+        legend_y = 0.005 if shared_xlabel else None
+        fig.legend(
+            handles,
+            labels,
+            loc="lower center",
+            bbox_to_anchor=(0.5, legend_y) if legend_y is not None else None,
+            ncol=len(labels),
+            frameon=False,
+        )
+    if shared_xlabel:
+        fig.supxlabel(xlabel, y=0.09)
     fig.suptitle(title)
-    fig.tight_layout(rect=(0, 0.07, 1, 0.94))
+    fig.tight_layout(rect=(0, 0.16 if shared_xlabel else 0.07, 1, 0.94))
     fig.savefig(out, bbox_inches="tight")
     plt.close(fig)
     return True
@@ -510,22 +521,32 @@ def main() -> None:
             "TFR: target-language tokens/character divided by English tokens/character. Computed on GSM8K templates.",
             "English-minus-target-language accuracy gap versus tokenizer fertility ratio (TFR)",
             args.out_dir / "tokenizer_fertility_vs_transfer.png",
+            True,
         ),
         (
             "typological_distance_from_english",
             "URIEL cosine distance from English (syntax + phoneme inventory features)",
             "English-minus-target-language accuracy gap versus typological distance from English",
             args.out_dir / "typological_distance_vs_transfer.png",
+            False,
         ),
         (
             "log10_common_crawl_pages",
             "Language-resource proxy: log10 Common Crawl page count",
             "English-minus-target-language accuracy gap versus Common Crawl resource quantity",
             args.out_dir / "resource_quantity_vs_transfer.png",
+            False,
         ),
     ]
-    for column, xlabel, title, path in plots:
-        if relationship_plot(transfer, column, xlabel, title, path):
+    for column, xlabel, title, path, shared_xlabel in plots:
+        if relationship_plot(
+            transfer,
+            column,
+            xlabel,
+            title,
+            path,
+            shared_xlabel=shared_xlabel,
+        ):
             print(f"Saved {path}")
         else:
             print(f"Skipped {path.name}: no paired transfer observations with this feature.")

plot_language_ridgeline.py

@@ -0,0 +1,695 @@
+# /// script
+# dependencies = ["inspect-ai", "matplotlib", "numpy", "pandas", "scipy"]
+# ///
+"""Plot original accuracy against sampled synthetic-set distributions by language.
+
+The synthetic distribution follows the benchmark sampling scheme used in
+``visualize_results.py``: each sampled set chooses one numerical variant from
+every source template, then averages correctness across the selected problems.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from inspect_ai.log import read_eval_log
+from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
+from matplotlib.ticker import PercentFormatter
+from scipy.stats import norm
+
+LANGUAGE_LABELS = {
+    "eng": "English",
+    "dan": "Danish",
+    "deu": "German",
+    "nob": "Norwegian Bokmal",
+    "isl": "Icelandic",
+}
+LANGUAGE_SPEAKERS = {
+    "eng": 380_000_000,
+    "deu": 100_000_000,
+    "dan": 6_000_000,
+    "nob": 5_000_000,
+    "isl": 370_000,
+}
+HUMAN_VERIFIED_LANGUAGES = {"eng", "dan"}
+
+SYNTHETIC_COLOR = "#173B75"
+SYNTHETIC_FILL = "#AFC0DD"
+ORIGINAL_COLOR = "#C61B3C"
+GRID_COLOR = "#D8DEE8"
+TEXT_COLOR = "#162033"
+
+plt.rcParams.update(
+    {
+        "axes.spines.left": False,
+        "axes.spines.right": False,
+        "axes.spines.top": False,
+        "figure.dpi": 160,
+        "font.family": "sans-serif",
+        "text.color": TEXT_COLOR,
+        "axes.labelcolor": TEXT_COLOR,
+        "xtick.color": "#4A5568",
+        "ytick.color": TEXT_COLOR,
+    }
+)
+
+
+@dataclass(frozen=True)
+class PlotStats:
+    language: str
+    original_accuracy: float
+    synthetic_mean: float
+    synthetic_std: float
+    shift_pp: float
+    n_models: int
+    n_templates: int
+    n_sampled_sets: int
+
+
+def model_name(raw_model: str) -> str:
+    """Remove provider prefixes while preserving the model identifier."""
+    return raw_model.rstrip("/").split("/")[-1]
+
+
+def model_family(model: str) -> str:
+    lower = model.lower()
+    if "qwen2.5" in lower:
+        return "Qwen2.5"
+    if "olmo-2" in lower:
+        return "OLMo 2"
+    if "gemma-3" in lower:
+        return "Gemma 3"
+    if re.search(r"llama[-_. ]?3", lower):
+        return "Llama 3"
+    if "apertus" in lower:
+        return "Apertus"
+    return "Other"
+
+
+def path_slug(value: str) -> str:
+    slug = re.sub(r"[^a-z0-9.]+", "-", value.lower()).strip("-")
+    return slug or "unknown"
+
+
+def format_speaker_count(count: int) -> str:
+    if count >= 1_000_000:
+        return f"{count / 1_000_000:g}M"
+    if count >= 1_000:
+        return f"{count / 1_000:g}K"
+    return str(count)
+
+
+def language_title(language: str) -> str:
+    label = LANGUAGE_LABELS.get(language, language)
+    speakers = LANGUAGE_SPEAKERS.get(language)
+    speaker_label = f" ({format_speaker_count(speakers)} native speakers)" if speakers else ""
+    verified = " ★" if language in HUMAN_VERIFIED_LANGUAGES else ""
+    return f"{label}{speaker_label}{verified}"
+
+
+def parse_task(task: str) -> tuple[str, str] | None:
+    matches = re.findall(r"(original|synthetic)[_-]([a-z]{3})", task.lower())
+    return matches[-1] if matches else None
+
+
+def score_to_float(score: Any) -> float | None:
+    value = getattr(score, "value", score)
+    if isinstance(value, bool):
+        return float(value)
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        normalized = value.strip().upper()
+        if normalized in {"C", "CORRECT", "TRUE"}:
+            return 1.0
+        if normalized in {"I", "INCORRECT", "FALSE"}:
+            return 0.0
+        try:
+            return float(normalized)
+        except ValueError:
+            return None
+    return None
+
+
+def sample_score(sample: Any, scorer: str | None) -> float | None:
+    scores = sample.scores or {}
+    if scorer:
+        return score_to_float(scores.get(scorer)) if scorer in scores else None
+
+    for preferred in ("math", "pattern"):
+        if preferred in scores:
+            return score_to_float(scores[preferred])
+
+    for score in scores.values():
+        value = score_to_float(score)
+        if value is not None:
+            return value
+    return None
+
+
+def _read_log_header(path: Path) -> tuple[Path, Any | None, str | None]:
+    try:
+        return path, read_eval_log(str(path), header_only=True), None
+    except Exception as exc:
+        return path, None, str(exc)
+
+
+def discover_selected_logs(
+    log_dir: Path,
+    requested_models: list[str] | None,
+    workers: int,
+) -> list[Path]:
+    """Select all successful logs and deduplicate snapshots in parallel."""
+    paths = sorted(path for path in log_dir.rglob("*.eval") if path.stat().st_size >= 1_000)
+    if not paths:
+        return []
+
+    requested = {model.lower() for model in requested_models} if requested_models else None
+    selected: dict[tuple[str, str], tuple[Path, Any]] = {}
+
+    if workers <= 1:
+        results = [_read_log_header(path) for path in paths]
+    else:
+        with ThreadPoolExecutor(max_workers=min(workers, len(paths))) as pool:
+            results = list(pool.map(_read_log_header, paths))
+
+    for path, header, error in results:
+        if error:
+            print(f"Skipping unreadable log {path.name}: {error}")
+            continue
+        if str(header.status) != "success" or parse_task(header.eval.task) is None:
+            continue
+        if requested and model_name(header.eval.model).lower() not in requested:
+            continue
+
+        key = (header.eval.eval_id, header.eval.task)
+        previous = selected.get(key)
+        if previous is None or path.stat().st_mtime_ns > previous[0].stat().st_mtime_ns:
+            selected[key] = (path, header)
+
+    return sorted(path for path, _header in selected.values())
+
+
+def _load_one_log(
+    path: Path,
+    scorer: str | None,
+) -> tuple[str, pd.DataFrame | None, str | None]:
+    """Read and partially aggregate one log in a worker process."""
+    try:
+        log = read_eval_log(str(path))
+    except Exception as exc:
+        return path.name, None, f"Skipping unreadable log {path.name}: {exc}"
+
+    parsed = parse_task(log.eval.task)
+    if parsed is None:
+        return path.name, None, f"Skipping unrecognized task {log.eval.task!r}"
+    if not log.samples:
+        return path.name, pd.DataFrame(), None
+
+    split, task_language = parsed
+    model = model_name(log.eval.model)
+    label = f"{model} / {task_language} / {split}"
+    rows: list[dict[str, Any]] = []
+
+    for sample in log.samples:
+        correct = sample_score(sample, scorer)
+        if correct is None:
+            continue
+        metadata = sample.metadata or {}
+        rows.append(
+            {
+                "model": model,
+                "language": metadata.get("language", task_language),
+                "split": split,
+                "sample_id": sample.id,
+                "source_id": metadata.get("source_id", sample.id),
+                "correct": correct,
+            }
+        )
+
+    if not rows:
+        return label, pd.DataFrame(), None
+
+    samples = pd.DataFrame(rows)
+    grouped = (
+        samples.groupby(
+            ["model", "language", "split", "sample_id", "source_id"],
+            dropna=False,
+            as_index=False,
+        )["correct"]
+        .agg(correct_sum="sum", correct_count="size")
+    )
+    return label, grouped, None
+
+
+def load_problem_scores(
+    paths: list[Path],
+    scorer: str | None,
+    workers: int,
+) -> pd.DataFrame:
+    """Load logs in parallel and combine repeated runs by model/problem."""
+    frames: list[pd.DataFrame] = []
+
+    if workers <= 1:
+        results = [_load_one_log(path, scorer) for path in paths]
+        for index, (label, frame, warning) in enumerate(results, start=1):
+            if warning:
+                print(warning)
+            else:
+                print(f"[{index}/{len(paths)}] {label}")
+            if frame is not None and not frame.empty:
+                frames.append(frame)
+    else:
+        with ProcessPoolExecutor(max_workers=min(workers, len(paths))) as pool:
+            futures = [pool.submit(_load_one_log, path, scorer) for path in paths]
+            for index, future in enumerate(as_completed(futures), start=1):
+                label, frame, warning = future.result()
+                if warning:
+                    print(warning)
+                else:
+                    print(f"[{index}/{len(paths)}] {label}")
+                if frame is not None and not frame.empty:
+                    frames.append(frame)
+
+    if not frames:
+        return pd.DataFrame()
+
+    combined = pd.concat(frames, ignore_index=True)
+    keys = ["model", "language", "split", "sample_id", "source_id"]
+    problems = (
+        combined.groupby(keys, dropna=False, as_index=False)
+        .agg(correct_sum=("correct_sum", "sum"), correct_count=("correct_count", "sum"))
+    )
+    problems["correct"] = problems["correct_sum"] / problems["correct_count"]
+    return problems.drop(columns=["correct_sum", "correct_count"])
+
+
+def sample_synthetic_sets(
+    synthetic: pd.DataFrame,
+    n_sets: int,
+    rng: np.random.Generator,
+) -> tuple[np.ndarray, int]:
+    """Sample one variant per source template and return set-level accuracies."""
+    variants = [
+        group["correct"].to_numpy(dtype=float)
+        for _source_id, group in synthetic.groupby("source_id", sort=True, dropna=False)
+    ]
+    if not variants:
+        raise ValueError("Synthetic data contains no source templates.")
+
+    set_totals = np.zeros(n_sets, dtype=float)
+    for values in variants:
+        set_totals += rng.choice(values, size=n_sets, replace=True)
+    return set_totals / len(variants), len(variants)
+
+
+def normal_curve(values: np.ndarray) -> tuple[np.ndarray, np.ndarray, float, float]:
+    """Fit and return a normal probability density for sampled accuracies."""
+    mean = float(values.mean())
+    std = max(float(values.std(ddof=1)), 0.005)
+    lower = max(0.0, mean - 4 * std)
+    upper = min(1.0, mean + 4 * std)
+    x = np.linspace(lower, upper, 500)
+    return x, norm.pdf(x, loc=mean, scale=std), mean, std
+
+
+def collect_plot_data(
+    problems: pd.DataFrame,
+    languages: list[str],
+    n_sets: int,
+    seed: int,
+) -> tuple[dict[str, tuple[np.ndarray, np.ndarray, np.ndarray]], list[PlotStats]]:
+    distributions: dict[str, tuple[np.ndarray, np.ndarray, np.ndarray]] = {}
+    stats: list[PlotStats] = []
+    rng = np.random.default_rng(seed)
+
+    for language in languages:
+        rows = problems[problems["language"] == language]
+        split_models = {
+            split: set(split_rows["model"].unique())
+            for split, split_rows in rows.groupby("split")
+        }
+        paired_models = sorted(
+            split_models.get("original", set()) & split_models.get("synthetic", set())
+        )
+        if not paired_models:
+            print(f"Skipping {language}: both original and synthetic results are required.")
+            continue
+
+        original_by_model: list[float] = []
+        synthetic_by_model: list[np.ndarray] = []
+        n_templates = 0
+        for model in paired_models:
+            model_rows = rows[rows["model"] == model]
+            original = model_rows[model_rows["split"] == "original"]
+            synthetic = model_rows[model_rows["split"] == "synthetic"]
+            original_by_model.append(float(original["correct"].mean()))
+            model_set_means, model_templates = sample_synthetic_sets(
+                synthetic,
+                n_sets,
+                rng,
+            )
+            synthetic_by_model.append(model_set_means)
+            n_templates += model_templates
+
+        set_means = np.mean(np.vstack(synthetic_by_model), axis=0)
+        x, density, synthetic_mean, synthetic_std = normal_curve(set_means)
+        original_accuracy = float(np.mean(original_by_model))
+        distributions[language] = (set_means, x, density)
+        stats.append(
+            PlotStats(
+                language=language,
+                original_accuracy=original_accuracy,
+                synthetic_mean=synthetic_mean,
+                synthetic_std=synthetic_std,
+                shift_pp=(synthetic_mean - original_accuracy) * 100,
+                n_models=len(paired_models),
+                n_templates=n_templates,
+                n_sampled_sets=n_sets,
+            )
+        )
+
+    return distributions, stats
+
+
+def plot_distributions(
+    distributions: dict[str, tuple[np.ndarray, np.ndarray, np.ndarray]],
+    stats: list[PlotStats],
+    scope_label: str,
+    out_png: Path,
+) -> None:
+    if not stats:
+        raise ValueError("No languages have paired original and synthetic results.")
+
+    fig, axes = plt.subplots(
+        len(stats),
+        1,
+        figsize=(10.5, 2.05 * len(stats) + 1.7),
+        sharex=True,
+        squeeze=False,
+    )
+    axes = axes[:, 0]
+
+    for ax, row in zip(axes, stats, strict=True):
+        set_means, x, density = distributions[row.language]
+        peak_density = float(density.max())
+        histogram_bins = min(18, max(8, int(np.sqrt(len(set_means)) / 2)))
+
+        ax.hist(
+            set_means,
+            bins=histogram_bins,
+            density=True,
+            color=SYNTHETIC_FILL,
+            edgecolor="white",
+            linewidth=0.7,
+            alpha=0.72,
+            zorder=1,
+        )
+        ax.fill_between(
+            x,
+            0,
+            density,
+            color=SYNTHETIC_FILL,
+            alpha=0.2,
+            zorder=2,
+        )
+        ax.plot(x, density, color=SYNTHETIC_COLOR, linewidth=2.2, zorder=3)
+        ax.scatter(
+            row.synthetic_mean,
+            peak_density,
+            color=SYNTHETIC_COLOR,
+            s=34,
+            zorder=5,
+        )
+
+        ax.axvline(
+            row.original_accuracy,
+            color=ORIGINAL_COLOR,
+            linewidth=2.4,
+            zorder=4,
+        )
+
+        arrow_y = peak_density * 1.08
+        gap = abs(row.synthetic_mean - row.original_accuracy)
+        if gap < 0.025:
+            cap_height = peak_density * 0.035
+            ax.hlines(
+                arrow_y,
+                row.synthetic_mean,
+                row.original_accuracy,
+                color="black",
+                linewidth=1.2,
+                zorder=6,
+            )
+            ax.vlines(
+                [row.synthetic_mean, row.original_accuracy],
+                arrow_y - cap_height,
+                arrow_y + cap_height,
+                color="black",
+                linewidth=1.2,
+                zorder=6,
+            )
+        else:
+            ax.annotate(
+                "",
+                xy=(row.synthetic_mean, arrow_y),
+                xytext=(row.original_accuracy, arrow_y),
+                arrowprops={
+                    "arrowstyle": "<->",
+                    "color": "black",
+                    "linewidth": 1.2,
+                    "shrinkA": 2,
+                    "shrinkB": 2,
+                },
+                zorder=6,
+            )
+        midpoint = (row.original_accuracy + row.synthetic_mean) / 2
+        ax.text(
+            midpoint,
+            arrow_y + peak_density * 0.045,
+            f"performance gap ({row.shift_pp:+.1f} pp)",
+            color="black",
+            fontsize=8,
+            ha="center",
+            va="bottom",
+            zorder=7,
+        )
+
+        ax.set_title(
+            language_title(row.language),
+            loc="left",
+            fontsize=11,
+            fontweight="semibold",
+            pad=8,
+        )
+        ax.set_ylim(0, peak_density * 1.32)
+        ax.grid(axis="y", color=GRID_COLOR, linewidth=0.7, alpha=0.65)
+        ax.set_axisbelow(True)
+        ax.tick_params(axis="y", labelsize=8)
+
+    axes[-1].set_xlim(0, 1)
+    axes[-1].xaxis.set_major_formatter(PercentFormatter(1))
+    axes[-1].set_xlabel("Exact-answer accuracy", fontsize=11, labelpad=10)
+    fig.supylabel("Density", fontsize=11, x=0.03)
+    fig.suptitle(
+        "Original accuracy and synthetic-set distributions",
+        x=0.08,
+        ha="left",
+        fontsize=17,
+        fontweight="bold",
+        y=0.985,
+    )
+    fig.text(
+        0.08,
+        0.955,
+        f"{scope_label} | one random variant per template in each sampled set",
+        fontsize=10,
+        color="#596579",
+        ha="left",
+        va="top",
+    )
+
+    legend_handles = [
+        Line2D(
+            [0],
+            [0],
+            color=ORIGINAL_COLOR,
+            marker="|",
+            markersize=15,
+            markeredgewidth=2.4,
+            linewidth=0,
+            label="Original benchmark accuracy",
+        ),
+        Patch(
+            facecolor=SYNTHETIC_FILL,
+            edgecolor=SYNTHETIC_COLOR,
+            label="Sampled synthetic sets",
+        ),
+        Line2D(
+            [0],
+            [0],
+            marker="$★$",
+            color="#E0A800",
+            markersize=10,
+            linewidth=0,
+            label="Human verified",
+        ),
+    ]
+    axes[0].legend(
+        handles=legend_handles,
+        loc="upper right",
+        bbox_to_anchor=(1, 1.42),
+        frameon=False,
+        ncol=3,
+        fontsize=9,
+        handlelength=1.8,
+        columnspacing=1.7,
+    )
+
+    fig.tight_layout(rect=(0.045, 0.03, 1, 0.925))
+    fig.savefig(out_png, dpi=220, bbox_inches="tight", facecolor="white")
+    plt.close(fig)
+
+
+def write_summary(stats: list[PlotStats], out_csv: Path) -> None:
+    pd.DataFrame(
+        [
+            {
+                "language": row.language,
+                "language_label": LANGUAGE_LABELS.get(row.language, row.language),
+                "original_accuracy": row.original_accuracy,
+                "synthetic_sampled_mean": row.synthetic_mean,
+                "synthetic_sampled_std": row.synthetic_std,
+                "synthetic_minus_original_pp": row.shift_pp,
+                "paired_models": row.n_models,
+                "source_templates": row.n_templates,
+                "sampled_sets": row.n_sampled_sets,
+            }
+            for row in stats
+        ]
+    ).to_csv(out_csv, index=False)
+
+
+def language_order(available: set[str], requested: list[str] | None) -> list[str]:
+    if requested:
+        return requested
+    return sorted(
+        available,
+        key=lambda language: (-LANGUAGE_SPEAKERS.get(language, -1), language),
+    )
+
+
+def main() -> None:
+    folder = Path(__file__).resolve().parent
+    cpu_count = os.cpu_count() or 1
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--log-dir",
+        type=Path,
+        default=folder / "logs",
+        help="Directory searched recursively for Inspect .eval logs.",
+    )
+    parser.add_argument(
+        "--model",
+        nargs="+",
+        help="Optional model identifiers without provider prefixes; defaults to all models.",
+    )
+    parser.add_argument(
+        "--languages",
+        nargs="+",
+        help="Optional three-letter language codes in display order; defaults to all discovered languages.",
+    )
+    parser.add_argument(
+        "--samples",
+        type=int,
+        default=2_000,
+        help="Number of synthetic benchmark sets to sample.",
+    )
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument(
+        "--scorer",
+        help="Inspect scorer name; defaults to math, pattern, then the first numeric score.",
+    )
+    parser.add_argument(
+        "--output-name",
+        help="Optional filename prefix; model identifiers are always appended.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=max(12, cpu_count),
+        help="Processes used for full log loading; use 1 to disable multiprocessing.",
+    )
+    parser.add_argument(
+        "--header-workers",
+        type=int,
+        default=min(32, max(4, cpu_count * 2)),
+        help="Threads used to inspect and deduplicate log headers.",
+    )
+    args = parser.parse_args()
+
+    if args.samples < 2:
+        parser.error("--samples must be at least 2")
+    if args.workers < 1 or args.header_workers < 1:
+        parser.error("--workers and --header-workers must be at least 1")
+
+    paths = discover_selected_logs(args.log_dir, args.model, args.header_workers)
+    if not paths:
+        requested = f" for models {args.model!r}" if args.model else ""
+        raise SystemExit(f"No successful logs found{requested} in {args.log_dir}.")
+
+    print(f"Selected {len(paths)} successful logs after deduplication.")
+    print(f"Loading logs with {args.workers} worker process(es).")
+    problems = load_problem_scores(paths, args.scorer, args.workers)
+    if problems.empty:
+        raise SystemExit("No scored samples found in the selected logs.")
+
+    models = sorted(problems["model"].unique(), key=lambda model: (model_family(model), model.lower()))
+    all_languages = language_order(set(problems["language"].unique()), args.languages)
+    print(f"Models ({len(models)}): {', '.join(models)}")
+    print(f"Languages ({len(all_languages)}): {', '.join(all_languages)}")
+
+    output_root = folder / "language_ridgeline"
+    for model_index, model in enumerate(models):
+        model_problems = problems[problems["model"] == model]
+        model_languages = language_order(
+            set(model_problems["language"].unique()),
+            args.languages,
+        )
+        curves, stats = collect_plot_data(
+            model_problems,
+            model_languages,
+            args.samples,
+            args.seed + model_index,
+        )
+        if not stats:
+            print(f"Skipping {model}: no languages have paired original and synthetic results.")
+            continue
+
+        family = model_family(model)
+        out_dir = output_root / path_slug(family)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        model_slug = path_slug(model)
+        base_name = f"{path_slug(args.output_name)}-{model_slug}" if args.output_name else model_slug
+        out_png = out_dir / f"{base_name}.png"
+        out_csv = out_dir / f"{base_name}.csv"
+
+        plot_distributions(curves, stats, model, out_png)
+        write_summary(stats, out_csv)
+
+        print(f"Saved {out_png}")
+        print(f"Saved {out_csv}")
+
+
+if __name__ == "__main__":
+    main()

ucloudeval

@@ -20,14 +20,18 @@ MODELS = (
     "Qwen/Qwen2.5-7B-Instruct",
     "Qwen/Qwen2.5-14B-Instruct",
     "Qwen/Qwen2.5-32B-Instruct",
-    "allenai/Olmo-3.1-7B-Instruct",
-    "allenai/Olmo-3.1-32B-Instruct",
+    "allenai/OLMo-2-0425-1B-Instruct",
+    "allenai/OLMo-2-1124-7B-Instruct",
+    "allenai/OLMo-2-1124-13B-Instruct",
+    "allenai/OLMo-2-0325-32B-Instruct",
     "google/gemma-3-1b-it",
     "google/gemma-3-4b-it",
     "google/gemma-3-12b-it",
     "google/gemma-3-27b-it",
-    "swiss-ai/Apertus-8B-Instruct-2509"
-
+    "meta-llama/Llama-3.2-1B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct",
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "swiss-ai/Apertus-8B-Instruct-2509",
 )
 # Repository id (no revision) and optional revision to apply to each task
 DATASET = "danish-foundation-models/multilingual-gsm-symbolic"