Remove Phase 2 source code (code lives on GitHub; HF holds artifacts only)

phase2_scaling/extract_activations.py

@@ -1,314 +0,0 @@
-"""Extract activations from Llama models via NDIF for Phase 2.
-
-Handles both pilot timing runs and full six-relation extraction.
-Uses the blackboxnlp-ndif conda environment.
-
-Usage:
-    # Pilot: one relation, N50, both models, record timing
-    python extract_activations.py --pilot
-
-    # Full extraction after N_final is frozen
-    python extract_activations.py --subset N50   # or N75, N100
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import math
-import os
-import time
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-import pandas as pd
-
-ROOT = Path(__file__).resolve().parent
-ENV_PATH = ROOT / ".env"
-DATA_PATH = ROOT / "data" / "processed" / "examples.parquet"
-ACTIVATIONS_DIR = ROOT / "activations"
-PILOT_DIR = ROOT / "activations" / "pilot"
-
-MODELS = {
-    "llama_3_1_8b": "meta-llama/Llama-3.1-8B",
-    "llama_3_1_70b": "meta-llama/Llama-3.1-70B",
-}
-
-DEPTHS = [0.25, 0.50, 0.75, 1.00]
-
-PILOT_RELATION = "P19"
-
-def load_env() -> str:
-    if not ENV_PATH.exists():
-        raise FileNotFoundError(f"Missing .env: {ENV_PATH}")
-    for line in ENV_PATH.read_text(encoding="utf-8").splitlines():
-        line = line.strip()
-        if not line or line.startswith("#"):
-            continue
-        if "=" in line:
-            k, v = line.split("=", 1)
-            os.environ.setdefault(k.strip(), v.strip())
-    api_key = os.environ.get("NDIF_API_KEY", "").strip()
-    if not api_key or api_key.startswith("PASTE_YOUR_"):
-        raise RuntimeError("Set NDIF_API_KEY in .env")
-    hf_token = os.environ.get("HF_TOKEN", "").strip()
-    if not hf_token or hf_token.startswith("PASTE_YOUR_"):
-        raise RuntimeError("Set HF_TOKEN in .env")
-    return api_key
-
-
-def get_layer_indices(num_layers: int) -> list[tuple[float, int]]:
-    return [(d, math.ceil(d * num_layers) - 1) for d in DEPTHS]
-
-
-def load_sentences(subset: str, relation: str | None = None) -> pd.DataFrame:
-    df = pd.read_parquet(DATA_PATH)
-    df = df[df["subset"] == subset]
-    if relation:
-        df = df[df["relation_id"] == relation]
-    return df.sort_values("example_id").reset_index(drop=True)
-
-
-def extract_for_model(
-    model_key: str,
-    model_id: str,
-    sentences: list[str],
-    api_key: str,
-) -> dict[str, Any]:
-    """Run extraction for one model, one sentence at a time.
-
-    Passes each sentence as a raw string to match the NNsight/NDIF
-    remote trace pattern validated in the smoke test.
-    """
-    from nnsight import CONFIG, LanguageModel
-
-    CONFIG.set_default_api_key(api_key)
-
-    print(f"\n{'='*50}")
-    print(f"Model: {model_id}")
-    print(f"Sentences: {len(sentences)}")
-    print(f"{'='*50}")
-
-    t_init_start = time.time()
-    model = LanguageModel(model_id)
-    num_layers = model.config.num_hidden_layers
-    hidden_dim = model.config.hidden_size
-    t_init = time.time() - t_init_start
-    print(f"Model init: {t_init:.1f}s  (layers={num_layers}, hidden={hidden_dim})")
-
-    layers = get_layer_indices(num_layers)
-    print(f"Target layers: {[(d, i) for d, i in layers]}")
-
-    tokenizer = model.tokenizer
-
-    assert len(layers) == 4, f"Expected 4 depths, got {len(layers)}"
-    li0, li1, li2, li3 = [idx for _, idx in layers]
-
-    all_activations: dict[int, list[np.ndarray]] = {
-        li0: [], li1: [], li2: [], li3: [],
-    }
-    all_positions: list[int] = []
-
-    t_remote_total = 0.0
-    t_wall_start = time.time()
-
-    for i, sent in enumerate(sentences):
-        tok_len = len(tokenizer(sent)["input_ids"])
-        last_pos = tok_len - 1
-        all_positions.append(last_pos)
-
-        t_sub = time.time()
-
-        # NNsight 0.7 does not trace Python for-loops inside the
-        # context manager — .save() calls inside a loop are silently
-        # dropped.  Unroll the four depths explicitly.
-        with model.trace(sent, remote=True):
-            s0 = model.model.layers[li0].output[0].save()
-            s1 = model.model.layers[li1].output[0].save()
-            s2 = model.model.layers[li2].output[0].save()
-            s3 = model.model.layers[li3].output[0].save()
-
-        t_remote_total += time.time() - t_sub
-
-        for li, tensor in [(li0, s0), (li1, s1), (li2, s2), (li3, s3)]:
-            t = tensor[0] if tensor.dim() == 3 else tensor
-            vec = t[last_pos, :].detach().cpu().float().numpy()
-            all_activations[li].append(vec)
-
-        if (i + 1) % 10 == 0 or i == 0:
-            elapsed = time.time() - t_wall_start
-            print(f"  {i+1}/{len(sentences)}  "
-                  f"({elapsed:.0f}s elapsed, "
-                  f"~{elapsed/(i+1):.2f}s/sent)")
-
-    t_wall_total = time.time() - t_wall_start
-
-    activation_arrays = {}
-    for layer_idx, vecs in all_activations.items():
-        arr = np.stack(vecs).astype(np.float16)
-        activation_arrays[layer_idx] = arr
-        print(f"  Layer {layer_idx}: shape={arr.shape}, dtype={arr.dtype}")
-
-    timing = {
-        "model_id": model_id,
-        "model_key": model_key,
-        "num_layers": num_layers,
-        "hidden_dim": hidden_dim,
-        "sentences_processed": len(sentences),
-        "model_init_seconds": round(t_init, 2),
-        "remote_execution_seconds": round(t_remote_total, 2),
-        "total_wall_clock_seconds": round(t_wall_total, 2),
-        "seconds_per_sentence": round(t_wall_total / len(sentences), 3),
-    }
-
-    return {
-        "activations": activation_arrays,
-        "positions": all_positions,
-        "layers": layers,
-        "timing": timing,
-    }
-
-
-def save_activations(
-    result: dict[str, Any],
-    output_dir: Path,
-    model_key: str,
-    df: pd.DataFrame,
-    dataset_hash: str,
-) -> None:
-    model_dir = output_dir / model_key
-    model_dir.mkdir(parents=True, exist_ok=True)
-
-    for layer_idx, arr in result["activations"].items():
-        np.save(model_dir / f"layer_{layer_idx}.npy", arr)
-
-    sample_index = df[["example_id", "pair_id", "case_id", "relation_id",
-                        "subject", "label", "subset"]].copy()
-    sample_index["token_position"] = result["positions"]
-    sample_index.to_parquet(model_dir / "sample_index.parquet", index=False)
-
-    manifest = {
-        **result["timing"],
-        "target_layers": [
-            {"depth": d, "layer_index": i} for d, i in result["layers"]
-        ],
-        "activation_shapes": {
-            str(idx): list(arr.shape)
-            for idx, arr in result["activations"].items()
-        },
-        "activation_dtype": "float16",
-        "dataset_hash": dataset_hash,
-        "token_position_strategy": "last_real_token (= final subtoken of target attribute)",
-    }
-    (model_dir / "manifest.json").write_text(
-        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
-    )
-
-
-def run_pilot(api_key: str) -> None:
-    print("=" * 60)
-    print(f"PILOT TIMING: relation={PILOT_RELATION}, subset=N50")
-    print("=" * 60)
-
-    df = load_sentences("N50", PILOT_RELATION)
-    sentences = df["sentence"].tolist()
-    print(f"Loaded {len(sentences)} pilot sentences")
-
-    dataset_hash = hashlib.sha256(
-        "\n".join(sentences).encode()
-    ).hexdigest()[:16]
-
-    all_timing = {}
-
-    for model_key, model_id in MODELS.items():
-        result = extract_for_model(model_key, model_id, sentences, api_key)
-        all_timing[model_key] = result["timing"]
-
-        save_activations(result, PILOT_DIR, model_key, df, dataset_hash)
-        print(f"\nSaved pilot activations to {PILOT_DIR / model_key}")
-
-    print("\n" + "=" * 60)
-    print("PILOT TIMING SUMMARY")
-    print("=" * 60)
-
-    for mk, t in all_timing.items():
-        print(f"\n  {mk}:")
-        print(f"    Wall clock:     {t['total_wall_clock_seconds']:.1f}s")
-        print(f"    Remote exec:    {t['remote_execution_seconds']:.1f}s")
-        print(f"    Per sentence:   {t['seconds_per_sentence']:.3f}s")
-        print(f"    Sentences:      {t['sentences_processed']}")
-
-    total_8b = all_timing["llama_3_1_8b"]["total_wall_clock_seconds"]
-    total_70b = all_timing["llama_3_1_70b"]["total_wall_clock_seconds"]
-
-    print("\n  Estimated full extraction times:")
-    for label, n_pairs in [("N50", 50), ("N75", 75), ("N100", 100)]:
-        multiplier = (6 * n_pairs * 2) / 100
-        est_8b = total_8b * multiplier
-        est_70b = total_70b * multiplier
-        est_total = est_8b + est_70b
-        print(f"    {label}: 8B={est_8b/60:.0f}min + 70B={est_70b/60:.0f}min "
-              f"= {est_total/60:.0f}min total")
-
-    decision_path = ROOT / "sample_size_decision.json"
-    decision = {
-        "pilot_relation": PILOT_RELATION,
-        "pilot_subset": "N50",
-        "pilot_sentences": len(sentences),
-        "pilot_timing": all_timing,
-        "estimated_full_extraction": {},
-    }
-    for label, n_pairs in [("N50", 50), ("N75", 75), ("N100", 100)]:
-        mult = (6 * n_pairs * 2) / 100
-        decision["estimated_full_extraction"][label] = {
-            "sentences": 6 * n_pairs * 2,
-            "multiplier": mult,
-            "estimated_8b_seconds": round(total_8b * mult, 1),
-            "estimated_70b_seconds": round(total_70b * mult, 1),
-            "estimated_total_seconds": round((total_8b + total_70b) * mult, 1),
-        }
-    decision_path.write_text(json.dumps(decision, indent=2) + "\n", encoding="utf-8")
-    print(f"\nSaved timing decision to {decision_path}")
-
-
-def run_full(api_key: str, subset: str) -> None:
-    print("=" * 60)
-    print(f"FULL EXTRACTION: subset={subset}, all relations")
-    print("=" * 60)
-
-    df = load_sentences(subset)
-    sentences = df["sentence"].tolist()
-    print(f"Loaded {len(sentences)} sentences across {df['relation_id'].nunique()} relations")
-
-    dataset_hash = hashlib.sha256(
-        "\n".join(sentences).encode()
-    ).hexdigest()[:16]
-
-    for model_key, model_id in MODELS.items():
-        result = extract_for_model(model_key, model_id, sentences, api_key)
-        out_dir = ACTIVATIONS_DIR / model_key
-        save_activations(result, ACTIVATIONS_DIR, model_key, df, dataset_hash)
-        print(f"\nSaved activations to {out_dir}")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--pilot", action="store_true",
-                       help="Run pilot timing with one relation")
-    group.add_argument("--subset", choices=["N50", "N75", "N100"],
-                       help="Run full extraction for this subset")
-    args = parser.parse_args()
-
-    api_key = load_env()
-
-    if args.pilot:
-        run_pilot(api_key)
-    else:
-        run_full(api_key, args.subset)
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/generate_figures.py

@@ -1,389 +0,0 @@
-"""Generate Phase 2 publication figures.
-
-Run from workspace/reproduction/scaling/ under the blackboxnlp conda env:
-    python generate_figures.py
-"""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import matplotlib.ticker as mticker
-import numpy as np
-import pandas as pd
-from matplotlib.colors import LinearSegmentedColormap
-
-ROOT = Path(__file__).resolve().parent
-RESULTS_DIR = ROOT / "results"
-FIGURES_DIR = ROOT / "figures"
-FIGURES_DIR.mkdir(exist_ok=True)
-
-RELATION_ORDER = ["P19", "P103", "P101", "P159", "P176", "P138"]
-RELATION_LABELS = {
-    "P19": "P19\nplace of birth",
-    "P103": "P103\nnative language",
-    "P101": "P101\nfield of work",
-    "P159": "P159\nHQ location",
-    "P176": "P176\nmanufacturer",
-    "P138": "P138\nnamed after",
-}
-RELATION_SHORT = {
-    "P19": "P19",
-    "P103": "P103",
-    "P101": "P101",
-    "P159": "P159",
-    "P176": "P176",
-    "P138": "P138",
-}
-
-C_8B = "#2a78d6"
-C_70B = "#1baf7a"
-C_8B_LIGHT = "#86b6ef"
-C_70B_LIGHT = "#7dd4b0"
-
-DEPTHS = [0.25, 0.5, 0.75, 1.0]
-DEPTH_LABELS = ["25%", "50%", "75%", "100%"]
-
-
-def setup_style():
-    plt.rcParams.update({
-        "font.family": "sans-serif",
-        "font.sans-serif": ["Segoe UI", "Arial", "Helvetica", "sans-serif"],
-        "font.size": 9,
-        "axes.titlesize": 10,
-        "axes.labelsize": 9,
-        "xtick.labelsize": 8,
-        "ytick.labelsize": 8,
-        "legend.fontsize": 8,
-        "figure.dpi": 300,
-        "savefig.dpi": 300,
-        "savefig.bbox": "tight",
-        "savefig.pad_inches": 0.05,
-        "axes.spines.top": False,
-        "axes.spines.right": False,
-        "axes.linewidth": 0.6,
-        "xtick.major.width": 0.6,
-        "ytick.major.width": 0.6,
-        "axes.grid": True,
-        "grid.alpha": 0.3,
-        "grid.linewidth": 0.5,
-        "lines.linewidth": 1.8,
-        "lines.markersize": 6,
-    })
-
-
-def load_data():
-    gap = pd.read_csv(RESULTS_DIR / "generality_gap.csv")
-    with open(RESULTS_DIR / "selected_layers.json") as f:
-        selected = json.load(f)
-    matrix_8b = pd.read_csv(RESULTS_DIR / "stage2_matrix_8b.csv", index_col=0)
-    matrix_70b = pd.read_csv(RESULTS_DIR / "stage2_matrix_70b.csv", index_col=0)
-    return gap, selected, matrix_8b, matrix_70b
-
-
-def fig1_depth_profile(gap: pd.DataFrame, selected: dict):
-    """Within-relation and LOO AUC across depths for both models."""
-    fig, ax = plt.subplots(figsize=(4.5, 3.2))
-
-    for model_key, color, label in [
-        ("llama_3_1_8b", C_8B, "8B"),
-        ("llama_3_1_70b", C_70B, "70B"),
-    ]:
-        m = gap[gap["model_key"] == model_key]
-
-        within_means = []
-        within_stds = []
-        loo_means = []
-        loo_stds = []
-        for d in DEPTHS:
-            depth_data = m[m["normalized_depth"] == d]
-            within_means.append(depth_data["within_mean_auc"].mean())
-            within_stds.append(depth_data["within_mean_auc"].std())
-            loo_means.append(depth_data["loo_auc"].mean())
-            loo_stds.append(depth_data["loo_auc"].std())
-
-        x = np.arange(len(DEPTHS))
-
-        ax.errorbar(x, within_means, yerr=within_stds, color=color,
-                     marker="o", linestyle="-", label=f"{label} within",
-                     capsize=3, capthick=1.2, markeredgecolor="white",
-                     markeredgewidth=1)
-        ax.errorbar(x, loo_means, yerr=loo_stds, color=color,
-                     marker="s", linestyle="--", label=f"{label} leave-one-out",
-                     capsize=3, capthick=1.2, markeredgecolor="white",
-                     markeredgewidth=1)
-
-    best_8b_idx = DEPTHS.index(selected["llama_3_1_8b"]["normalized_depth"])
-    best_70b_idx = DEPTHS.index(selected["llama_3_1_70b"]["normalized_depth"])
-    ax.axvline(best_8b_idx, color=C_8B, alpha=0.15, linewidth=8, zorder=0)
-    ax.axvline(best_70b_idx, color=C_70B, alpha=0.15, linewidth=8, zorder=0)
-
-    ax.set_xticks(range(len(DEPTHS)))
-    ax.set_xticklabels(DEPTH_LABELS)
-    ax.set_xlabel("Normalized depth")
-    ax.set_ylabel("ROC-AUC")
-    ax.set_ylim(0.88, 1.005)
-    ax.yaxis.set_major_formatter(mticker.FormatStrFormatter("%.2f"))
-    ax.legend(loc="lower left", framealpha=0.9, edgecolor="none")
-    ax.set_title("Within-relation and leave-one-out AUC by depth")
-
-    fig.tight_layout()
-    fig.savefig(FIGURES_DIR / "fig1_depth_profile.pdf")
-    fig.savefig(FIGURES_DIR / "fig1_depth_profile.png")
-    plt.close(fig)
-    print("  fig1_depth_profile.pdf")
-
-
-def fig2_generality_gap(gap: pd.DataFrame, selected: dict):
-    """Mean absolute generality gap by depth for both models."""
-    fig, ax = plt.subplots(figsize=(4.0, 3.0))
-
-    bar_width = 0.35
-    x = np.arange(len(DEPTHS))
-
-    for i, (model_key, color, label) in enumerate([
-        ("llama_3_1_8b", C_8B, "8B"),
-        ("llama_3_1_70b", C_70B, "70B"),
-    ]):
-        m = gap[gap["model_key"] == model_key]
-        mean_abs_gaps = []
-        for d in DEPTHS:
-            depth_data = m[m["normalized_depth"] == d]
-            mean_abs_gaps.append(depth_data["generality_gap"].abs().mean())
-
-        offset = (i - 0.5) * bar_width
-        bars = ax.bar(x + offset, mean_abs_gaps, bar_width * 0.88,
-                       color=color, alpha=0.85, label=label,
-                       edgecolor="white", linewidth=0.5)
-        for bar, val in zip(bars, mean_abs_gaps):
-            ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.001,
-                    f"{val:.3f}", ha="center", va="bottom", fontsize=7,
-                    color="#52514e")
-
-    ax.set_xticks(x)
-    ax.set_xticklabels(DEPTH_LABELS)
-    ax.set_xlabel("Normalized depth")
-    ax.set_ylabel("Mean |generality gap|")
-    ax.set_ylim(0, 0.06)
-    ax.legend(framealpha=0.9, edgecolor="none")
-    ax.set_title("Generality gap: 8B vs 70B")
-
-    fig.tight_layout()
-    fig.savefig(FIGURES_DIR / "fig2_generality_gap.pdf")
-    fig.savefig(FIGURES_DIR / "fig2_generality_gap.png")
-    plt.close(fig)
-    print("  fig2_generality_gap.pdf")
-
-
-def _draw_heatmap(ax, matrix: pd.DataFrame, title: str, vmin: float, vmax: float,
-                  cmap, show_cbar: bool = False):
-    """Draw a single transfer matrix heatmap."""
-    ordered = matrix.loc[RELATION_ORDER, RELATION_ORDER].astype(float)
-    data = ordered.values
-
-    im = ax.imshow(data, cmap=cmap, vmin=vmin, vmax=vmax, aspect="equal")
-
-    n = len(RELATION_ORDER)
-    for i in range(n):
-        for j in range(n):
-            val = data[i, j]
-            text_color = "white" if val > 0.97 else "#0b0b0b"
-            weight = "bold" if i == j else "normal"
-            ax.text(j, i, f"{val:.3f}", ha="center", va="center",
-                    fontsize=7, color=text_color, fontweight=weight)
-
-    ax.set_xticks(range(n))
-    ax.set_yticks(range(n))
-    short_labels = [RELATION_SHORT[r] for r in RELATION_ORDER]
-    ax.set_xticklabels(short_labels, fontsize=8)
-    ax.set_yticklabels(short_labels, fontsize=8)
-    ax.set_xlabel("Target relation", fontsize=9)
-    ax.set_ylabel("Source relation", fontsize=9)
-    ax.set_title(title, fontsize=10, pad=8)
-
-    ax.spines[:].set_visible(True)
-    ax.spines[:].set_linewidth(0.5)
-    ax.spines[:].set_color("#c3c2b7")
-    ax.tick_params(length=0)
-
-    return im
-
-
-def fig3_transfer_matrices(matrix_8b: pd.DataFrame, matrix_70b: pd.DataFrame):
-    """Side-by-side 6×6 transfer matrix heatmaps."""
-    blues = LinearSegmentedColormap.from_list("custom_blues", [
-        "#cde2fb", "#86b6ef", "#3987e5", "#1c5cab", "#104281"
-    ])
-
-    fig = plt.figure(figsize=(9.5, 3.8))
-    gs = fig.add_gridspec(1, 3, width_ratios=[1, 1, 0.05], wspace=0.3)
-    ax1 = fig.add_subplot(gs[0, 0])
-    ax2 = fig.add_subplot(gs[0, 1])
-    cax = fig.add_subplot(gs[0, 2])
-
-    _draw_heatmap(ax1, matrix_8b, "Llama-3.1-8B (layer 7, depth 25%)",
-                  vmin=0.84, vmax=1.0, cmap=blues)
-    im = _draw_heatmap(ax2, matrix_70b, "Llama-3.1-70B (layer 39, depth 50%)",
-                       vmin=0.84, vmax=1.0, cmap=blues)
-
-    cbar = fig.colorbar(im, cax=cax)
-    cbar.set_label("ROC-AUC", fontsize=9)
-    cbar.ax.tick_params(labelsize=8)
-    cbar.outline.set_linewidth(0.5)
-
-    fig.savefig(FIGURES_DIR / "fig3_transfer_matrices.pdf")
-    fig.savefig(FIGURES_DIR / "fig3_transfer_matrices.png")
-    plt.close(fig)
-    print("  fig3_transfer_matrices.pdf")
-
-
-def _fmt_gap(val: float) -> str:
-    if abs(val) < 0.0005:
-        return "0.000"
-    return f"{val:+.3f}"
-
-
-def fig4_relation_gap_detail(gap: pd.DataFrame, selected: dict):
-    """Per-relation generality gap at the selected layer for each model."""
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.5, 3.0))
-
-    n = len(RELATION_ORDER)
-    y_positions = np.arange(n)
-
-    for ax, model_key, color, title, layer_depth in [
-        (ax1, "llama_3_1_8b", C_8B, "8B (layer 7)", 0.25),
-        (ax2, "llama_3_1_70b", C_70B, "70B (layer 39)", 0.5),
-    ]:
-        m = gap[(gap["model_key"] == model_key) &
-                (gap["normalized_depth"] == layer_depth)]
-        m = m.set_index("target_relation").loc[RELATION_ORDER]
-
-        gaps = m["generality_gap"].values
-
-        colors = [color if g >= 0 else "#e34948" for g in gaps]
-        bars = ax.barh(y_positions, gaps, height=0.6, color=colors, alpha=0.8,
-                        edgecolor="white", linewidth=0.5)
-
-        for bar, val in zip(bars, gaps):
-            x_pos = val + 0.002 if val >= 0 else val - 0.002
-            ha = "left" if val >= 0 else "right"
-            ax.text(x_pos, bar.get_y() + bar.get_height() / 2,
-                    _fmt_gap(val), ha=ha, va="center", fontsize=7,
-                    color="#52514e")
-
-        ax.set_yticks(y_positions)
-        ax.set_yticklabels(RELATION_ORDER, fontsize=8)
-        ax.axvline(0, color="#c3c2b7", linewidth=0.8, zorder=0)
-        ax.set_xlabel("Generality gap (within − leave-one-out)", fontsize=8)
-        ax.set_title(title, fontsize=10)
-        ax.set_xlim(-0.035, 0.065)
-        ax.set_ylim(n - 0.5, -0.5)
-
-    fig.suptitle("Per-relation generality gap at selected layer",
-                 fontsize=10)
-    fig.tight_layout(rect=[0, 0, 1, 0.95])
-    fig.savefig(FIGURES_DIR / "fig4_relation_gap_detail.pdf")
-    fig.savefig(FIGURES_DIR / "fig4_relation_gap_detail.png")
-    plt.close(fig)
-    print("  fig4_relation_gap_detail.pdf")
-
-
-def fig5_relation_depth_profiles(gap: pd.DataFrame):
-    """Small multiples: each relation's within AUC trajectory across depths."""
-    fig, axes = plt.subplots(2, 3, figsize=(8, 4.5), sharex=True, sharey=True)
-
-    for idx, rel in enumerate(RELATION_ORDER):
-        ax = axes[idx // 3, idx % 3]
-
-        for model_key, color, label in [
-            ("llama_3_1_8b", C_8B, "8B"),
-            ("llama_3_1_70b", C_70B, "70B"),
-        ]:
-            m = gap[(gap["model_key"] == model_key) &
-                    (gap["target_relation"] == rel)]
-            m = m.sort_values("normalized_depth")
-            x = np.arange(len(DEPTHS))
-            ax.plot(x, m["within_mean_auc"].values, color=color,
-                    marker="o", markersize=4, label=f"{label} within",
-                    markeredgecolor="white", markeredgewidth=0.8)
-            ax.plot(x, m["loo_auc"].values, color=color,
-                    marker="s", markersize=4, linestyle="--",
-                    label=f"{label} leave-one-out",
-                    markeredgecolor="white", markeredgewidth=0.8)
-
-        ax.set_title(f"{rel}", fontsize=9, fontweight="bold")
-        ax.set_xticks(range(len(DEPTHS)))
-        ax.set_xticklabels(DEPTH_LABELS, fontsize=7)
-        ax.set_ylim(0.80, 1.01)
-        ax.yaxis.set_major_formatter(mticker.FormatStrFormatter("%.2f"))
-
-        if idx == 0:
-            ax.legend(fontsize=6, loc="lower left", framealpha=0.9,
-                      edgecolor="none")
-
-    fig.supxlabel("Normalized depth", fontsize=9)
-    fig.supylabel("ROC-AUC", fontsize=9)
-    fig.suptitle("Per-relation AUC profiles", fontsize=10, y=1.0)
-    fig.tight_layout()
-    fig.savefig(FIGURES_DIR / "fig5_relation_profiles.pdf")
-    fig.savefig(FIGURES_DIR / "fig5_relation_profiles.png")
-    plt.close(fig)
-    print("  fig5_relation_profiles.pdf")
-
-
-def table1_relation_results(gap: pd.DataFrame, selected: dict):
-    """Relation-level table at selected layers."""
-    rows = []
-    for rel in RELATION_ORDER:
-        row = {"Relation": rel}
-        for model_key, short, depth in [
-            ("llama_3_1_8b", "8B", 0.25),
-            ("llama_3_1_70b", "70B", 0.5),
-        ]:
-            m = gap[(gap["model_key"] == model_key) &
-                    (gap["normalized_depth"] == depth) &
-                    (gap["target_relation"] == rel)]
-            row[f"{short} within"] = f"{m['within_mean_auc'].values[0]:.3f}"
-            row[f"{short} std"] = f"{m['within_std_auc'].values[0]:.3f}"
-            row[f"{short} leave-one-out"] = f"{m['loo_auc'].values[0]:.3f}"
-            row[f"{short} gap"] = _fmt_gap(m['generality_gap'].values[0])
-        rows.append(row)
-
-    mean_row = {"Relation": "Mean"}
-    for model_key, short, depth in [
-        ("llama_3_1_8b", "8B", 0.25),
-        ("llama_3_1_70b", "70B", 0.5),
-    ]:
-        m = gap[(gap["model_key"] == model_key) &
-                (gap["normalized_depth"] == depth)]
-        mean_row[f"{short} within"] = f"{m['within_mean_auc'].mean():.3f}"
-        mean_row[f"{short} std"] = f"{m['within_std_auc'].mean():.3f}"
-        mean_row[f"{short} leave-one-out"] = f"{m['loo_auc'].mean():.3f}"
-        mean_row[f"{short} gap"] = _fmt_gap(m['generality_gap'].mean())
-    rows.append(mean_row)
-
-    table = pd.DataFrame(rows)
-    table.to_csv(RESULTS_DIR / "table1_relation_results.csv", index=False)
-    print("  table1_relation_results.csv")
-    print(table.to_string(index=False))
-
-
-def main():
-    setup_style()
-    gap, selected, matrix_8b, matrix_70b = load_data()
-
-    print("Generating figures...")
-    fig1_depth_profile(gap, selected)
-    fig2_generality_gap(gap, selected)
-    fig3_transfer_matrices(matrix_8b, matrix_70b)
-    fig4_relation_gap_detail(gap, selected)
-    fig5_relation_depth_profiles(gap)
-    table1_relation_results(gap, selected)
-    print("\nAll figures saved to figures/")
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/generate_splits.py

@@ -1,106 +0,0 @@
-"""Generate 3-fold pair-grouped cross-validation splits for N100.
-
-True/false examples from the same pair are always in the same fold.
-Downstream code joins on example_id, never on row index.
-
-Run from workspace/reproduction/scaling/ under the blackboxnlp conda env:
-    python generate_splits.py
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-
-SEED = 20260712_03
-ROOT = Path(__file__).resolve().parent
-DATA_PATH = ROOT / "data" / "processed" / "examples.parquet"
-OUTPUT_PATH = ROOT / "data" / "processed" / "splits.parquet"
-
-N_FOLDS = 3
-
-
-def main() -> None:
-    df = pd.read_parquet(DATA_PATH)
-    df = df[df["subset"] == "N100"]
-    print(f"Loaded {len(df)} N100 examples across "
-          f"{df['relation_id'].nunique()} relations")
-
-    rng = np.random.RandomState(SEED)
-
-    fold_assignments: list[dict] = []
-
-    for rel in sorted(df["relation_id"].unique()):
-        rel_df = df[df["relation_id"] == rel]
-        pairs = sorted(rel_df[rel_df["label"] == 1]["case_id"].unique())
-        n_pairs = len(pairs)
-
-        shuffled = rng.permutation(pairs)
-        folds = np.array_split(shuffled, N_FOLDS)
-        fold_sizes = [len(f) for f in folds]
-
-        pair_to_fold = {}
-        for fold_idx, fold_pairs in enumerate(folds):
-            for case_id in fold_pairs:
-                pair_to_fold[case_id] = fold_idx
-
-        for _, row in rel_df.iterrows():
-            fold_assignments.append({
-                "example_id": row["example_id"],
-                "pair_id": row["pair_id"],
-                "case_id": row["case_id"],
-                "relation_id": row["relation_id"],
-                "within_relation_fold": pair_to_fold[row["case_id"]],
-            })
-
-        print(f"  {rel}: {n_pairs} pairs -> folds {fold_sizes}")
-
-    splits = pd.DataFrame(fold_assignments)
-
-    # --- Validation ---
-    errors = []
-
-    for rel in splits["relation_id"].unique():
-        rel_splits = splits[splits["relation_id"] == rel]
-
-        for case_id in rel_splits["case_id"].unique():
-            pair_rows = rel_splits[rel_splits["case_id"] == case_id]
-            if pair_rows["within_relation_fold"].nunique() != 1:
-                errors.append(f"{rel} case_id={case_id}: pair split across folds")
-
-        fold_counts = rel_splits.groupby("within_relation_fold").size()
-        if len(fold_counts) != N_FOLDS:
-            errors.append(f"{rel}: expected {N_FOLDS} folds, got {len(fold_counts)}")
-
-    joined = splits.merge(
-        df[["example_id", "label"]], on="example_id", how="left"
-    )
-    for rel in splits["relation_id"].unique():
-        rel_j = joined[joined["relation_id"] == rel]
-        for fold in range(N_FOLDS):
-            fold_j = rel_j[rel_j["within_relation_fold"] == fold]
-            n_true = (fold_j["label"] == 1).sum()
-            n_false = (fold_j["label"] == 0).sum()
-            if n_true != n_false:
-                errors.append(f"{rel} fold {fold}: {n_true} true vs {n_false} false")
-
-    if errors:
-        for e in errors:
-            print(f"  ERROR: {e}")
-        raise RuntimeError("Split validation failed")
-
-    print(f"\nValidation passed:")
-    print(f"  All pairs have true/false in same fold")
-    print(f"  All relations have {N_FOLDS} folds")
-    print(f"  Class balance OK within every fold")
-
-    splits.to_parquet(OUTPUT_PATH, index=False, engine="pyarrow")
-    print(f"\nSaved {len(splits)} rows to {OUTPUT_PATH}")
-    print(f"Split seed: {SEED}")
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/ndif_smoke_test.py

@@ -1,77 +0,0 @@
-"""Minimal remote Llama-3.1-8B test using NNsight and NDIF.
-
-Before running:
-  1. Put NDIF_API_KEY and HF_TOKEN in the adjacent .env file.
-  2. Ensure the Hugging Face account behind HF_TOKEN has Meta Llama 3.1 access.
-  3. Install the workspace requirements.
-
-Run from workspace/reproduction/scaling:
-  python ndif_smoke_test.py
-
-This script sends one short prompt to NDIF. It does not download or run
-Llama weights on the local computer.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-
-def load_local_env(env_path: Path) -> None:
-    """Load simple KEY=VALUE entries without adding a python-dotenv dependency."""
-    if not env_path.exists():
-        raise FileNotFoundError(f"Missing credentials file: {env_path}")
-
-    for raw_line in env_path.read_text(encoding="utf-8").splitlines():
-        line = raw_line.strip()
-        if not line or line.startswith("#"):
-            continue
-        if "=" not in line:
-            raise ValueError(f"Invalid .env line: {raw_line!r}")
-
-        key, value = line.split("=", 1)
-        os.environ.setdefault(key.strip(), value.strip())
-
-
-def require_secret(name: str) -> str:
-    value = os.environ.get(name, "").strip()
-    if not value or value.startswith("PASTE_YOUR_"):
-        raise RuntimeError(
-            f"Set {name} in .env before running this script. "
-            "Do not paste the key into Python code or commit it to Git."
-        )
-    return value
-
-
-def main() -> None:
-    load_local_env(Path(__file__).with_name(".env"))
-
-    ndif_api_key = require_secret("NDIF_API_KEY")
-    require_secret("HF_TOKEN")
-    from nnsight import CONFIG, LanguageModel
-
-    # The key is read from the local environment, never written into source code.
-    CONFIG.set_default_api_key(ndif_api_key)
-
-    print("Creating the lightweight local model definition...")
-    # This exact ID is currently listed by ndif_status() as a running model.
-    model = LanguageModel("meta-llama/Llama-3.1-8B")
-
-    prompt = "The Eiffel Tower is located in"
-    print("Submitting one remote NDIF trace for Llama-3.1-8B...")
-    with model.trace(prompt, remote=True):
-        # Save the final layer's small sequence tensor. Indexing is performed
-        # locally below because this NDIF deployment does not whitelist the
-        # internal module NNsight uses to serialize remote tensor slicing.
-        hidden_sequence = model.model.layers[-1].output[0].save()
-
-    hidden = hidden_sequence[-1, :]
-
-    print("Success: NDIF returned one hidden representation.")
-    print(f"Returned shape: {tuple(hidden.shape)}")
-    print(f"Returned dtype: {hidden.dtype}")
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/prepare_counterfact_multirelation.py

@@ -1,552 +0,0 @@
-"""Prepare multi-relation CounterFact dataset for Phase 2 scaling experiment.
-
-Processes six CounterFact relations into balanced true/false sentence pairs
-with derangement-based negative construction.  Produces nested N50/N75/N100
-subsets for the timing-gate sample-size selection.
-
-Run from workspace/reproduction/scaling/ under the blackboxnlp conda env:
-    python prepare_counterfact_multirelation.py
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import random
-from collections import Counter, defaultdict
-from pathlib import Path
-from typing import Any
-
-import pandas as pd
-
-SEED = 20260712
-
-RELATIONS = ["P19", "P103", "P176", "P101", "P159", "P138"]
-RELATION_NAMES = {
-    "P19": "place of birth",
-    "P103": "native language",
-    "P176": "manufacturer",
-    "P101": "field of work",
-    "P159": "headquarters location",
-    "P138": "named after",
-}
-
-SUBSET_SIZES = [("N50", 50), ("N75", 75), ("N100", 100)]
-
-P103_FRENCH_CAPS = {"N50": 20, "N75": 30, "N100": 40}
-
-ROOT = Path(__file__).resolve().parent
-RAW_PATH = ROOT / "data" / "raw" / "counterfact.json"
-OUTPUT_DIR = ROOT / "data" / "processed"
-
-
-def make_sentence(template: str, subject: str, attribute: str) -> str:
-    return f"{template.format(subject).rstrip()} {attribute.strip()}"
-
-
-def load_raw(path: Path) -> list[dict]:
-    if not path.exists():
-        raise FileNotFoundError(f"Raw CounterFact not found: {path}")
-    with path.open("r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def relation_seed(rel: str) -> int:
-    return SEED + RELATIONS.index(rel) * 10007
-
-
-# ---------------------------------------------------------------------------
-# Cleaning
-# ---------------------------------------------------------------------------
-
-def filter_relations(records: list[dict]) -> dict[str, list[dict]]:
-    by_rel: dict[str, list[dict]] = defaultdict(list)
-    for r in records:
-        rel = r["requested_rewrite"]["relation_id"]
-        if rel in RELATIONS:
-            by_rel[rel].append(r)
-    return dict(by_rel)
-
-
-def dedup_subjects(records: list[dict]) -> list[dict]:
-    """Keep lowest case_id per subject."""
-    sorted_recs = sorted(records, key=lambda r: r["case_id"])
-    seen: set[str] = set()
-    out = []
-    for r in sorted_recs:
-        subj = r["requested_rewrite"]["subject"]
-        if subj not in seen:
-            seen.add(subj)
-            out.append(r)
-    return out
-
-
-def find_cross_relation_subjects(
-    by_rel: dict[str, list[dict]],
-) -> set[str]:
-    subj_rels: dict[str, set[str]] = defaultdict(set)
-    for rel, recs in by_rel.items():
-        for r in recs:
-            subj_rels[r["requested_rewrite"]["subject"]].add(rel)
-    return {s for s, rels in subj_rels.items() if len(rels) > 1}
-
-
-def remove_subjects(records: list[dict], subjects: set[str]) -> list[dict]:
-    return [r for r in records if r["requested_rewrite"]["subject"] not in subjects]
-
-
-def dedup_sentences(records: list[dict]) -> list[dict]:
-    seen: set[str] = set()
-    out = []
-    for r in records:
-        rw = r["requested_rewrite"]
-        sent = make_sentence(rw["prompt"], rw["subject"], rw["target_true"]["str"])
-        if sent not in seen:
-            seen.add(sent)
-            out.append(r)
-    return out
-
-
-# ---------------------------------------------------------------------------
-# Sampling
-# ---------------------------------------------------------------------------
-
-def sample_nested(
-    records: list[dict],
-    rel: str,
-) -> dict[str, list[dict]]:
-    if rel == "P103":
-        return _sample_p103(records)
-
-    rng = random.Random(relation_seed(rel))
-    pool = list(records)
-    rng.shuffle(pool)
-
-    subsets = {}
-    for name, size in SUBSET_SIZES:
-        if size > len(pool):
-            raise ValueError(f"{rel}: need {size} records for {name}, have {len(pool)}")
-        subsets[name] = sorted(pool[:size], key=lambda r: r["case_id"])
-    return subsets
-
-
-def _sample_p103(records: list[dict]) -> dict[str, list[dict]]:
-    french = [r for r in records if r["requested_rewrite"]["target_true"]["str"] == "French"]
-    non_french = [r for r in records if r["requested_rewrite"]["target_true"]["str"] != "French"]
-
-    base = relation_seed("P103")
-    rng_fr = random.Random(base + 1)
-    rng_oth = random.Random(base + 2)
-    rng_fr.shuffle(french)
-    rng_oth.shuffle(non_french)
-
-    subsets = {}
-    for name, size in SUBSET_SIZES:
-        cap = P103_FRENCH_CAPS[name]
-        n_other = size - cap
-        if cap > len(french):
-            raise ValueError(f"P103: need {cap} French for {name}, have {len(french)}")
-        if n_other > len(non_french):
-            raise ValueError(f"P103: need {n_other} non-French for {name}, have {len(non_french)}")
-        selected = french[:cap] + non_french[:n_other]
-        subsets[name] = sorted(selected, key=lambda r: r["case_id"])
-    return subsets
-
-
-# ---------------------------------------------------------------------------
-# Derangement
-# ---------------------------------------------------------------------------
-
-def construct_derangement(
-    records: list[dict],
-) -> list[tuple[dict, str, int]]:
-    """Attribute-shifted derangement.
-
-    Sort records by (attribute, case_id), then shift indices by max group
-    size.  Since max_group <= n//2, the shifted block never overlaps the
-    original block for any attribute, guaranteeing no self-match.
-
-    Returns (record, false_attribute, source_case_id) for each record.
-    """
-    n = len(records)
-    attrs = [r["requested_rewrite"]["target_true"]["str"] for r in records]
-
-    sorted_idx = sorted(range(n), key=lambda i: (attrs[i], records[i]["case_id"]))
-    sorted_attrs = [attrs[i] for i in sorted_idx]
-
-    max_group = max(Counter(attrs).values())
-    if max_group > n // 2:
-        attr_counts = Counter(attrs).most_common(3)
-        raise ValueError(
-            f"Derangement impossible: max group {max_group} > n//2={n // 2}. "
-            f"Top attributes: {attr_counts}"
-        )
-
-    shift = max_group
-    result: list[tuple[dict, str, int]] = []
-    for pos, orig_i in enumerate(sorted_idx):
-        target_pos = (pos + shift) % n
-        target_i = sorted_idx[target_pos]
-        false_attr = attrs[target_i]
-        assert false_attr != attrs[orig_i], (
-            f"Self-match at pos {pos}: {false_attr}"
-        )
-        result.append((records[orig_i], false_attr, records[target_i]["case_id"]))
-
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Example construction
-# ---------------------------------------------------------------------------
-
-def build_examples(
-    deranged: list[tuple[dict, str, int]],
-    subset_name: str,
-) -> list[dict]:
-    examples = []
-    for record, false_attr, source_case_id in deranged:
-        rw = record["requested_rewrite"]
-        cid = record["case_id"]
-        subj = rw["subject"]
-        tpl = rw["prompt"]
-        true_attr = rw["target_true"]["str"]
-        rel = rw["relation_id"]
-
-        common = {
-            "pair_id": f"{rel}_{subset_name}_{cid}",
-            "case_id": cid,
-            "relation_id": rel,
-            "subject": subj,
-            "template": tpl,
-            "true_attribute": true_attr,
-            "false_attribute_source_id": source_case_id,
-            "subset": subset_name,
-        }
-        examples.append({
-            **common,
-            "example_id": f"{rel}_{subset_name}_{cid}_true",
-            "used_attribute": true_attr,
-            "sentence": make_sentence(tpl, subj, true_attr),
-            "label": 1,
-        })
-        examples.append({
-            **common,
-            "example_id": f"{rel}_{subset_name}_{cid}_false",
-            "used_attribute": false_attr,
-            "sentence": make_sentence(tpl, subj, false_attr),
-            "label": 0,
-        })
-    return examples
-
-
-# ---------------------------------------------------------------------------
-# Validation
-# ---------------------------------------------------------------------------
-
-def validate_subset(
-    examples: list[dict],
-    subset_name: str,
-    rel: str,
-) -> dict[str, Any]:
-    true_ex = [e for e in examples if e["label"] == 1]
-    false_ex = [e for e in examples if e["label"] == 0]
-    errors: list[str] = []
-
-    expected = dict(SUBSET_SIZES)[subset_name]
-    if len(true_ex) != expected:
-        errors.append(f"Expected {expected} pairs, got {len(true_ex)}")
-    if len(true_ex) != len(false_ex):
-        errors.append(f"Class imbalance: {len(true_ex)} true vs {len(false_ex)} false")
-
-    ids = [e["example_id"] for e in examples]
-    if len(ids) != len(set(ids)):
-        errors.append("Duplicate example_ids")
-
-    sents = [e["sentence"] for e in examples]
-    if len(sents) != len(set(sents)):
-        n_dup = len(sents) - len(set(sents))
-        errors.append(f"{n_dup} duplicate sentences")
-
-    subjects = [e["subject"] for e in true_ex]
-    if len(subjects) != len(set(subjects)):
-        errors.append("Duplicate subjects")
-
-    for e in false_ex:
-        if e["used_attribute"] == e["true_attribute"]:
-            errors.append(f"false==true for case_id {e['case_id']}")
-            break
-
-    true_marginals = Counter(e["used_attribute"] for e in true_ex)
-    false_marginals = Counter(e["used_attribute"] for e in false_ex)
-    marginals_match = true_marginals == false_marginals
-    if not marginals_match:
-        errors.append("Attribute marginals differ between true and false")
-
-    if rel == "P103":
-        n_french = sum(1 for e in true_ex if e["true_attribute"] == "French")
-        expected_cap = P103_FRENCH_CAPS[subset_name]
-        if n_french != expected_cap:
-            errors.append(f"P103 French count {n_french} != cap {expected_cap}")
-
-    return {
-        "relation_id": rel,
-        "subset": subset_name,
-        "pairs": len(true_ex),
-        "examples": len(examples),
-        "unique_subjects": len(set(subjects)),
-        "unique_attributes_true": len(true_marginals),
-        "unique_attributes_false": len(false_marginals),
-        "marginals_match": marginals_match,
-        "errors": errors,
-        "valid": len(errors) == 0,
-    }
-
-
-def validate_nesting(
-    subsets: dict[str, list[dict]],
-    rel: str,
-) -> list[str]:
-    """Check N50 ⊂ N75 ⊂ N100 by case_id."""
-    errors = []
-    ids = {name: {e["example_id"] for e in exs if e["label"] == 1}
-           for name, exs in subsets.items()}
-    case_ids = {name: {e["case_id"] for e in exs if e["label"] == 1}
-                for name, exs in subsets.items()}
-
-    if not case_ids["N50"] <= case_ids["N75"]:
-        errors.append(f"{rel}: N50 not subset of N75")
-    if not case_ids["N75"] <= case_ids["N100"]:
-        errors.append(f"{rel}: N75 not subset of N100")
-    return errors
-
-
-# ---------------------------------------------------------------------------
-# Output
-# ---------------------------------------------------------------------------
-
-def sha256_file(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as f:
-        for chunk in iter(lambda: f.read(8192), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def save_outputs(
-    all_examples: list[dict],
-    relation_meta: dict[str, Any],
-    manifest: dict[str, Any],
-) -> None:
-    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-    parquet_path = OUTPUT_DIR / "examples.parquet"
-    df = pd.DataFrame(all_examples)
-    col_order = [
-        "example_id", "pair_id", "case_id", "relation_id", "subject",
-        "template", "true_attribute", "used_attribute", "sentence",
-        "label", "false_attribute_source_id", "subset",
-    ]
-    df = df[col_order]
-    df.to_parquet(parquet_path, index=False, engine="pyarrow")
-    print(f"\nSaved {len(df)} examples to {parquet_path}")
-
-    manifest["output_hash"] = sha256_file(parquet_path)
-
-    rel_path = OUTPUT_DIR / "relations.json"
-    rel_path.write_text(
-        json.dumps(relation_meta, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
-
-    manifest_path = OUTPUT_DIR / "dataset_manifest.json"
-    manifest_path.write_text(
-        json.dumps(manifest, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
-    print(f"Saved relations.json and dataset_manifest.json")
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    print("=" * 60)
-    print("CounterFact multi-relation preprocessing")
-    print("=" * 60)
-
-    raw = load_raw(RAW_PATH)
-    print(f"Loaded {len(raw)} raw CounterFact records\n")
-
-    # --- Stage 1: filter ---
-    by_rel = filter_relations(raw)
-    s1 = {r: len(v) for r, v in by_rel.items()}
-    print("Stage 1 — Filter to target relations:")
-    for rel in RELATIONS:
-        print(f"  {rel} ({RELATION_NAMES[rel]}): {s1[rel]}")
-
-    # --- Stage 2: within-relation subject dedup ---
-    for rel in RELATIONS:
-        by_rel[rel] = dedup_subjects(by_rel[rel])
-    s2 = {r: len(v) for r, v in by_rel.items()}
-    print("\nStage 2 — Within-relation subject dedup:")
-    for rel in RELATIONS:
-        d = s1[rel] - s2[rel]
-        print(f"  {rel}: {s1[rel]} -> {s2[rel]}  ({d} removed)")
-
-    # --- Stage 3: cross-relation subject removal ---
-    cross_subjs = find_cross_relation_subjects(by_rel)
-    for rel in RELATIONS:
-        by_rel[rel] = remove_subjects(by_rel[rel], cross_subjs)
-    s3 = {r: len(v) for r, v in by_rel.items()}
-    print(f"\nStage 3 — Cross-relation subject removal ({len(cross_subjs)} subjects):")
-    for rel in RELATIONS:
-        d = s2[rel] - s3[rel]
-        print(f"  {rel}: {s2[rel]} -> {s3[rel]}  ({d} removed)")
-    print(f"  Removed subjects: {sorted(cross_subjs)}")
-
-    # --- Stage 4: sentence dedup ---
-    for rel in RELATIONS:
-        by_rel[rel] = dedup_sentences(by_rel[rel])
-    s4 = {r: len(v) for r, v in by_rel.items()}
-    print("\nStage 4 — Sentence dedup:")
-    for rel in RELATIONS:
-        d = s3[rel] - s4[rel]
-        print(f"  {rel}: {s3[rel]} -> {s4[rel]}  ({d} removed)")
-
-    # --- P103 attribute distribution after cleaning ---
-    p103_attrs = Counter(
-        r["requested_rewrite"]["target_true"]["str"] for r in by_rel["P103"]
-    )
-    n_french = p103_attrs.get("French", 0)
-    print(f"\nP103 after cleaning: {s4['P103']} records, "
-          f"French={n_french} ({100*n_french/s4['P103']:.1f}%)")
-
-    # --- Sample, derange, build examples ---
-    all_examples: list[dict] = []
-    all_validations: list[dict] = []
-    nesting_errors: list[str] = []
-    relation_meta: dict[str, Any] = {}
-
-    for rel in RELATIONS:
-        print(f"\nProcessing {rel}...")
-        subsets_records = sample_nested(by_rel[rel], rel)
-
-        rel_info: dict[str, Any] = {
-            "relation_id": rel,
-            "relation_name": RELATION_NAMES[rel],
-            "cleaning_counts": {
-                "raw": s1[rel],
-                "after_subject_dedup": s2[rel],
-                "after_cross_relation_removal": s3[rel],
-                "after_sentence_dedup": s4[rel],
-            },
-            "subsets": {},
-        }
-
-        subset_examples: dict[str, list[dict]] = {}
-
-        for subset_name, size in SUBSET_SIZES:
-            recs = subsets_records[subset_name]
-            deranged = construct_derangement(recs)
-            exs = build_examples(deranged, subset_name)
-
-            val = validate_subset(exs, subset_name, rel)
-            all_validations.append(val)
-            subset_examples[subset_name] = exs
-            all_examples.extend(exs)
-
-            attr_dist = Counter(
-                r["requested_rewrite"]["target_true"]["str"] for r in recs
-            )
-            rel_info["subsets"][subset_name] = {
-                "pairs": len(recs),
-                "examples": len(exs),
-                "attribute_distribution": dict(attr_dist.most_common()),
-                "unique_templates": len({r["requested_rewrite"]["prompt"] for r in recs}),
-                "unique_subjects": len({r["requested_rewrite"]["subject"] for r in recs}),
-                "validation": val,
-            }
-
-            status = "PASS" if val["valid"] else f"FAIL: {val['errors']}"
-            print(f"  {subset_name}: {size} pairs -> {len(exs)} examples  {status}")
-
-        nest_err = validate_nesting(subset_examples, rel)
-        nesting_errors.extend(nest_err)
-        if nest_err:
-            print(f"  NESTING ERROR: {nest_err}")
-        else:
-            print(f"  Nesting N50 ⊂ N75 ⊂ N100: OK")
-
-        relation_meta[rel] = rel_info
-
-    # --- Cross-relation duplicate check on N100 ---
-    n100_subjects: dict[str, set[str]] = defaultdict(set)
-    for e in all_examples:
-        if e["subset"] == "N100" and e["label"] == 1:
-            n100_subjects[e["relation_id"]].add(e["subject"])
-    cross_check_errors = []
-    for i, r1 in enumerate(RELATIONS):
-        for r2 in RELATIONS[i + 1:]:
-            overlap = n100_subjects[r1] & n100_subjects[r2]
-            if overlap:
-                cross_check_errors.append(f"{r1}+{r2}: {len(overlap)} shared subjects")
-    if cross_check_errors:
-        print(f"\nCROSS-RELATION SUBJECT LEAK: {cross_check_errors}")
-    else:
-        print("\nCross-relation subject check on N100: OK (no overlap)")
-
-    # --- Build manifest ---
-    manifest: dict[str, Any] = {
-        "seed": SEED,
-        "relations": RELATIONS,
-        "subset_sizes": {name: size for name, size in SUBSET_SIZES},
-        "p103_french_caps": P103_FRENCH_CAPS,
-        "cleaning_stages": {
-            "stage1_raw": s1,
-            "stage2_subject_dedup": s2,
-            "stage3_cross_relation": s3,
-            "stage4_sentence_dedup": s4,
-        },
-        "cross_relation_subjects": sorted(cross_subjs),
-        "total_examples": len(all_examples),
-        "examples_per_subset": {
-            name: sum(1 for e in all_examples if e["subset"] == name)
-            for name, _ in SUBSET_SIZES
-        },
-        "validation": {
-            "all_subset_checks_passed": all(v["valid"] for v in all_validations),
-            "nesting_checks_passed": len(nesting_errors) == 0,
-            "cross_relation_check_passed": len(cross_check_errors) == 0,
-            "checks_passed": sum(1 for v in all_validations if v["valid"]),
-            "checks_total": len(all_validations),
-        },
-        "raw_data_hash": sha256_file(RAW_PATH),
-    }
-
-    save_outputs(all_examples, relation_meta, manifest)
-
-    # --- Final report ---
-    all_passed = (
-        all(v["valid"] for v in all_validations)
-        and len(nesting_errors) == 0
-        and len(cross_check_errors) == 0
-    )
-    print("\n" + "=" * 60)
-    print("VALIDATION SUMMARY")
-    print("=" * 60)
-    for v in all_validations:
-        status = "PASS" if v["valid"] else f"FAIL: {v['errors']}"
-        print(f"  {v['relation_id']} {v['subset']}: {status}")
-    if nesting_errors:
-        for err in nesting_errors:
-            print(f"  NESTING: {err}")
-    print(f"\n{'ALL CHECKS PASSED' if all_passed else 'FAILURES DETECTED'}")
-
-    if not all_passed:
-        raise RuntimeError("Validation failures — see output above")
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/prepare_counterfact_p103.py

@@ -1,214 +0,0 @@
-"""Create a controlled, balanced true/false P103 dataset from CounterFact.
-
-French occurs in more than half of raw P103 records, making a frequency-
-preserving derangement of all P103 examples mathematically impossible. We
-therefore retain every non-French record and deterministically sample an equal
-number of French records. False attributes then exchange the French and
-non-French pools. Every attribute has exactly the same frequency in both
-labels, and no false sentence retains its own true attribute. This prevents a
-linear probe from succeeding merely because a language name is more frequent
-in one label.
-
-Run from any directory:
-    python prepare_counterfact_p103.py
-"""
-
-from __future__ import annotations
-
-import json
-import random
-from collections import Counter
-from pathlib import Path
-from typing import Any
-
-
-SEED = 20260711
-RELATION_ID = "P103"
-ROOT = Path(__file__).resolve().parent
-RAW_PATH = ROOT / "data" / "raw" / "counterfact.json"
-OUTPUT_PATH = ROOT / "data" / "processed" / "counterfact_p103_balanced_pairs.jsonl"
-SUMMARY_PATH = ROOT / "data" / "processed" / "counterfact_p103_balanced_summary.json"
-
-
-def make_sentence(template: str, subject: str, attribute: str) -> str:
-    """Fill CounterFact's subject placeholder and add exactly one word space."""
-    return f"{template.format(subject).rstrip()} {attribute.strip()}"
-
-
-def load_p103_records(path: Path) -> list[dict[str, Any]]:
-    if not path.exists():
-        raise FileNotFoundError(
-            f"Raw CounterFact file is missing: {path}\n"
-            "Download it before running this preparation script."
-        )
-
-    with path.open("r", encoding="utf-8") as handle:
-        raw_records = json.load(handle)
-
-    records = [
-        record
-        for record in raw_records
-        if record["requested_rewrite"]["relation_id"] == RELATION_ID
-    ]
-    if not records:
-        raise RuntimeError(f"No records found for relation {RELATION_ID}.")
-    return records
-
-
-def select_balanced_records(
-    records: list[dict[str, Any]],
-) -> tuple[list[dict[str, Any]], str, int]:
-    """Balance the dominant attribute against the aggregate of all others."""
-    attributes = [record["requested_rewrite"]["target_true"]["str"] for record in records]
-    dominant_attribute, dominant_count = Counter(attributes).most_common(1)[0]
-    dominant_records = [
-        record
-        for record in records
-        if record["requested_rewrite"]["target_true"]["str"] == dominant_attribute
-    ]
-    other_records = [record for record in records if record not in dominant_records]
-
-    if not other_records:
-        raise RuntimeError("P103 has no non-dominant attributes to construct negatives from.")
-
-    rng = random.Random(SEED)
-    sampled_dominant = rng.sample(dominant_records, len(other_records))
-    selected = sorted(sampled_dominant + other_records, key=lambda record: record["case_id"])
-    excluded = dominant_count - len(sampled_dominant)
-    return selected, dominant_attribute, excluded
-
-
-def build_examples(records: list[dict[str, Any]], dominant_attribute: str) -> list[dict[str, Any]]:
-    dominant_records = [
-        record
-        for record in records
-        if record["requested_rewrite"]["target_true"]["str"] == dominant_attribute
-    ]
-    other_records = [record for record in records if record not in dominant_records]
-
-    false_by_case_id: dict[int, str] = {}
-    other_attributes = [record["requested_rewrite"]["target_true"]["str"] for record in other_records]
-    random.Random(SEED).shuffle(other_attributes)
-    for record, false_attribute in zip(dominant_records, other_attributes):
-        false_by_case_id[record["case_id"]] = false_attribute
-    for record in other_records:
-        false_by_case_id[record["case_id"]] = dominant_attribute
-
-    examples: list[dict[str, Any]] = []
-    for record in records:
-        rewrite = record["requested_rewrite"]
-        case_id = record["case_id"]
-        subject = rewrite["subject"]
-        template = rewrite["prompt"]
-        true_attribute = rewrite["target_true"]["str"]
-        false_attribute = false_by_case_id[case_id]
-
-        common = {
-            "pair_id": case_id,
-            "case_id": case_id,
-            "relation_id": rewrite["relation_id"],
-            "subject": subject,
-            "template": template,
-            "target_true": true_attribute,
-            "target_false": false_attribute,
-            "construction": "P103_balanced_dominant_attribute_exchange",
-        }
-        examples.append(
-            {
-                **common,
-                "example_id": f"{case_id}_true",
-                "label": 1,
-                "sentence": make_sentence(template, subject, true_attribute),
-            }
-        )
-        examples.append(
-            {
-                **common,
-                "example_id": f"{case_id}_false",
-                "label": 0,
-                "sentence": make_sentence(template, subject, false_attribute),
-            }
-        )
-
-    return examples
-
-
-def validate(
-    source_records: int,
-    records: list[dict[str, Any]],
-    examples: list[dict[str, Any]],
-    dominant_attribute: str,
-    excluded_records: int,
-) -> dict[str, Any]:
-    true_examples = [example for example in examples if example["label"] == 1]
-    false_examples = [example for example in examples if example["label"] == 0]
-
-    if len(examples) != 2 * len(records):
-        raise AssertionError("Each source record must create exactly two examples.")
-    if len(true_examples) != len(false_examples):
-        raise AssertionError("The labels are not balanced.")
-    if any(example["target_true"] == example["target_false"] for example in examples):
-        raise AssertionError("A false example retained its true attribute.")
-    if Counter(example["target_true"] for example in true_examples) != Counter(
-        example["target_false"] for example in false_examples
-    ):
-        raise AssertionError("True and false attribute frequencies are not balanced.")
-
-    return {
-        "source": str(RAW_PATH),
-        "relation_id": RELATION_ID,
-        "seed": SEED,
-        "source_records": source_records,
-        "selected_records": len(records),
-        "excluded_records": excluded_records,
-        "dominant_attribute": dominant_attribute,
-        "pairs": len(records),
-        "examples": len(examples),
-        "true_examples": len(true_examples),
-        "false_examples": len(false_examples),
-        "unique_attributes": len({example["target_true"] for example in true_examples}),
-        "validation": {
-            "labels_balanced": True,
-            "no_false_attribute_equals_its_true_attribute": True,
-            "true_false_attribute_frequencies_match": True,
-        },
-    }
-
-
-def write_jsonl(path: Path, examples: list[dict[str, Any]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", encoding="utf-8") as handle:
-        for example in examples:
-            handle.write(json.dumps(example, ensure_ascii=False) + "\n")
-
-
-def main() -> None:
-    source_records = load_p103_records(RAW_PATH)
-    records, dominant_attribute, excluded_records = select_balanced_records(source_records)
-    examples = build_examples(records, dominant_attribute)
-    summary = validate(
-        len(source_records), records, examples, dominant_attribute, excluded_records
-    )
-    write_jsonl(OUTPUT_PATH, examples)
-    SUMMARY_PATH.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
-
-    print("P103 CounterFact preparation completed.")
-    print(
-        f"Source P103 records: {summary['source_records']}; "
-        f"balanced pairs: {summary['pairs']}; examples: {summary['examples']}"
-    )
-    print(
-        f"Balanced dominant attribute: {summary['dominant_attribute']}; "
-        f"excluded source records: {summary['excluded_records']}"
-    )
-    print(f"Output: {OUTPUT_PATH}")
-    print("\nFirst five true/false pairs:")
-    for index in range(0, min(10, len(examples)), 2):
-        true_example, false_example = examples[index], examples[index + 1]
-        print(f"\nPair {true_example['pair_id']}")
-        print(f"  TRUE : {true_example['sentence']}")
-        print(f"  FALSE: {false_example['sentence']}")
-
-
-if __name__ == "__main__":
-    main()

phase2_scaling/run_probing.py

@@ -1,639 +0,0 @@
-"""Phase 2 probing pipeline: Stage 1A, 1B, layer selection, Stage 2.
-
-Run from workspace/reproduction/scaling/ under the blackboxnlp conda env:
-    python run_probing.py
-"""
-from __future__ import annotations
-
-import hashlib
-import json
-import warnings
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-import sklearn
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import balanced_accuracy_score, roc_auc_score
-from sklearn.preprocessing import StandardScaler
-
-ROOT = Path(__file__).resolve().parent
-CONFIG_PATH = ROOT / "experiment_config.json"
-DATA_DIR = ROOT / "data" / "processed"
-ACT_DIR = ROOT / "activations"
-RESULTS_DIR = ROOT / "results"
-WEIGHTS_DIR = RESULTS_DIR / "probe_weights"
-
-MODELS = {
-    "llama_3_1_8b": {"model_id": "meta-llama/Llama-3.1-8B"},
-    "llama_3_1_70b": {"model_id": "meta-llama/Llama-3.1-70B"},
-}
-
-RELATION_ORDER = ["P19", "P103", "P101", "P159", "P176", "P138"]
-
-
-def load_config() -> dict:
-    with open(CONFIG_PATH) as f:
-        return json.load(f)
-
-
-def config_hash(cfg: dict) -> str:
-    blob = json.dumps(cfg["probe"], sort_keys=True).encode()
-    return hashlib.sha256(blob).hexdigest()[:16]
-
-
-def load_data():
-    examples = pd.read_parquet(DATA_DIR / "examples.parquet")
-    examples = examples[examples["subset"] == "N100"]
-    splits = pd.read_parquet(DATA_DIR / "splits.parquet")
-    merged = examples.merge(splits[["example_id", "within_relation_fold"]],
-                            on="example_id", how="inner")
-    return merged
-
-
-def load_activations(model_key: str) -> tuple[dict[int, np.ndarray], pd.DataFrame]:
-    model_dir = ACT_DIR / model_key
-    with open(model_dir / "manifest.json") as f:
-        manifest = json.load(f)
-    sample_index = pd.read_parquet(model_dir / "sample_index.parquet")
-
-    acts = {}
-    for layer_info in manifest["target_layers"]:
-        li = layer_info["layer_index"]
-        arr = np.load(model_dir / f"layer_{li}.npy").astype(np.float32)
-        acts[li] = arr
-
-    return acts, sample_index
-
-
-def make_probe(cfg: dict) -> LogisticRegression:
-    p = cfg["probe"]
-    return LogisticRegression(
-        solver=p["solver"],
-        penalty=p["penalty"],
-        C=p["C"],
-        max_iter=p["max_iter"],
-        tol=p["tol"],
-        fit_intercept=p["fit_intercept"],
-        class_weight=p["class_weight"],
-        random_state=p["random_state"],
-    )
-
-
-def fit_and_predict(
-    X_train: np.ndarray, y_train: np.ndarray,
-    X_test: np.ndarray, y_test: np.ndarray,
-    cfg: dict,
-) -> tuple[LogisticRegression, StandardScaler, np.ndarray, float, float, int]:
-    scaler = StandardScaler()
-    X_train_s = scaler.fit_transform(X_train)
-    X_test_s = scaler.transform(X_test)
-
-    probe = make_probe(cfg)
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        probe.fit(X_train_s, y_train)
-
-    for w in caught:
-        if issubclass(w.category, sklearn.exceptions.ConvergenceWarning):
-            raise RuntimeError(
-                f"Probe did not converge within max_iter={cfg['probe']['max_iter']}. "
-                f"Training samples={len(y_train)}, features={X_train.shape[1]}"
-            )
-
-    scores = probe.predict_proba(X_test_s)[:, 1]
-    auc = roc_auc_score(y_test, scores)
-    preds = (scores >= 0.5).astype(int)
-    bal_acc = balanced_accuracy_score(y_test, preds)
-    n_iter = int(probe.n_iter_[0])
-
-    return probe, scaler, scores, auc, bal_acc, n_iter
-
-
-def save_probe(
-    probe: LogisticRegression, scaler: StandardScaler,
-    probe_id: str, meta: dict,
-) -> None:
-    np.savez(
-        WEIGHTS_DIR / f"{probe_id}.npz",
-        coefficient=probe.coef_,
-        intercept=probe.intercept_,
-        scaler_mean=scaler.mean_,
-        scaler_scale=scaler.scale_,
-        classes=probe.classes_,
-    )
-    manifest_path = WEIGHTS_DIR / f"{probe_id}_manifest.json"
-    with open(manifest_path, "w") as f:
-        json.dump(meta, f, indent=2)
-
-
-def build_activation_index(sample_index: pd.DataFrame, data: pd.DataFrame):
-    eid_to_row = {eid: i for i, eid in enumerate(sample_index["example_id"])}
-    data = data.copy()
-    data["act_row"] = data["example_id"].map(eid_to_row)
-    assert data["act_row"].notna().all(), "example_id mismatch between data and activations"
-    data["act_row"] = data["act_row"].astype(int)
-    return data
-
-
-def run_stage1a(data: pd.DataFrame, model_key: str, acts: dict[int, np.ndarray],
-                manifest: dict, cfg: dict, cfg_h: str):
-    relations = RELATION_ORDER
-    metrics_rows = []
-    pred_rows = []
-    probe_count = 0
-
-    for layer_info in manifest["target_layers"]:
-        li = layer_info["layer_index"]
-        depth = layer_info["depth"]
-        X_all = acts[li]
-
-        for rel in relations:
-            rel_data = data[data["relation_id"] == rel]
-
-            for fold in range(3):
-                train_mask = rel_data["within_relation_fold"] != fold
-                test_mask = rel_data["within_relation_fold"] == fold
-
-                train_rows = rel_data[train_mask]["act_row"].values
-                test_rows = rel_data[test_mask]["act_row"].values
-
-                X_train = X_all[train_rows]
-                y_train = rel_data[train_mask]["label"].values
-                X_test = X_all[test_rows]
-                y_test = rel_data[test_mask]["label"].values
-
-                probe, scaler, scores, auc, bal_acc, n_iter = fit_and_predict(
-                    X_train, y_train, X_test, y_test, cfg
-                )
-
-                probe_id = f"s1a_{model_key}_L{li}_{rel}_f{fold}"
-                train_eids = rel_data[train_mask]["example_id"].tolist()
-
-                save_probe(probe, scaler, probe_id, {
-                    "probe_id": probe_id,
-                    "stage": "1A",
-                    "protocol": "within_relation",
-                    "model_id": MODELS[model_key]["model_id"],
-                    "model_revision": "served via NDIF",
-                    "layer_index": li,
-                    "normalized_depth": depth,
-                    "source_relations": [rel],
-                    "target_relation": rel,
-                    "fold": fold,
-                    "training_example_ids": train_eids,
-                    "probe_configuration_hash": cfg_h,
-                    "sklearn_version": sklearn.__version__,
-                    "n_iter": n_iter,
-                })
-
-                metrics_rows.append({
-                    "stage": "1A",
-                    "model_id": MODELS[model_key]["model_id"],
-                    "model_key": model_key,
-                    "layer_index": li,
-                    "normalized_depth": depth,
-                    "protocol": "within_relation",
-                    "source_relations": rel,
-                    "target_relation": rel,
-                    "fold": fold,
-                    "auc": auc,
-                    "balanced_accuracy": bal_acc,
-                    "n_train": len(y_train),
-                    "n_test": len(y_test),
-                    "n_iter": n_iter,
-                })
-
-                test_eids = rel_data[test_mask]["example_id"].values
-                for eid, true_label, score in zip(test_eids, y_test, scores):
-                    pred_rows.append({
-                        "stage": "1A",
-                        "model_id": MODELS[model_key]["model_id"],
-                        "model_key": model_key,
-                        "layer_index": li,
-                        "normalized_depth": depth,
-                        "protocol": "within_relation",
-                        "source_relations": rel,
-                        "target_relation": rel,
-                        "fold": fold,
-                        "example_id": eid,
-                        "true_label": true_label,
-                        "prediction_score": float(score),
-                    })
-
-                probe_count += 1
-
-    print(f"  Stage 1A: {probe_count} probes fitted for {model_key}")
-    return metrics_rows, pred_rows
-
-
-def run_stage1b(data: pd.DataFrame, model_key: str, acts: dict[int, np.ndarray],
-                manifest: dict, cfg: dict, cfg_h: str):
-    relations = RELATION_ORDER
-    metrics_rows = []
-    pred_rows = []
-    probe_count = 0
-
-    for layer_info in manifest["target_layers"]:
-        li = layer_info["layer_index"]
-        depth = layer_info["depth"]
-        X_all = acts[li]
-
-        for target_rel in relations:
-            train_data = data[data["relation_id"] != target_rel]
-            test_data = data[data["relation_id"] == target_rel]
-
-            train_rows = train_data["act_row"].values
-            test_rows = test_data["act_row"].values
-
-            X_train = X_all[train_rows]
-            y_train = train_data["label"].values
-            X_test = X_all[test_rows]
-            y_test = test_data["label"].values
-
-            source_rels = [r for r in relations if r != target_rel]
-
-            probe, scaler, scores, auc, bal_acc, n_iter = fit_and_predict(
-                X_train, y_train, X_test, y_test, cfg
-            )
-
-            probe_id = f"s1b_{model_key}_L{li}_target_{target_rel}"
-            train_eids = train_data["example_id"].tolist()
-
-            save_probe(probe, scaler, probe_id, {
-                "probe_id": probe_id,
-                "stage": "1B",
-                "protocol": "leave_one_out",
-                "model_id": MODELS[model_key]["model_id"],
-                "model_revision": "served via NDIF",
-                "layer_index": li,
-                "normalized_depth": depth,
-                "source_relations": source_rels,
-                "target_relation": target_rel,
-                "fold": None,
-                "training_example_ids": train_eids,
-                "probe_configuration_hash": cfg_h,
-                "sklearn_version": sklearn.__version__,
-                "n_iter": n_iter,
-            })
-
-            metrics_rows.append({
-                "stage": "1B",
-                "model_id": MODELS[model_key]["model_id"],
-                "model_key": model_key,
-                "layer_index": li,
-                "normalized_depth": depth,
-                "protocol": "leave_one_out",
-                "source_relations": ";".join(source_rels),
-                "target_relation": target_rel,
-                "fold": None,
-                "auc": auc,
-                "balanced_accuracy": bal_acc,
-                "n_train": len(y_train),
-                "n_test": len(y_test),
-                "n_iter": n_iter,
-            })
-
-            for eid, true_label, score in zip(test_data["example_id"].values,
-                                               y_test, scores):
-                pred_rows.append({
-                    "stage": "1B",
-                    "model_id": MODELS[model_key]["model_id"],
-                    "model_key": model_key,
-                    "layer_index": li,
-                    "normalized_depth": depth,
-                    "protocol": "leave_one_out",
-                    "source_relations": ";".join(source_rels),
-                    "target_relation": target_rel,
-                    "fold": None,
-                    "example_id": eid,
-                    "true_label": true_label,
-                    "prediction_score": float(score),
-                })
-
-            probe_count += 1
-
-    print(f"  Stage 1B: {probe_count} probes fitted for {model_key}")
-    return metrics_rows, pred_rows
-
-
-def select_layers(metrics_1a: pd.DataFrame, cfg: dict) -> dict:
-    tol = cfg["layer_selection_tie_tolerance"]
-    selected = {}
-
-    for model_key in metrics_1a["model_key"].unique():
-        m = metrics_1a[metrics_1a["model_key"] == model_key]
-        mean_by_depth = (
-            m.groupby(["layer_index", "normalized_depth"])["auc"]
-            .mean()
-            .reset_index()
-        )
-        best_auc = mean_by_depth["auc"].max()
-        candidates = mean_by_depth[mean_by_depth["auc"] >= best_auc - tol]
-        chosen = candidates.loc[candidates["normalized_depth"].idxmin()]
-
-        selected[model_key] = {
-            "layer_index": int(chosen["layer_index"]),
-            "normalized_depth": float(chosen["normalized_depth"]),
-            "mean_auc": float(chosen["auc"]),
-            "best_auc": float(best_auc),
-            "all_depths": mean_by_depth.to_dict(orient="records"),
-        }
-        print(f"  {model_key}: selected layer {int(chosen['layer_index'])} "
-              f"(depth={chosen['normalized_depth']}, "
-              f"mean_auc={chosen['auc']:.4f}, best={best_auc:.4f})")
-
-    return selected
-
-
-def fit_probe_only(
-    X_train: np.ndarray, y_train: np.ndarray, cfg: dict,
-) -> tuple[LogisticRegression, StandardScaler, int]:
-    scaler = StandardScaler()
-    X_train_s = scaler.fit_transform(X_train)
-
-    probe = make_probe(cfg)
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        probe.fit(X_train_s, y_train)
-
-    for w in caught:
-        if issubclass(w.category, sklearn.exceptions.ConvergenceWarning):
-            raise RuntimeError(
-                f"Probe did not converge within max_iter={cfg['probe']['max_iter']}. "
-                f"Training samples={len(y_train)}, features={X_train.shape[1]}"
-            )
-
-    return probe, scaler, int(probe.n_iter_[0])
-
-
-def run_stage2(all_indexed: dict[str, pd.DataFrame], selected: dict,
-               acts_cache: dict, manifests: dict,
-               metrics_1a: pd.DataFrame, cfg: dict, cfg_h: str):
-    relations = RELATION_ORDER
-    metrics_rows = []
-    pred_rows = []
-    matrices = {}
-    probe_count = 0
-
-    for model_key, layer_info in selected.items():
-        li = layer_info["layer_index"]
-        depth = layer_info["normalized_depth"]
-        X_all = acts_cache[model_key][li]
-        data = all_indexed[model_key]
-
-        matrix = pd.DataFrame(index=relations, columns=relations, dtype=float)
-
-        s1a_at_layer = metrics_1a[
-            (metrics_1a["model_key"] == model_key) &
-            (metrics_1a["layer_index"] == li)
-        ]
-        for rel in relations:
-            rel_aucs = s1a_at_layer[s1a_at_layer["target_relation"] == rel]["auc"]
-            matrix.loc[rel, rel] = rel_aucs.mean()
-
-        for source_rel in relations:
-            source_data = data[data["relation_id"] == source_rel]
-            X_train = X_all[source_data["act_row"].values]
-            y_train = source_data["label"].values
-
-            probe, scaler, n_iter = fit_probe_only(X_train, y_train, cfg)
-
-            probe_id = f"s2_{model_key}_L{li}_src_{source_rel}"
-            train_eids = source_data["example_id"].tolist()
-
-            save_probe(probe, scaler, probe_id, {
-                "probe_id": probe_id,
-                "stage": "2",
-                "protocol": "transfer",
-                "model_id": MODELS[model_key]["model_id"],
-                "model_revision": "served via NDIF",
-                "layer_index": li,
-                "normalized_depth": depth,
-                "source_relations": [source_rel],
-                "target_relation": "all",
-                "fold": None,
-                "training_example_ids": train_eids,
-                "probe_configuration_hash": cfg_h,
-                "sklearn_version": sklearn.__version__,
-                "n_iter": n_iter,
-            })
-            probe_count += 1
-
-            for target_rel in relations:
-                if target_rel == source_rel:
-                    continue
-
-                target_data = data[data["relation_id"] == target_rel]
-                X_test = X_all[target_data["act_row"].values]
-                y_test = target_data["label"].values
-
-                X_test_s = scaler.transform(X_test)
-                scores = probe.predict_proba(X_test_s)[:, 1]
-                auc = roc_auc_score(y_test, scores)
-                preds = (scores >= 0.5).astype(int)
-                bal_acc = balanced_accuracy_score(y_test, preds)
-
-                matrix.loc[source_rel, target_rel] = auc
-
-                metrics_rows.append({
-                    "stage": "2",
-                    "model_id": MODELS[model_key]["model_id"],
-                    "model_key": model_key,
-                    "layer_index": li,
-                    "normalized_depth": depth,
-                    "protocol": "transfer",
-                    "source_relations": source_rel,
-                    "target_relation": target_rel,
-                    "fold": None,
-                    "auc": auc,
-                    "balanced_accuracy": bal_acc,
-                    "n_train": len(y_train),
-                    "n_test": len(y_test),
-                    "n_iter": n_iter,
-                })
-
-                for eid, true_label, score in zip(target_data["example_id"].values,
-                                                   y_test, scores):
-                    pred_rows.append({
-                        "stage": "2",
-                        "model_id": MODELS[model_key]["model_id"],
-                        "model_key": model_key,
-                        "layer_index": li,
-                        "normalized_depth": depth,
-                        "protocol": "transfer",
-                        "source_relations": source_rel,
-                        "target_relation": target_rel,
-                        "fold": None,
-                        "example_id": eid,
-                        "true_label": true_label,
-                        "prediction_score": float(score),
-                    })
-
-        matrices[model_key] = matrix
-        print(f"  Stage 2: {probe_count} source probes fitted for {model_key}")
-
-    return metrics_rows, pred_rows, matrices
-
-
-def main() -> None:
-    cfg = load_config()
-    cfg_h = config_hash(cfg)
-    print(f"Config hash: {cfg_h}")
-
-    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
-    WEIGHTS_DIR.mkdir(parents=True, exist_ok=True)
-
-    print("\nLoading data...")
-    data = load_data()
-    print(f"  {len(data)} N100 examples, {data['relation_id'].nunique()} relations")
-
-    all_metrics_1a = []
-    all_preds_1a = []
-    all_metrics_1b = []
-    all_preds_1b = []
-    acts_cache = {}
-    manifests = {}
-
-    for model_key in MODELS:
-        print(f"\n{'='*50}")
-        print(f"Model: {model_key}")
-        print(f"{'='*50}")
-
-        acts, sample_index = load_activations(model_key)
-        model_dir = ACT_DIR / model_key
-        with open(model_dir / "manifest.json") as f:
-            manifest = json.load(f)
-
-        indexed_data = build_activation_index(sample_index, data)
-        acts_cache[model_key] = acts
-        manifests[model_key] = manifest
-
-        m1a, p1a = run_stage1a(indexed_data, model_key, acts, manifest, cfg, cfg_h)
-        all_metrics_1a.extend(m1a)
-        all_preds_1a.extend(p1a)
-
-        m1b, p1b = run_stage1b(indexed_data, model_key, acts, manifest, cfg, cfg_h)
-        all_metrics_1b.extend(m1b)
-        all_preds_1b.extend(p1b)
-
-    metrics_1a_df = pd.DataFrame(all_metrics_1a)
-    metrics_1b_df = pd.DataFrame(all_metrics_1b)
-    preds_1a_df = pd.DataFrame(all_preds_1a)
-    preds_1b_df = pd.DataFrame(all_preds_1b)
-
-    print(f"\n{'='*50}")
-    print("Layer Selection")
-    print(f"{'='*50}")
-    selected = select_layers(metrics_1a_df, cfg)
-
-    with open(RESULTS_DIR / "selected_layers.json", "w") as f:
-        json.dump(selected, f, indent=2)
-
-    print(f"\n{'='*50}")
-    print("Stage 2: Transfer Matrices")
-    print(f"{'='*50}")
-
-    all_indexed = {}
-    for model_key in MODELS:
-        sample_index = pd.read_parquet(ACT_DIR / model_key / "sample_index.parquet")
-        all_indexed[model_key] = build_activation_index(sample_index, data)
-
-    m2, p2, matrices = run_stage2(
-        all_indexed, selected, acts_cache, manifests,
-        metrics_1a_df, cfg, cfg_h
-    )
-    metrics_2_df = pd.DataFrame(m2)
-    preds_2_df = pd.DataFrame(p2)
-
-    print(f"\n{'='*50}")
-    print("Saving results")
-    print(f"{'='*50}")
-
-    stage1_metrics = pd.concat([metrics_1a_df, metrics_1b_df], ignore_index=True)
-    stage1_metrics.to_csv(RESULTS_DIR / "stage1_metrics.csv", index=False)
-    print(f"  stage1_metrics.csv: {len(stage1_metrics)} rows (1A + 1B)")
-
-    metrics_2_df.to_csv(RESULTS_DIR / "stage2_metrics.csv", index=False)
-    print(f"  stage2_metrics.csv: {len(metrics_2_df)} rows")
-
-    stage1_preds = pd.concat([preds_1a_df, preds_1b_df], ignore_index=True)
-    stage1_preds.to_parquet(RESULTS_DIR / "stage1_predictions.parquet", index=False)
-    print(f"  Stage 1 predictions: {len(stage1_preds)} rows")
-
-    preds_2_df.to_parquet(RESULTS_DIR / "stage2_predictions.parquet", index=False)
-    print(f"  Stage 2 predictions: {len(preds_2_df)} rows (off-diagonal only)")
-
-    for model_key, matrix in matrices.items():
-        ordered_matrix = matrix.loc[RELATION_ORDER, RELATION_ORDER]
-        fname = f"stage2_matrix_{model_key.split('_')[-1]}.csv"
-        ordered_matrix.to_csv(RESULTS_DIR / fname)
-        print(f"  Transfer matrix: {fname}")
-        print(ordered_matrix.round(3).to_string())
-        print()
-
-    # --- Generality gap CSV ---
-    gap_rows = []
-    for model_key in MODELS:
-        for layer_info in manifests[model_key]["target_layers"]:
-            li = layer_info["layer_index"]
-            depth = layer_info["depth"]
-            for rel in RELATION_ORDER:
-                within_aucs = metrics_1a_df[
-                    (metrics_1a_df["model_key"] == model_key) &
-                    (metrics_1a_df["layer_index"] == li) &
-                    (metrics_1a_df["target_relation"] == rel)
-                ]["auc"]
-                mean_within = within_aucs.mean()
-                std_within = within_aucs.std()
-
-                loo_auc = metrics_1b_df[
-                    (metrics_1b_df["model_key"] == model_key) &
-                    (metrics_1b_df["layer_index"] == li) &
-                    (metrics_1b_df["target_relation"] == rel)
-                ]["auc"].values[0]
-
-                gap_rows.append({
-                    "model_key": model_key,
-                    "model_id": MODELS[model_key]["model_id"],
-                    "layer_index": li,
-                    "normalized_depth": depth,
-                    "target_relation": rel,
-                    "within_mean_auc": mean_within,
-                    "within_std_auc": std_within,
-                    "loo_auc": loo_auc,
-                    "generality_gap": mean_within - loo_auc,
-                })
-
-    gap_df = pd.DataFrame(gap_rows)
-    gap_df.to_csv(RESULTS_DIR / "generality_gap.csv", index=False)
-    print(f"  generality_gap.csv: {len(gap_df)} rows")
-
-    print(f"\n{'='*50}")
-    print("Generality Gap Summary")
-    print(f"{'='*50}")
-    for model_key in MODELS:
-        print(f"\n  {model_key}:")
-        for layer_info in manifests[model_key]["target_layers"]:
-            li = layer_info["layer_index"]
-            depth = layer_info["depth"]
-            model_gaps = gap_df[
-                (gap_df["model_key"] == model_key) &
-                (gap_df["layer_index"] == li)
-            ]
-            mean_abs_gap = model_gaps["generality_gap"].abs().mean()
-            print(f"    Layer {li} (depth={depth})  mean|gap|={mean_abs_gap:.4f}")
-            for _, row in model_gaps.iterrows():
-                print(f"      {row['target_relation']}: "
-                      f"within={row['within_mean_auc']:.3f}  "
-                      f"LOO={row['loo_auc']:.3f}  "
-                      f"gap={row['generality_gap']:+.3f}")
-
-    total_probes = len(all_metrics_1a) + len(all_metrics_1b) + len(m2)
-    print(f"\nTotal probes fitted: {total_probes}")
-    print(f"Probe weights saved to: {WEIGHTS_DIR}")
-    print("Done.")
-
-
-if __name__ == "__main__":
-    main()