Update vizualize grid

visualize_model_grid.py

@@ -14,14 +14,16 @@ Only successful logs are included by default. Repeated/resumed logs with the sam
 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
+    uv run hf_dataset/visualize_model_grid.py --log-dir hf_dataset/logs --workers 8
 """
 
 from __future__ import annotations
 
 import argparse
 import math
+import os
 import re
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -41,7 +43,6 @@ class ModelInfo:
     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),
@@ -69,6 +70,16 @@ LANGUAGE_LABELS = {
     "ukr": "Ukrainian",
 }
 
+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"}
+
 FAMILY_COLORS = {
     "Qwen2.5": "#7B2CBF",
     "Llama 3": "#E76F51",
@@ -143,13 +154,16 @@ 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
 
 
@@ -160,73 +174,169 @@ def discover_logs(log_dirs: list[Path]) -> list[Path]:
     return sorted(paths)
 
 
-def select_logs(paths: list[Path], include_incomplete: bool) -> list[tuple[Path, Any]]:
+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 select_logs(paths: list[Path], include_incomplete: bool, workers: int) -> 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}")
+
+    if not paths:
+        return []
+
+    if workers <= 1:
+        results = [_read_log_header(path) for path in paths]
+    else:
+        max_workers = min(workers, len(paths))
+        with ThreadPoolExecutor(max_workers=max_workers) as pool:
+            futures = [pool.submit(_read_log_header, path) for path in paths]
+            results = [future.result() for future in as_completed(futures)]
+
+    for path, log, error in results:
+        if error:
+            print(f"Skipping unreadable log {path.name}: {error}")
             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)
+
+        previous = selected.get(key)
         if previous is None:
             selected[key] = (path, log)
             continue
-        previous_rank = (str(previous[1].status) == "success", previous[0].stat().st_mtime_ns)
+
+        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_one_log(path: Path, scorer: str | None) -> tuple[str, pd.DataFrame | None, str | None]:
+    """Load and score one full Inspect log.
+
+    Returns a partially aggregated dataframe to reduce data copied back from
+    worker processes.
+    """
+    try:
+        log = read_eval_log(str(path))
+    except Exception as exc:
+        return path.name, None, f"Skipping unreadable log {path.name}: {exc}"
+
+    parsed_task = parse_task(log.eval.task)
+    if parsed_task is None:
+        return path.name, None, f"Skipping unrecognized task {log.eval.task!r}"
+
+    split, task_language = parsed_task
+    label = f"{model_name(log.eval.model)} / {task_language} / {split}"
+
+    if not log.samples:
+        return label, pd.DataFrame(), None
+
+    info = infer_model_info(log.eval.model)
+    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_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"),
+                "correct": correct,
+            }
+        )
+
+    if not rows:
+        return label, pd.DataFrame(), None
+
+    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",
+    ]
+
+    grouped = (
+        samples.groupby(problem_keys, dropna=False, as_index=False)["correct"]
+        .agg(correct_sum="sum", correct_count="size")
+    )
+
+    return label, grouped, None
+
+
 def load_samples(
     selected: list[tuple[Path, Any]],
     scorer: str | None,
+    workers: int,
 ) -> 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:
+    """Load selected logs, optionally in parallel."""
+    frames: list[pd.DataFrame] = []
+    paths = [path for path, _header in selected]
+
+    if not paths:
         return pd.DataFrame()
-    samples = pd.DataFrame(rows)
+
+    if workers <= 1:
+        for index, path in enumerate(paths, start=1):
+            label, frame, warning = _load_one_log(path, scorer)
+            if warning:
+                print(warning)
+            else:
+                print(f"[{index}/{len(paths)}] {label}")
+            if frame is not None and not frame.empty:
+                frames.append(frame)
+    else:
+        max_workers = min(workers, len(paths))
+        with ProcessPoolExecutor(max_workers=max_workers) 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)
+
     problem_keys = [
         "model_raw",
         "model",
@@ -240,7 +350,14 @@ def load_samples(
         "sample_id",
         "source_id",
     ]
-    return samples.groupby(problem_keys, dropna=False, as_index=False)["correct"].mean()
+
+    samples = (
+        combined.groupby(problem_keys, dropna=False, as_index=False)
+        .agg(correct_sum=("correct_sum", "sum"), correct_count=("correct_count", "sum"))
+    )
+    samples["correct"] = samples["correct_sum"] / samples["correct_count"]
+
+    return samples.drop(columns=["correct_sum", "correct_count"])
 
 
 def summarize(samples: pd.DataFrame) -> pd.DataFrame:
@@ -270,6 +387,20 @@ def model_order(summary: pd.DataFrame) -> list[str]:
     return models.sort_values(["family_order", "size_order", "model"])["model"].tolist()
 
 
+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 annotated_heatmap(
     ax: plt.Axes,
     matrix: pd.DataFrame,
@@ -281,11 +412,34 @@ def annotated_heatmap(
 ) -> 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"
+        range(len(matrix.columns)),
+        [heatmap_language_label(x) for x in matrix.columns],
+        rotation=40,
+        ha="right",
     )
+
+    for col, language in enumerate(matrix.columns):
+        if language not in HUMAN_VERIFIED_LANGUAGES:
+            continue
+        ax.annotate(
+            "*",
+            xy=(col, 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(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]
@@ -293,22 +447,32 @@ def annotated_heatmap(
                 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))
+    languages = sorted(
+        summary["language"].unique(),
+        key=lambda language: (-LANGUAGE_SPEAKERS.get(language, -1), language),
+    )
+
     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
-        )
+        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
@@ -323,17 +487,24 @@ def plot_heatmaps(summary: pd.DataFrame, out: Path) -> None:
         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)
+    fig.text(0.465, 0.02, "*", color="#FFC107", fontweight="bold", ha="right", fontsize=8)
+    fig.text(0.467, 0.02, "Human verified", ha="left", fontsize=8)
+    fig.subplots_adjust(left=0.2, right=0.92, bottom=0.28, 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)
 
@@ -341,12 +512,18 @@ def plot_heatmaps(summary: pd.DataFrame, out: Path) -> None:
 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"]
-    )
+
+    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"],
@@ -362,21 +539,27 @@ def plot_split_pairs(summary: pd.DataFrame, out: Path) -> bool:
             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),
@@ -384,18 +567,22 @@ def plot_family_scaling(summary: pd.DataFrame, out: Path) -> bool:
         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"],
@@ -405,18 +592,22 @@ def plot_family_scaling(summary: pd.DataFrame, out: Path) -> bool:
                     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,
@@ -425,15 +616,18 @@ def plot_family_scaling(summary: pd.DataFrame, out: Path) -> bool:
             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,
@@ -441,34 +635,65 @@ def main() -> None:
         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."
+        "--out-dir",
+        type=Path,
+        default=Path(__file__).parent / "figures" / "model_grid",
     )
     parser.add_argument(
-        "--include-incomplete", action="store_true", help="Include readable samples from non-success logs."
+        "--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.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=32,
+        help="Processes used for full log loading. Use 1 to disable multiprocessing.",
+    )
+    parser.add_argument(
+        "--header-workers",
+        type=int,
+        default=32,
+        help="Threads used for the header-only deduplication pass.",
+    )
+
     args = parser.parse_args()
 
     paths = discover_logs(args.log_dir)
-    selected = select_logs(paths, args.include_incomplete)
+    selected = select_logs(paths, args.include_incomplete, workers=args.header_workers)
+
     print(f"Discovered {len(paths)} logs; selected {len(selected)} after status filtering and deduplication.")
-    samples = load_samples(selected, args.scorer)
+    print(f"Loading selected logs with {args.workers} worker(s).")
+
+    samples = load_samples(selected, args.scorer, workers=args.workers)
+
     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:
+
+    if made_pairs:
+        print(f"Saved {args.out_dir / 'original_vs_synthetic.png'}")
+    else:
         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:
@@ -476,4 +701,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()