Update eval script and add visualization

ucloudeval

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import argparse
+import os
 import subprocess
 import sys
 from collections.abc import Sequence
@@ -24,7 +25,9 @@ MODELS = (
     "google/gemma-3-4b-it",
     "google/gemma-3-12b-it",
 )
-DATASET = "danish-foundation-models/multilingual-gsm-symbolic@refs/pr/4"
+# Repository id (no revision) and optional revision to apply to each task
+DATASET = "danish-foundation-models/multilingual-gsm-symbolic"
+REVISION = "refs/pr/4"
 
 HERE = Path(__file__).resolve().parent
 EVAL_YAML, LOG_DIR = HERE / "eval.yaml", HERE / "logs"
@@ -56,7 +59,10 @@ def load_tasks(path: Path = EVAL_YAML) -> list[Task]:
 
 def build_parser(languages: Sequence[str], splits: Sequence[str]) -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
-        description="Evaluate multilingual GSM-Symbolic tasks against one local vLLM model at a time."
+        description=(
+            "Evaluate multilingual GSM-Symbolic tasks against one local vLLM model at a time, "
+            "resuming completed and interrupted work from the log directory."
+        )
     )
     options = (
         ("model", MODELS, "HF_MODEL_ID", "curated Hugging Face model id"),
@@ -109,13 +115,35 @@ def select_tasks(
 
 
 def inspect_command(model: str, tasks: Sequence[Task]) -> list[str]:
+    # place the revision after the task id so the HF loader parses it correctly
+    specs = [
+        f"hf/{DATASET}/{task.task_id}@{REVISION}" if REVISION else f"hf/{DATASET}/{task.task_id}" for task in tasks
+    ]
     return [
-        "inspect", "eval", *(f"hf/{DATASET}/{task.task_id}" for task in tasks),
-        "--model", f"vllm/{model}", "-M", "dtype=auto",
-        "--max-tasks", "1", "--log-dir", str(LOG_DIR),
+        # Eval sets use the log directory to skip successful tasks and retry
+        # interrupted tasks without repeating their completed samples.
+        "inspect", "eval-set", *specs,
+        "--model", f"vllm/{model}",
+        "-M", "dtype=auto",
+        "-M", "attention_backend=FLASH_ATTN",
+        "-M", "max_num_seqs=512",
+        "--max-connections", "128",
+        "--max-samples", "128",
+        "--max-tasks", "8",
+        "--log-dir", str(LOG_DIR),
+        "--log-dir-allow-dirty",
     ]
 
 
+def vllm_environment() -> dict[str, str]:
+    env = os.environ.copy()
+    # The CUDA 13 packages in this environment have mismatched nvcc/headers.
+    # Avoid vLLM paths that require FlashInfer or DeepGEMM runtime compilation.
+    env.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
+    env.setdefault("VLLM_USE_DEEP_GEMM", "0")
+    return env
+
+
 def show_command(message: str, command: Sequence[str]) -> None:
     print(f"{message}\n  {' '.join(command)}")
 
@@ -124,11 +152,13 @@ def run_inspect(model: str, tasks: Sequence[Task]) -> None:
     command = inspect_command(model, tasks)
     show_command(f"Running {len(tasks)} Inspect task(s) for {model}", command)
     try:
-        subprocess.run(command, check=True)
+        subprocess.run(command, check=True, env=vllm_environment())
     except subprocess.CalledProcessError as error:
         raise RunnerError(f"Inspect failed for {model} with status {error.returncode}") from error
     except OSError as error:
         raise RunnerError(f"Could not start Inspect for {model}: {error}") from error
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     try:
         tasks = load_tasks()

visualize_model_grid.py

@@ -0,0 +1,479 @@
+# /// script
+# dependencies = ["inspect-ai", "matplotlib", "numpy", "pandas"]
+# ///
+"""Visualize multilingual GSM evaluation logs across models and splits.
+
+The script reads Inspect ``.eval`` logs and writes:
+
+* ``run_summary.csv``: tidy accuracy table for downstream analysis.
+* ``accuracy_heatmaps.png``: original, synthetic, and original-minus-synthetic.
+* ``original_vs_synthetic.png``: paired split performance for each model/language.
+* ``family_scaling.png``: within-family accuracy as a function of parameter count.
+
+Only successful logs are included by default. Repeated/resumed logs with the same
+evaluation id are deduplicated, preferring a successful and then newer log.
+
+Example:
+    uv run hf_dataset/visualize_model_grid.py --log-dir hf_dataset/logs
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+import re
+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
+
+
+@dataclass(frozen=True)
+class ModelInfo:
+    family: str
+    params_b: float | None
+    vocab_size: int | None = None
+    training_language: str = ""
+    pretrain_tokens_t: float | None = None
+
+
+# Values are intentionally easy to edit as model documentation is revised.
+MODEL_CATALOG = {
+    "qwen2.5-0.5b-instruct": ModelInfo("Qwen2.5", 0.5, 151_936, "Chinese-English; multilingual", 18),
+    "qwen2.5-1.5b-instruct": ModelInfo("Qwen2.5", 1.5, 151_936, "Chinese-English; multilingual", 18),
+    "qwen2.5-3b-instruct": ModelInfo("Qwen2.5", 3, 151_936, "Chinese-English; multilingual", 18),
+    "qwen2.5-7b-instruct": ModelInfo("Qwen2.5", 7, 151_936, "Chinese-English; multilingual", 18),
+    "llama-3.2-1b-instruct": ModelInfo("Llama 3", 1, 128_256, "English-centric", 9),
+    "llama-3.2-3b-instruct": ModelInfo("Llama 3", 3, 128_256, "English-centric", 9),
+    "llama-3.1-8b-instruct": ModelInfo("Llama 3", 8, 128_256, "English-centric", 15),
+    "gemma-3-1b-it": ModelInfo("Gemma 3", 1, 262_144, "English-oriented", 2),
+    "gemma-3-4b-it": ModelInfo("Gemma 3", 4, 262_144, "Multilingual; 140+ languages", 4),
+    "gemma-3-12b-it": ModelInfo("Gemma 3", 12, 262_144, "Multilingual; 140+ languages", 12),
+}
+
+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",
+}
+
+FAMILY_COLORS = {
+    "Qwen2.5": "#7B2CBF",
+    "Llama 3": "#E76F51",
+    "Gemma 3": "#2A9D8F",
+    "OpenAI": "#457B9D",
+    "Other": "#666666",
+}
+
+plt.rcParams.update(
+    {
+        "axes.spines.right": False,
+        "axes.spines.top": False,
+        "figure.dpi": 160,
+        "font.family": "sans-serif",
+    }
+)
+
+
+def model_name(raw_model: str) -> str:
+    """Drop provider/organization prefixes while preserving the model id."""
+    return raw_model.rstrip("/").split("/")[-1]
+
+
+def infer_model_info(raw_model: str) -> ModelInfo:
+    name = model_name(raw_model)
+    catalog_info = MODEL_CATALOG.get(name.lower())
+    if catalog_info:
+        return catalog_info
+
+    lower = name.lower()
+    if "qwen" in lower:
+        family = "Qwen2.5" if "2.5" in lower else "Qwen"
+    elif "llama" in lower:
+        family = "Llama 3" if re.search(r"llama[-_. ]?3", lower) else "Llama"
+    elif "gemma" in lower:
+        family = "Gemma 3" if re.search(r"gemma[-_. ]?3", lower) else "Gemma"
+    elif raw_model.lower().startswith("openai/") or lower.startswith(("gpt-", "o1", "o3", "o4")):
+        family = "OpenAI"
+    else:
+        family = "Other"
+
+    size_match = re.search(r"(?<![\d.])(\d+(?:\.\d+)?)\s*b(?:\b|[-_])", lower)
+    params_b = float(size_match.group(1)) if size_match else None
+    return ModelInfo(family, params_b)
+
+
+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 discover_logs(log_dirs: list[Path]) -> list[Path]:
+    paths: set[Path] = set()
+    for log_dir in log_dirs:
+        paths.update(path for path in log_dir.rglob("*.eval") if path.stat().st_size >= 1_000)
+    return sorted(paths)
+
+
+def select_logs(paths: list[Path], include_incomplete: bool) -> list[tuple[Path, Any]]:
+    """Deduplicate log snapshots, preferring successful and newer entries."""
+    selected: dict[tuple[str, str], tuple[Path, Any]] = {}
+    for path in paths:
+        try:
+            log = read_eval_log(str(path), header_only=True)
+        except Exception as exc:
+            print(f"Skipping unreadable log {path.name}: {exc}")
+            continue
+        status = str(log.status)
+        if not include_incomplete and status != "success":
+            continue
+        key = (log.eval.eval_id, log.eval.task)
+        previous = selected.get(key)
+        rank = (status == "success", path.stat().st_mtime_ns)
+        if previous is None:
+            selected[key] = (path, log)
+            continue
+        previous_rank = (str(previous[1].status) == "success", previous[0].stat().st_mtime_ns)
+        if rank > previous_rank:
+            selected[key] = (path, log)
+    return sorted(selected.values(), key=lambda item: item[0].name)
+
+
+def load_samples(
+    selected: list[tuple[Path, Any]],
+    scorer: str | None,
+) -> pd.DataFrame:
+    rows: list[dict[str, Any]] = []
+    for index, (path, header) in enumerate(selected, start=1):
+        parsed_task = parse_task(header.eval.task)
+        if parsed_task is None:
+            print(f"Skipping unrecognized task {header.eval.task!r}")
+            continue
+        split, task_language = parsed_task
+        print(f"[{index}/{len(selected)}] {model_name(header.eval.model)} / {task_language} / {split}")
+        log = read_eval_log(str(path))
+        if not log.samples:
+            continue
+        info = infer_model_info(log.eval.model)
+        for sample in log.samples:
+            correct = sample_score(sample, scorer)
+            if correct is None:
+                continue
+            metadata = sample.metadata or {}
+            rows.append(
+                {
+                    "eval_id": log.eval.eval_id,
+                    "created": log.eval.created,
+                    "model_raw": log.eval.model,
+                    "model": model_name(log.eval.model),
+                    "family": info.family,
+                    "params_b": info.params_b,
+                    "vocab_size": info.vocab_size,
+                    "training_language": info.training_language,
+                    "pretrain_tokens_t": info.pretrain_tokens_t,
+                    "language": metadata.get("language", task_language),
+                    "split": split,
+                    "sample_id": sample.id,
+                    "source_id": metadata.get("source_id"),
+                    "epoch": sample.epoch,
+                    "correct": correct,
+                }
+            )
+    if not rows:
+        return pd.DataFrame()
+    samples = pd.DataFrame(rows)
+    problem_keys = [
+        "model_raw",
+        "model",
+        "family",
+        "params_b",
+        "vocab_size",
+        "training_language",
+        "pretrain_tokens_t",
+        "language",
+        "split",
+        "sample_id",
+        "source_id",
+    ]
+    return samples.groupby(problem_keys, dropna=False, as_index=False)["correct"].mean()
+
+
+def summarize(samples: pd.DataFrame) -> pd.DataFrame:
+    group_cols = [
+        "model_raw",
+        "model",
+        "family",
+        "params_b",
+        "vocab_size",
+        "training_language",
+        "pretrain_tokens_t",
+        "language",
+        "split",
+    ]
+    return (
+        samples.groupby(group_cols, dropna=False)["correct"]
+        .agg(accuracy="mean", n_problems="size", stderr="sem")
+        .reset_index()
+    )
+
+
+def model_order(summary: pd.DataFrame) -> list[str]:
+    models = summary[["model", "family", "params_b"]].drop_duplicates().copy()
+    family_order = {"Qwen2.5": 0, "Llama 3": 1, "Gemma 3": 2, "OpenAI": 3, "Other": 4}
+    models["family_order"] = models["family"].map(family_order).fillna(99)
+    models["size_order"] = models["params_b"].fillna(math.inf)
+    return models.sort_values(["family_order", "size_order", "model"])["model"].tolist()
+
+
+def annotated_heatmap(
+    ax: plt.Axes,
+    matrix: pd.DataFrame,
+    title: str,
+    cmap: str,
+    vmin: float,
+    vmax: float,
+    signed: bool = False,
+) -> Any:
+    values = matrix.to_numpy(dtype=float)
+    image = ax.imshow(values, aspect="auto", cmap=cmap, vmin=vmin, vmax=vmax)
+    ax.set_xticks(
+        range(len(matrix.columns)), [LANGUAGE_LABELS.get(x, x) for x in matrix.columns], rotation=40, ha="right"
+    )
+    ax.set_yticks(range(len(matrix.index)), matrix.index)
+    ax.set_title(title)
+    for row in range(values.shape[0]):
+        for col in range(values.shape[1]):
+            value = values[row, col]
+            if np.isnan(value):
+                continue
+            label = f"{value:+.1%}" if signed else f"{value:.1%}"
+            ax.text(col, row, label, ha="center", va="center", fontsize=7)
+    return image
+
+
+def plot_heatmaps(summary: pd.DataFrame, out: Path) -> None:
+    order = model_order(summary)
+    languages = sorted(summary["language"].unique(), key=lambda x: (x != "eng", x))
+    available_splits = [split for split in ("original", "synthetic") if split in set(summary["split"])]
+    matrices: dict[str, pd.DataFrame] = {}
+    for split in available_splits:
+        split_rows = summary[summary["split"] == split]
+        matrices[split] = split_rows.pivot_table(index="model", columns="language", values="accuracy").reindex(
+            index=order, columns=languages
+        )
+    panels: list[tuple[str, pd.DataFrame, str, float, float, bool]] = [
+        (split.title(), matrices[split], "viridis", 0, 1, False) for split in available_splits
+    ]
+    if {"original", "synthetic"}.issubset(matrices):
+        gap = matrices["original"] - matrices["synthetic"]
+        max_gap = np.nanmax(np.abs(gap.to_numpy())) if gap.notna().any().any() else 0.1
+        panels.append(("Original - synthetic", gap, "RdBu_r", -max_gap, max_gap, True))
+
+    height = max(4.0, 0.42 * len(order) + 1.5)
+    fig, axes = plt.subplots(
+        1,
+        len(panels),
+        figsize=(max(6, 2.5 * len(languages) * len(panels)), height),
+        sharey=True,
+        squeeze=False,
+    )
+    axes = axes[0]
+    images = [
+        annotated_heatmap(ax, matrix, title, cmap, vmin, vmax, signed)
+        for ax, (title, matrix, cmap, vmin, vmax, signed) in zip(axes, panels, strict=True)
+    ]
+    axes[0].set_ylabel("Model")
+    fig.suptitle("Accuracy across models, languages, and splits")
+    fig.subplots_adjust(left=0.2, right=0.92, bottom=0.22, top=0.84, wspace=0.18)
+    accuracy_axes = [ax for ax, panel in zip(axes, panels, strict=True) if not panel[-1]]
+    fig.colorbar(images[0], ax=accuracy_axes, shrink=0.8, label="Accuracy")
+    if panels[-1][-1]:
+        fig.colorbar(images[-1], ax=axes[-1], shrink=0.8, label="Accuracy-point gap")
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_split_pairs(summary: pd.DataFrame, out: Path) -> bool:
+    if not {"original", "synthetic"}.issubset(summary["split"].unique()):
+        return False
+    paired = summary.pivot_table(index=["model", "family", "language"], columns="split", values="accuracy").dropna(
+        subset=["original", "synthetic"]
+    )
+    if paired.empty:
+        return False
+    fig, ax = plt.subplots(figsize=(6.5, 6))
+    for (model, family, language), row in paired.iterrows():
+        ax.scatter(
+            row["original"],
+            row["synthetic"],
+            color=FAMILY_COLORS.get(family, FAMILY_COLORS["Other"]),
+            s=50,
+            alpha=0.85,
+        )
+        ax.annotate(
+            f"{model} / {language}",
+            (row["original"], row["synthetic"]),
+            xytext=(4, 3),
+            textcoords="offset points",
+            fontsize=6.5,
+        )
+    ax.plot([0, 1], [0, 1], linestyle="--", color="black", linewidth=1, alpha=0.6)
+    ax.set(xlim=(0, 1), ylim=(0, 1), xlabel="Original accuracy", ylabel="Synthetic accuracy")
+    ax.set_title("Original versus synthetic performance")
+    fig.tight_layout()
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
+def plot_family_scaling(summary: pd.DataFrame, out: Path) -> bool:
+    scaled = summary.dropna(subset=["params_b"])
+    families = [family for family in ("Qwen2.5", "Llama 3", "Gemma 3") if family in set(scaled["family"])]
+    if not families:
+        return False
+    splits = [split for split in ("original", "synthetic") if split in set(scaled["split"])]
+    fig, axes = plt.subplots(
+        len(splits),
+        len(families),
+        figsize=(5 * len(families), 4 * len(splits)),
+        sharey=True,
+        squeeze=False,
+    )
+    markers = ["o", "s", "^", "D", "P", "X", "v", "<", ">"]
+    languages = sorted(scaled["language"].unique(), key=lambda x: (x != "eng", x))
+    legend_handles: list[Any] = []
+    legend_labels: list[str] = []
+    for row_index, split in enumerate(splits):
+        for col_index, family in enumerate(families):
+            ax = axes[row_index, col_index]
+            panel = scaled[(scaled["split"] == split) & (scaled["family"] == family)]
+            for language, marker in zip(languages, markers, strict=False):
+                line = panel[panel["language"] == language].sort_values("params_b")
+                if line.empty:
+                    continue
+                ax.errorbar(
+                    line["params_b"],
+                    line["accuracy"],
+                    yerr=line["stderr"].fillna(0),
+                    marker=marker,
+                    linewidth=1.5,
+                    capsize=2,
+                    label=LANGUAGE_LABELS.get(language, language),
+                )
+            ax.set_xscale("log")
+            ax.set_ylim(0, 1)
+            ax.grid(alpha=0.2)
+            ax.set_title(f"{family}: {split}")
+            ax.set_xlabel("Parameters (billions, log scale)")
+            if col_index == 0:
+                ax.set_ylabel("Accuracy")
+            handles, labels = ax.get_legend_handles_labels()
+            for handle, label in zip(handles, labels, strict=True):
+                if label not in legend_labels:
+                    legend_handles.append(handle)
+                    legend_labels.append(label)
+    if legend_handles:
+        fig.legend(
+            legend_handles,
+            legend_labels,
+            loc="lower center",
+            ncol=min(5, len(legend_labels)),
+            frameon=False,
+        )
+    fig.suptitle("Within-family scaling across languages")
+    fig.tight_layout(rect=(0, 0.06, 1, 0.96))
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--log-dir",
+        type=Path,
+        nargs="+",
+        default=[Path(__file__).parent / "logs"],
+        help="One or more directories searched recursively for .eval logs.",
+    )
+    parser.add_argument("--out-dir", type=Path, default=Path(__file__).parent / "figures" / "model_grid")
+    parser.add_argument(
+        "--scorer", help="Inspect scorer name to use; defaults to math, pattern, then first numeric score."
+    )
+    parser.add_argument(
+        "--include-incomplete", action="store_true", help="Include readable samples from non-success logs."
+    )
+    args = parser.parse_args()
+
+    paths = discover_logs(args.log_dir)
+    selected = select_logs(paths, args.include_incomplete)
+    print(f"Discovered {len(paths)} logs; selected {len(selected)} after status filtering and deduplication.")
+    samples = load_samples(selected, args.scorer)
+    if samples.empty:
+        raise SystemExit("No scored samples found in the selected logs.")
+
+    summary = summarize(samples)
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    summary_path = args.out_dir / "run_summary.csv"
+    summary.sort_values(["family", "params_b", "model", "language", "split"]).to_csv(summary_path, index=False)
+    plot_heatmaps(summary, args.out_dir / "accuracy_heatmaps.png")
+    made_pairs = plot_split_pairs(summary, args.out_dir / "original_vs_synthetic.png")
+    made_scaling = plot_family_scaling(summary, args.out_dir / "family_scaling.png")
+
+    print(f"Saved {summary_path}")
+    print(f"Saved {args.out_dir / 'accuracy_heatmaps.png'}")
+    if not made_pairs:
+        print("Skipped original_vs_synthetic.png: no model/language has both splits.")
+    if made_scaling:
+        print(f"Saved {args.out_dir / 'family_scaling.png'}")
+    else:
+        print("Skipped family_scaling.png: no recognized model parameter counts.")
+
+
+if __name__ == "__main__":
+    main()