add more visualizations

analyze_transfer_features.py

@@ -0,0 +1,551 @@
+# /// script
+# dependencies = [
+#   "lang2vec",
+#   "matplotlib",
+#   "numpy",
+#   "pandas",
+#   "pyarrow",
+#   "setuptools<81",
+#   "transformers",
+# ]
+# ///
+"""Collect language features and relate them to cross-lingual transfer.
+
+The script combines ``visualize_model_grid.py``'s run summary with:
+
+* tokenizer fertility: tokens per non-whitespace Unicode character, normalized
+  to English on matched source problems for each model tokenizer;
+* typological distance: cosine distance from English over concatenated
+  URIEL/lang2vec ``syntax_knn`` and ``inventory_knn`` vectors;
+* resource quantity: current Wikipedia article count, used as a transparent
+  reproducible proxy and plotted on a base-10 log scale.
+
+Outputs include the collected feature tables, the joined transfer-analysis
+table, provenance metadata, and one relationship plot per feature.
+
+Example:
+    uv run hf_dataset/analyze_transfer_features.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import urllib.parse
+import urllib.request
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import lang2vec.lang2vec as l2v
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from transformers import AutoTokenizer
+
+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",
+}
+
+WIKIPEDIA_CODES = {
+    "dan": "da",
+    "deu": "de",
+    "eng": "en",
+    "fra": "fr",
+    "isl": "is",
+    "ita": "it",
+    "nob": "no",
+    "por": "pt",
+    "rus": "ru",
+    "spa": "es",
+    "ukr": "uk",
+    "zho": "zh",
+}
+
+TOKENIZER_REPOS = {
+    "qwen2.5-0.5b-instruct": "Qwen/Qwen2.5-0.5B-Instruct",
+    "qwen2.5-1.5b-instruct": "Qwen/Qwen2.5-1.5B-Instruct",
+    "qwen2.5-3b-instruct": "Qwen/Qwen2.5-3B-Instruct",
+    "qwen2.5-7b-instruct": "Qwen/Qwen2.5-7B-Instruct",
+    "llama-3.2-1b-instruct": "meta-llama/Llama-3.2-1B-Instruct",
+    "llama-3.2-3b-instruct": "meta-llama/Llama-3.2-3B-Instruct",
+    "llama-3.1-8b-instruct": "meta-llama/Llama-3.1-8B-Instruct",
+    "gemma-3-1b-it": "google/gemma-3-1b-it",
+    "gemma-3-4b-it": "google/gemma-3-4b-it",
+    "gemma-3-12b-it": "google/gemma-3-12b-it",
+}
+
+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 wikipedia_statistics(language: str, timeout: float) -> dict[str, Any]:
+    """Fetch current article/page counts from a language's MediaWiki API."""
+    wiki_code = WIKIPEDIA_CODES.get(language)
+    if wiki_code is None:
+        raise ValueError(f"No Wikipedia language code configured for {language!r}")
+
+    query = urllib.parse.urlencode(
+        {
+            "action": "query",
+            "meta": "siteinfo",
+            "siprop": "statistics",
+            "format": "json",
+            "formatversion": 2,
+        }
+    )
+    url = f"https://{wiki_code}.wikipedia.org/w/api.php?{query}"
+    request = urllib.request.Request(
+        url,
+        headers={
+            "User-Agent": (
+                "multilingual-gsm-symbolic/transfer-feature-analysis "
+                "(https://github.com/centre-for-humanities-computing/multilingual-gsm-symbolic)"
+            )
+        },
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        payload = json.load(response)
+
+    statistics = payload["query"]["statistics"]
+    return {
+        "wikipedia_code": wiki_code,
+        "wikipedia_articles": int(statistics["articles"]),
+        "wikipedia_pages": int(statistics["pages"]),
+        "resource_source_url": url,
+    }
+
+
+def cosine_distance(left: np.ndarray, right: np.ndarray) -> float:
+    denominator = np.linalg.norm(left) * np.linalg.norm(right)
+    if denominator == 0:
+        return math.nan
+    distance = float(1 - np.dot(left, right) / denominator)
+    return 0.0 if abs(distance) < 1e-12 else distance
+
+
+def collect_language_features(
+    languages: list[str],
+    timeout: float,
+    resource_cache: pd.DataFrame | None,
+) -> pd.DataFrame:
+    """Collect URIEL distance and Wikipedia resource counts per language."""
+    vectors = l2v.get_features(languages, "syntax_knn+inventory_knn")
+    english = np.asarray(vectors["eng"], dtype=float)
+    cached = {}
+    if resource_cache is not None and not resource_cache.empty:
+        cached = resource_cache.set_index("language").to_dict(orient="index")
+
+    rows: list[dict[str, Any]] = []
+    retrieved_at = datetime.now(UTC).isoformat()
+    for language in languages:
+        try:
+            resource = wikipedia_statistics(language, timeout)
+            resource["resource_retrieved_at_utc"] = retrieved_at
+        except Exception as exc:
+            if language not in cached:
+                raise RuntimeError(
+                    f"Could not fetch Wikipedia statistics for {language} and no cache is available"
+                ) from exc
+            print(f"Using cached Wikipedia statistics for {language}: {exc}")
+            resource = {
+                key: cached[language][key]
+                for key in (
+                    "wikipedia_code",
+                    "wikipedia_articles",
+                    "wikipedia_pages",
+                    "resource_source_url",
+                    "resource_retrieved_at_utc",
+                )
+            }
+
+        articles = int(resource["wikipedia_articles"])
+        rows.append(
+            {
+                "language": language,
+                "language_name": LANGUAGE_LABELS.get(language, language),
+                "typological_distance_from_english": cosine_distance(
+                    np.asarray(vectors[language], dtype=float),
+                    english,
+                ),
+                "typological_feature_set": "URIEL syntax_knn + inventory_knn",
+                **resource,
+                "log10_wikipedia_articles": math.log10(articles) if articles > 0 else math.nan,
+            }
+        )
+
+    return pd.DataFrame(rows)
+
+
+def load_questions(data_dir: Path, languages: list[str]) -> dict[str, pd.DataFrame]:
+    """Load original benchmark questions, indexed by matched source id."""
+    questions: dict[str, pd.DataFrame] = {}
+    for language in languages:
+        paths = sorted((data_dir / language).glob("test_original-*.parquet"))
+        if not paths:
+            raise FileNotFoundError(f"No test_original parquet files found for {language} in {data_dir}")
+        frame = pd.concat(pd.read_parquet(path, columns=["question", "source_id"]) for path in paths)
+        frame = frame.drop_duplicates("source_id").set_index("source_id").sort_index()
+        questions[language] = frame
+    return questions
+
+
+def tokenizer_repo(model: str, model_raw: str) -> str | None:
+    known = TOKENIZER_REPOS.get(model.lower())
+    if known:
+        return known
+
+    raw = model_raw.rstrip("/")
+    for prefix in ("vllm/", "hf/", "transformers/"):
+        if raw.lower().startswith(prefix):
+            return raw[len(prefix) :]
+    if raw.lower().startswith("openai/"):
+        return None
+    return raw if "/" in raw else None
+
+
+def text_fertility(tokenizer: Any, texts: list[str]) -> tuple[float, int, int]:
+    """Return corpus tokens/non-whitespace-character ratio and its totals."""
+    encoded = tokenizer(
+        texts,
+        add_special_tokens=False,
+        truncation=False,
+        return_attention_mask=False,
+        return_token_type_ids=False,
+    )
+    token_count = sum(len(input_ids) for input_ids in encoded["input_ids"])
+    character_count = sum(sum(not character.isspace() for character in text) for text in texts)
+    if character_count == 0:
+        return math.nan, token_count, character_count
+    return token_count / character_count, token_count, character_count
+
+
+def collect_tokenizer_fertility(
+    summary: pd.DataFrame,
+    questions: dict[str, pd.DataFrame],
+    local_files_only: bool,
+) -> pd.DataFrame:
+    """Calculate model-specific fertility on source-matched translated questions."""
+    if "eng" not in questions:
+        raise ValueError("English questions are required as the fertility reference")
+
+    models = summary[["model_raw", "model", "family"]].drop_duplicates()
+    rows: list[dict[str, Any]] = []
+
+    for model_row in models.itertuples(index=False):
+        repo = tokenizer_repo(model_row.model, model_row.model_raw)
+        if repo is None:
+            print(f"Skipping tokenizer fertility for {model_row.model}: no open tokenizer repository")
+            continue
+
+        print(f"Loading tokenizer for {model_row.model} from {repo}")
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(
+                repo,
+                local_files_only=local_files_only,
+                trust_remote_code=False,
+            )
+        except Exception as exc:
+            print(f"Skipping tokenizer fertility for {model_row.model}: {exc}")
+            continue
+
+        for language, language_questions in questions.items():
+            common_ids = questions["eng"].index.intersection(language_questions.index)
+            if common_ids.empty:
+                print(f"Skipping {model_row.model}/{language}: no source ids match English")
+                continue
+
+            english_texts = questions["eng"].loc[common_ids, "question"].astype(str).tolist()
+            language_texts = language_questions.loc[common_ids, "question"].astype(str).tolist()
+            english_fertility, english_tokens, english_characters = text_fertility(
+                tokenizer,
+                english_texts,
+            )
+            fertility, token_count, character_count = text_fertility(tokenizer, language_texts)
+
+            rows.append(
+                {
+                    "model_raw": model_row.model_raw,
+                    "model": model_row.model,
+                    "family": model_row.family,
+                    "tokenizer_repo": repo,
+                    "language": language,
+                    "fertility_tokens_per_character": fertility,
+                    "english_fertility_tokens_per_character": english_fertility,
+                    "normalized_fertility": fertility / english_fertility,
+                    "n_matched_questions": len(common_ids),
+                    "token_count": token_count,
+                    "non_whitespace_character_count": character_count,
+                    "english_token_count": english_tokens,
+                    "english_non_whitespace_character_count": english_characters,
+                }
+            )
+
+    return pd.DataFrame(rows)
+
+
+def build_transfer_table(
+    summary: pd.DataFrame,
+    language_features: pd.DataFrame,
+    fertility: pd.DataFrame,
+) -> pd.DataFrame:
+    """Join English-relative accuracy penalties to collected language features."""
+    index_columns = ["model_raw", "model", "family", "params_b", "language", "split"]
+    values = summary[index_columns + ["accuracy", "stderr", "n_problems"]].copy()
+    english = (
+        values[values["language"] == "eng"]
+        .drop(columns="language")
+        .rename(
+            columns={
+                "accuracy": "english_accuracy",
+                "stderr": "english_stderr",
+                "n_problems": "english_n_problems",
+            }
+        )
+    )
+    transfer = values[values["language"] != "eng"].merge(
+        english,
+        on=["model_raw", "model", "family", "params_b", "split"],
+        how="inner",
+        validate="many_to_one",
+    )
+    transfer["transfer_gap"] = transfer["english_accuracy"] - transfer["accuracy"]
+    transfer["transfer_gap_stderr"] = np.sqrt(
+        transfer["stderr"].fillna(0) ** 2 + transfer["english_stderr"].fillna(0) ** 2
+    )
+
+    transfer = transfer.merge(
+        language_features,
+        on="language",
+        how="left",
+        validate="many_to_one",
+    )
+    if not fertility.empty:
+        transfer = transfer.merge(
+            fertility.drop(columns=["family"]),
+            on=["model_raw", "model", "language"],
+            how="left",
+            validate="many_to_one",
+        )
+    return transfer
+
+
+def relationship_plot(
+    data: pd.DataFrame,
+    x_column: str,
+    xlabel: str,
+    title: str,
+    out: Path,
+) -> bool:
+    """Plot a descriptive feature relationship separately for each split."""
+    plot_data = data.dropna(subset=[x_column, "transfer_gap"])
+    if plot_data.empty:
+        return False
+
+    splits = [split for split in ("original", "synthetic") if split in set(plot_data["split"])]
+    fig, axes = plt.subplots(1, len(splits), figsize=(6.5 * len(splits), 5), squeeze=False)
+    axes = axes[0]
+
+    for ax, split in zip(axes, splits, strict=True):
+        panel = plot_data[plot_data["split"] == split]
+        for family, family_rows in panel.groupby("family"):
+            ax.errorbar(
+                family_rows[x_column],
+                family_rows["transfer_gap"],
+                yerr=family_rows["transfer_gap_stderr"],
+                fmt="o",
+                markersize=6,
+                capsize=2,
+                alpha=0.8,
+                color=FAMILY_COLORS.get(family, FAMILY_COLORS["Other"]),
+                label=family,
+            )
+
+        label_positions = (
+            panel.groupby(["family", "language"], as_index=False)
+            .agg(x=(x_column, "mean"), y=("transfer_gap", "mean"))
+        )
+        for row in label_positions.itertuples(index=False):
+            ax.annotate(
+                row.language,
+                (row.x, row.y),
+                xytext=(4, 3),
+                textcoords="offset points",
+                fontsize=7,
+                color=FAMILY_COLORS.get(row.family, FAMILY_COLORS["Other"]),
+            )
+
+        unique_x = panel[x_column].nunique()
+        if len(panel) >= 3 and unique_x >= 2:
+            slope, intercept = np.polyfit(panel[x_column], panel["transfer_gap"], 1)
+            x_line = np.linspace(panel[x_column].min(), panel[x_column].max(), 100)
+            ax.plot(x_line, slope * x_line + intercept, color="black", linestyle="--", linewidth=1)
+            correlation = panel[[x_column, "transfer_gap"]].corr().iloc[0, 1]
+            ax.text(
+                0.02,
+                0.98,
+                f"Descriptive Pearson r = {correlation:.2f}",
+                transform=ax.transAxes,
+                ha="left",
+                va="top",
+                fontsize=8,
+            )
+
+        ax.axhline(0, color="black", linewidth=0.8, alpha=0.4)
+        ax.grid(alpha=0.2)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel("Transfer gap (English - language accuracy)")
+        ax.set_title(split.title())
+
+    handles, labels = axes[0].get_legend_handles_labels()
+    if handles:
+        fig.legend(handles, labels, loc="lower center", ncol=len(labels), frameon=False)
+    fig.suptitle(title)
+    fig.tight_layout(rect=(0, 0.07, 1, 0.94))
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
+def source_metadata() -> dict[str, Any]:
+    return {
+        "definitions": {
+            "transfer_gap": "English accuracy minus target-language accuracy for the same model and split",
+            "tokenizer_fertility": (
+                "Tokenizer tokens divided by non-whitespace Unicode characters, with no special tokens"
+            ),
+            "normalized_fertility": (
+                "Target-language fertility divided by English fertility on matched source_id questions"
+            ),
+            "typological_distance": (
+                "Cosine distance from English over concatenated URIEL/lang2vec "
+                "syntax_knn and inventory_knn vectors"
+            ),
+            "resource_quantity": "Wikipedia article count; plots use log10(article count)",
+        },
+        "sources": {
+            "tokenizers": "https://huggingface.co/docs/transformers/en/model_doc/auto",
+            "uriel_lang2vec": "https://github.com/antonisa/lang2vec",
+            "uriel_paper": "https://aclanthology.org/E17-2002/",
+            "mediawiki_siteinfo": "https://www.mediawiki.org/wiki/API:Siteinfo",
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    script_dir = Path(__file__).parent
+    default_out = script_dir / "figures" / "transfer_features"
+    parser.add_argument(
+        "--summary",
+        type=Path,
+        default=script_dir / "figures" / "model_grid" / "run_summary.csv",
+    )
+    parser.add_argument("--data-dir", type=Path, default=script_dir / "data")
+    parser.add_argument("--out-dir", type=Path, default=default_out)
+    parser.add_argument(
+        "--local-files-only",
+        action="store_true",
+        help="Do not download tokenizer files; use the Hugging Face cache only.",
+    )
+    parser.add_argument(
+        "--resource-timeout",
+        type=float,
+        default=30,
+        help="Seconds allowed for each Wikipedia statistics request.",
+    )
+    args = parser.parse_args()
+
+    summary = pd.read_csv(args.summary)
+    if "eng" not in set(summary["language"]):
+        raise SystemExit("English results are required to calculate transfer gaps.")
+    languages = sorted(set(summary["language"]))
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    language_features_path = args.out_dir / "language_features.csv"
+    resource_cache = pd.read_csv(language_features_path) if language_features_path.exists() else None
+
+    print(f"Collecting language features for: {', '.join(languages)}")
+    language_features = collect_language_features(
+        languages,
+        timeout=args.resource_timeout,
+        resource_cache=resource_cache,
+    )
+    language_features.to_csv(language_features_path, index=False)
+
+    questions = load_questions(args.data_dir, languages)
+    fertility = collect_tokenizer_fertility(
+        summary,
+        questions,
+        local_files_only=args.local_files_only,
+    )
+    fertility_path = args.out_dir / "tokenizer_fertility.csv"
+    fertility.to_csv(fertility_path, index=False)
+
+    transfer = build_transfer_table(summary, language_features, fertility)
+    transfer_path = args.out_dir / "transfer_feature_data.csv"
+    transfer.to_csv(transfer_path, index=False)
+
+    metadata_path = args.out_dir / "feature_sources.json"
+    metadata_path.write_text(json.dumps(source_metadata(), indent=2) + "\n", encoding="utf-8")
+
+    plots = [
+        (
+            "normalized_fertility",
+            "Tokenizer fertility relative to English",
+            "Transfer gap versus tokenizer fertility",
+            args.out_dir / "tokenizer_fertility_vs_transfer.png",
+        ),
+        (
+            "typological_distance_from_english",
+            "URIEL typological distance from English",
+            "Transfer gap versus typological distance",
+            args.out_dir / "typological_distance_vs_transfer.png",
+        ),
+        (
+            "log10_wikipedia_articles",
+            "Language resources: log10 Wikipedia articles",
+            "Resource quantity versus transfer",
+            args.out_dir / "resource_quantity_vs_transfer.png",
+        ),
+    ]
+    for column, xlabel, title, path in plots:
+        if relationship_plot(transfer, column, xlabel, title, path):
+            print(f"Saved {path}")
+        else:
+            print(f"Skipped {path.name}: no paired transfer observations with this feature.")
+
+    print(f"Saved {language_features_path}")
+    print(f"Saved {fertility_path}")
+    print(f"Saved {transfer_path}")
+    print(f"Saved {metadata_path}")
+
+
+if __name__ == "__main__":
+    main()

visualize_model_grid.py

@@ -9,6 +9,9 @@ The script reads Inspect ``.eval`` logs and writes:
 * ``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.
+* ``english_normalized_transfer.png``: language accuracy relative to English.
+* ``transfer_robustness.png``: transfer penalty and cross-language dispersion by size.
+* ``split_degradation_heatmaps.png``: absolute and relative original-to-synthetic drop.
 
 Only successful logs are included by default. Repeated/resumed logs with the same
 evaluation id are deduplicated, preferring a successful and then newer log.
@@ -21,7 +24,6 @@ from __future__ import annotations
 
 import argparse
 import math
-import os
 import re
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
@@ -413,6 +415,16 @@ def annotated_heatmap(
     values = matrix.to_numpy(dtype=float)
     image = ax.imshow(values, aspect="auto", cmap=cmap, vmin=vmin, vmax=vmax)
 
+    families = [infer_model_info(model).family for model in matrix.index]
+    for row in range(1, len(families)):
+        if families[row] != families[row - 1]:
+            ax.axhline(
+                row - 0.5,
+                color="white",
+                linewidth=1.5,
+                alpha=0.9,
+            )
+
     ax.set_xticks(
         range(len(matrix.columns)),
         [heatmap_language_label(x) for x in matrix.columns],
@@ -551,6 +563,221 @@ def plot_split_pairs(summary: pd.DataFrame, out: Path) -> bool:
     return True
 
 
+def plot_english_normalized_transfer(summary: pd.DataFrame, out: Path) -> bool:
+    """Plot each language's accuracy difference from the same model's English score."""
+    order = model_order(summary)
+    splits = [split for split in ("original", "synthetic") if split in set(summary["split"])]
+    languages = sorted(
+        (language for language in summary["language"].unique() if language != "eng"),
+        key=lambda language: (-LANGUAGE_SPEAKERS.get(language, -1), language),
+    )
+
+    panels: list[tuple[str, pd.DataFrame]] = []
+    for split in splits:
+        matrix = (
+            summary[summary["split"] == split]
+            .pivot_table(index="model", columns="language", values="accuracy")
+            .reindex(index=order)
+        )
+        if "eng" not in matrix or not languages:
+            continue
+        transfer = matrix.reindex(columns=languages).sub(matrix["eng"], axis=0)
+        if transfer.notna().any().any():
+            panels.append((split.title(), transfer))
+
+    if not panels:
+        return False
+
+    max_gap = max(
+        np.nanmax(np.abs(matrix.to_numpy()))
+        for _title, matrix in panels
+        if matrix.notna().any().any()
+    )
+    max_gap = max(max_gap, 0.05)
+    height = max(4.0, 0.42 * len(order) + 1.5)
+    fig, axes = plt.subplots(
+        1,
+        len(panels),
+        figsize=(max(7, 2.8 * len(languages) * len(panels)), height),
+        sharey=True,
+        squeeze=False,
+    )
+    axes = axes[0]
+
+    images = [
+        annotated_heatmap(
+            ax,
+            matrix,
+            title,
+            "RdBu",
+            -max_gap,
+            max_gap,
+            signed=True,
+        )
+        for ax, (title, matrix) in zip(axes, panels, strict=True)
+    ]
+
+    axes[0].set_ylabel("Model")
+    fig.suptitle("Cross-lingual transfer relative to English")
+    fig.subplots_adjust(left=0.2, right=0.89, bottom=0.27, top=0.84, wspace=0.18)
+    colorbar_axis = fig.add_axes([0.91, 0.25, 0.012, 0.55])
+    fig.colorbar(
+        images[0],
+        cax=colorbar_axis,
+        label="Accuracy difference (language - English)",
+    )
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
+def transfer_robustness_summary(summary: pd.DataFrame) -> pd.DataFrame:
+    """Summarize the English transfer penalty across non-English languages."""
+    indexed = summary.pivot_table(
+        index=["model", "family", "params_b", "split"],
+        columns="language",
+        values="accuracy",
+    )
+    non_english = [column for column in indexed.columns if column != "eng"]
+    if "eng" not in indexed or not non_english:
+        return pd.DataFrame()
+
+    penalties = indexed[non_english].rsub(indexed["eng"], axis=0)
+    result = indexed.reset_index()[["model", "family", "params_b", "split"]].copy()
+    result["mean_transfer_penalty"] = penalties.mean(axis=1, skipna=True).to_numpy()
+    result["language_dispersion"] = indexed[non_english].std(axis=1, ddof=0, skipna=True).to_numpy()
+    result["n_transfer_languages"] = penalties.notna().sum(axis=1).to_numpy()
+    return result[result["n_transfer_languages"] > 0]
+
+
+def plot_transfer_robustness(summary: pd.DataFrame, out: Path) -> bool:
+    robust = transfer_robustness_summary(summary).dropna(subset=["params_b"])
+    if robust.empty:
+        return False
+
+    splits = [split for split in ("original", "synthetic") if split in set(robust["split"])]
+    metrics = [
+        ("mean_transfer_penalty", "Mean transfer penalty\n(English - non-English)"),
+        ("language_dispersion", "Cross-language accuracy SD"),
+    ]
+    fig, axes = plt.subplots(
+        len(splits),
+        len(metrics),
+        figsize=(11, 4 * len(splits)),
+        squeeze=False,
+    )
+
+    for row_index, split in enumerate(splits):
+        split_rows = robust[robust["split"] == split]
+        for col_index, (metric, label) in enumerate(metrics):
+            ax = axes[row_index, col_index]
+            for family, family_rows in split_rows.groupby("family"):
+                family_rows = family_rows.sort_values("params_b")
+                ax.plot(
+                    family_rows["params_b"],
+                    family_rows[metric],
+                    marker="o",
+                    linewidth=1.7,
+                    color=FAMILY_COLORS.get(family, FAMILY_COLORS["Other"]),
+                    label=family,
+                )
+                for row in family_rows.itertuples():
+                    ax.annotate(
+                        row.model,
+                        (row.params_b, getattr(row, metric)),
+                        xytext=(4, 4),
+                        textcoords="offset points",
+                        fontsize=6.5,
+                    )
+
+            ax.axhline(0, color="black", linewidth=0.8, alpha=0.4)
+            ax.set_xscale("log")
+            ax.grid(alpha=0.2)
+            ax.set_xlabel("Parameters (billions, log scale)")
+            ax.set_ylabel(label)
+            ax.set_title(split.title())
+
+    handles, labels = axes[0, 0].get_legend_handles_labels()
+    if handles:
+        fig.legend(handles, labels, loc="lower center", ncol=len(labels), frameon=False)
+    fig.suptitle("Cross-lingual transfer robustness with model scale")
+    fig.tight_layout(rect=(0, 0.05, 1, 0.96))
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return True
+
+
+def plot_split_degradation(summary: pd.DataFrame, out: Path) -> bool:
+    if not {"original", "synthetic"}.issubset(summary["split"].unique()):
+        return False
+
+    order = model_order(summary)
+    languages = sorted(
+        summary["language"].unique(),
+        key=lambda language: (-LANGUAGE_SPEAKERS.get(language, -1), language),
+    )
+    paired = summary.pivot_table(
+        index="model",
+        columns=["split", "language"],
+        values="accuracy",
+    )
+    original = paired["original"].reindex(index=order, columns=languages)
+    synthetic = paired["synthetic"].reindex(index=order, columns=languages)
+    absolute = original - synthetic
+    relative = absolute.div(original.where(original != 0))
+
+    if not absolute.notna().any().any():
+        return False
+
+    absolute_limit = max(float(np.nanmax(np.abs(absolute.to_numpy()))), 0.05)
+    finite_relative = relative.to_numpy()[np.isfinite(relative.to_numpy())]
+    relative_limit = max(float(np.max(np.abs(finite_relative))) if finite_relative.size else 0, 0.05)
+
+    height = max(4.0, 0.42 * len(order) + 1.5)
+    fig, axes = plt.subplots(
+        1,
+        2,
+        figsize=(max(12, 5 * len(languages)), height),
+        sharey=True,
+    )
+    absolute_image = annotated_heatmap(
+        axes[0],
+        absolute,
+        "Absolute degradation",
+        "RdBu_r",
+        -absolute_limit,
+        absolute_limit,
+        signed=True,
+    )
+    relative_image = annotated_heatmap(
+        axes[1],
+        relative,
+        "Relative degradation",
+        "RdBu_r",
+        -relative_limit,
+        relative_limit,
+        signed=True,
+    )
+    axes[0].set_ylabel("Model")
+    fig.suptitle("Performance degradation from original to synthetic")
+    fig.colorbar(
+        absolute_image,
+        ax=axes[0],
+        shrink=0.8,
+        label="Original - synthetic accuracy",
+    )
+    fig.colorbar(
+        relative_image,
+        ax=axes[1],
+        shrink=0.8,
+        label="(Original - synthetic) / original",
+    )
+    fig.subplots_adjust(left=0.2, right=0.92, bottom=0.27, top=0.84, wspace=0.18)
+    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"])]
@@ -685,6 +912,18 @@ def main() -> None:
     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")
+    made_transfer = plot_english_normalized_transfer(
+        summary,
+        args.out_dir / "english_normalized_transfer.png",
+    )
+    made_robustness = plot_transfer_robustness(
+        summary,
+        args.out_dir / "transfer_robustness.png",
+    )
+    made_degradation = plot_split_degradation(
+        summary,
+        args.out_dir / "split_degradation_heatmaps.png",
+    )
 
     print(f"Saved {summary_path}")
     print(f"Saved {args.out_dir / 'accuracy_heatmaps.png'}")
@@ -699,6 +938,21 @@ def main() -> None:
     else:
         print("Skipped family_scaling.png: no recognized model parameter counts.")
 
+    if made_transfer:
+        print(f"Saved {args.out_dir / 'english_normalized_transfer.png'}")
+    else:
+        print("Skipped english_normalized_transfer.png: paired English/non-English results are required.")
+
+    if made_robustness:
+        print(f"Saved {args.out_dir / 'transfer_robustness.png'}")
+    else:
+        print("Skipped transfer_robustness.png: paired transfer results with model sizes are required.")
+
+    if made_degradation:
+        print(f"Saved {args.out_dir / 'split_degradation_heatmaps.png'}")
+    else:
+        print("Skipped split_degradation_heatmaps.png: paired original/synthetic results are required.")
+
 
 if __name__ == "__main__":
-    main()
+    main()