swap_analysis/pca_all_layers.py

"""
pca_all_layers.py — Generate 2D and 3D PCA plots for ALL layers from existing NPZ files.

For each results/{model}/npz/vectors_{scale}.npz, produces:
  results/{model}/plots/all/pca/pca_{scale}_L{layer}.png      (2D, 3-panel)
  results/{model}/plots/all/pca_3d/pca_{scale}_L{layer}.png   (3D, 3-panel)

for every layer stored in the NPZ.

NOTE: NPZ files must have all layers saved. If you only see 5 representative layers in
existing results, re-run the main pipeline — save_vectors_npz() now saves all layers.

Usage:
    python pca_all_layers.py                             # all models, all scales
    python pca_all_layers.py --model qwen                # one model, all scales
    python pca_all_layers.py --model qwen --scale vanilla  # one model, one scale
    python pca_all_layers.py --overwrite                 # regenerate existing plots
"""

import argparse
import os
import re

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
import numpy as np
from sklearn.decomposition import PCA

# ---------------------------------------------------------------------------
# Constants
# ---------------------------------------------------------------------------

RESULTS_DIR = os.path.join(os.path.dirname(__file__), 'results')

CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close']
GROUP_ORDER    = ['horizontal', 'vertical', 'distance']

CAT_COLORS = {
    'left':  '#ff7f0e', 'right':  '#ffbb78',   # horizontal → orange
    'above': '#2ca02c', 'under':  '#98df8a',   # vertical   → green
    'far':   '#9467bd', 'close':  '#c5b0d5',   # distance   → purple
}
GROUP_COLORS = {
    'horizontal': '#ff7f0e',
    'vertical':   '#2ca02c',
    'distance':   '#9467bd',
}


# ---------------------------------------------------------------------------
# 2D PCA
# ---------------------------------------------------------------------------

def _plot_2d(data, layer, scale, model, save_path):
    orig   = data.get(f'orig_L{layer}')
    swap   = data.get(f'swap_L{layer}')
    labels = data.get(f'labels_L{layer}')
    deltas = data.get(f'delta_L{layer}')
    cats   = data.get(f'categories_L{layer}')
    groups = data.get(f'groups_L{layer}')

    if orig is None or swap is None:
        return False

    fig, axes = plt.subplots(1, 3, figsize=(24, 7))

    # ── Panel 1: embeddings ───────────────────────────────────────────────
    pca_emb = PCA(n_components=2)
    all_proj = pca_emb.fit_transform(np.vstack([orig, swap]))
    orig_proj = all_proj[:len(orig)]
    swap_proj = all_proj[len(orig):]
    ev = pca_emb.explained_variance_ratio_

    ax = axes[0]
    for cat in CATEGORY_ORDER:
        mask = np.array([str(l) == cat for l in labels])
        if mask.any():
            ax.scatter(orig_proj[mask, 0], orig_proj[mask, 1],
                       c=CAT_COLORS.get(cat, 'gray'), label=f'{cat} (orig)',
                       alpha=0.5, s=15, marker='o')
            ax.scatter(swap_proj[mask, 0], swap_proj[mask, 1],
                       c=CAT_COLORS.get(cat, 'gray'),
                       alpha=0.5, s=15, marker='x')
    ax.set_title('Embeddings by Category\n(o=orig, x=swap)', fontsize=11)
    ax.set_xlabel(f'PC1 ({ev[0]:.1%})', fontsize=9)
    ax.set_ylabel(f'PC2 ({ev[1]:.1%})', fontsize=9)
    ax.legend(fontsize=7, ncol=2)
    ax.grid(True, alpha=0.2)

    # ── Panels 2+3: delta vectors ─────────────────────────────────────────
    has_delta = deltas is not None and cats is not None and len(deltas) >= 2
    if has_delta:
        pca_d = PCA(n_components=2)
        delta_proj = pca_d.fit_transform(deltas)
        ev_d = pca_d.explained_variance_ratio_

    ax = axes[1]
    if has_delta and groups is not None:
        for group in GROUP_ORDER:
            mask = np.array([str(g) == group for g in groups])
            if mask.any():
                ax.scatter(delta_proj[mask, 0], delta_proj[mask, 1],
                           c=GROUP_COLORS.get(group, 'gray'), label=group,
                           alpha=0.5, s=15)
        ax.set_title('Delta Vectors by Group', fontsize=11)
        ax.set_xlabel(f'PC1 ({ev_d[0]:.1%})', fontsize=9)
        ax.set_ylabel(f'PC2 ({ev_d[1]:.1%})', fontsize=9)
        ax.legend(fontsize=9)
        ax.grid(True, alpha=0.2)
    else:
        ax.set_title('Delta Vectors by Group\n(no data)', fontsize=11)

    ax = axes[2]
    if has_delta and cats is not None:
        for cat in CATEGORY_ORDER:
            mask = np.array([str(c) == cat for c in cats])
            if mask.any():
                ax.scatter(delta_proj[mask, 0], delta_proj[mask, 1],
                           c=CAT_COLORS.get(cat, 'gray'), label=cat,
                           alpha=0.5, s=15)
        ax.set_title('Delta Vectors by Category', fontsize=11)
        ax.set_xlabel(f'PC1 ({ev_d[0]:.1%})', fontsize=9)
        ax.set_ylabel(f'PC2 ({ev_d[1]:.1%})', fontsize=9)
        ax.legend(fontsize=8, ncol=2)
        ax.grid(True, alpha=0.2)
    else:
        ax.set_title('Delta Vectors by Category\n(no data)', fontsize=11)

    fig.suptitle(f'{model.upper()} ({scale}) — Layer {layer} — 2D PCA', fontweight='bold')
    plt.tight_layout()
    plt.savefig(save_path, dpi=200, bbox_inches='tight')
    plt.close()
    return True


# ---------------------------------------------------------------------------
# 3D PCA
# ---------------------------------------------------------------------------

def _plot_3d(data, layer, scale, model, save_path):
    orig   = data.get(f'orig_L{layer}')
    swap   = data.get(f'swap_L{layer}')
    labels = data.get(f'labels_L{layer}')
    deltas = data.get(f'delta_L{layer}')
    cats   = data.get(f'categories_L{layer}')
    groups = data.get(f'groups_L{layer}')

    if orig is None or swap is None:
        return False

    fig = plt.figure(figsize=(30, 8))

    # ── Panel 1: embeddings ───────────────────────────────────────────────
    pca_emb = PCA(n_components=3)
    all_proj = pca_emb.fit_transform(np.vstack([orig, swap]))
    orig_proj = all_proj[:len(orig)]
    swap_proj = all_proj[len(orig):]
    ev1 = pca_emb.explained_variance_ratio_

    ax1 = fig.add_subplot(131, projection='3d')
    for cat in CATEGORY_ORDER:
        mask = np.array([str(l) == cat for l in labels])
        if mask.any():
            ax1.scatter(orig_proj[mask, 0], orig_proj[mask, 1], orig_proj[mask, 2],
                        c=CAT_COLORS.get(cat, 'gray'), label=f'{cat} (orig)',
                        alpha=0.45, s=12, marker='o')
            ax1.scatter(swap_proj[mask, 0], swap_proj[mask, 1], swap_proj[mask, 2],
                        c=CAT_COLORS.get(cat, 'gray'), label=f'{cat} (swap)',
                        alpha=0.45, s=12, marker='^')
    ax1.set_title('Embeddings by Category\n(o=orig, ^=swap)', fontsize=10)
    ax1.set_xlabel(f'PC1 ({ev1[0]:.1%})', fontsize=8)
    ax1.set_ylabel(f'PC2 ({ev1[1]:.1%})', fontsize=8)
    ax1.set_zlabel(f'PC3 ({ev1[2]:.1%})', fontsize=8)
    ax1.legend(fontsize=6, ncol=2, loc='upper left')

    # ── Panels 2+3: delta vectors ─────────────────────────────────────────
    has_delta = deltas is not None and len(deltas) >= 3
    if has_delta:
        pca_d = PCA(n_components=3)
        delta_proj = pca_d.fit_transform(deltas)
        ev2 = pca_d.explained_variance_ratio_
    else:
        delta_proj = None
        ev2 = None

    ax2 = fig.add_subplot(132, projection='3d')
    if has_delta and groups is not None:
        for group in GROUP_ORDER:
            mask = np.array([str(g) == group for g in groups])
            if mask.any():
                ax2.scatter(delta_proj[mask, 0], delta_proj[mask, 1], delta_proj[mask, 2],
                            c=GROUP_COLORS.get(group, 'gray'), label=group,
                            alpha=0.45, s=12)
        ax2.set_title('Delta Vectors by Group', fontsize=10)
        ax2.set_xlabel(f'PC1 ({ev2[0]:.1%})', fontsize=8)
        ax2.set_ylabel(f'PC2 ({ev2[1]:.1%})', fontsize=8)
        ax2.set_zlabel(f'PC3 ({ev2[2]:.1%})', fontsize=8)
        ax2.legend(fontsize=8)
    else:
        ax2.set_title('Delta Vectors by Group\n(no data)', fontsize=10)

    ax3 = fig.add_subplot(133, projection='3d')
    if has_delta and cats is not None:
        for cat in CATEGORY_ORDER:
            mask = np.array([str(c) == cat for c in cats])
            if mask.any():
                ax3.scatter(delta_proj[mask, 0], delta_proj[mask, 1], delta_proj[mask, 2],
                            c=CAT_COLORS.get(cat, 'gray'), label=cat,
                            alpha=0.45, s=12)
        ax3.set_title('Delta Vectors by Category', fontsize=10)
        ax3.set_xlabel(f'PC1 ({ev2[0]:.1%})', fontsize=8)
        ax3.set_ylabel(f'PC2 ({ev2[1]:.1%})', fontsize=8)
        ax3.set_zlabel(f'PC3 ({ev2[2]:.1%})', fontsize=8)
        ax3.legend(fontsize=7, ncol=2)
    else:
        ax3.set_title('Delta Vectors by Category\n(no data)', fontsize=10)

    fig.suptitle(f'{model.upper()} ({scale}) — Layer {layer} — 3D PCA', fontweight='bold')
    plt.tight_layout()
    plt.savefig(save_path, dpi=200, bbox_inches='tight', pad_inches=0.4)
    plt.close()
    return True


# ---------------------------------------------------------------------------
# Per-NPZ processing
# ---------------------------------------------------------------------------

def process_npz(npz_path, scale, model, plots_all_dir, overwrite=False):
    data = np.load(npz_path, allow_pickle=True)
    layer_keys = [k for k in data.files if k.startswith('orig_L')]
    layers = sorted([int(k.replace('orig_L', '')) for k in layer_keys])

    if not layers:
        print(f'  [skip] No orig_L* keys in {npz_path}')
        return 0

    print(f'  [{model}] {scale}: {len(layers)} layers (L{layers[0]}–L{layers[-1]})')

    pca_2d_dir = os.path.join(plots_all_dir, 'pca')
    pca_3d_dir = os.path.join(plots_all_dir, 'pca_3d')
    os.makedirs(pca_2d_dir, exist_ok=True)
    os.makedirs(pca_3d_dir, exist_ok=True)

    saved = 0
    for i, layer in enumerate(layers):
        path_2d = os.path.join(pca_2d_dir, f'pca_{scale}_L{layer}.png')
        path_3d = os.path.join(pca_3d_dir, f'pca_{scale}_L{layer}.png')

        skip_2d = not overwrite and os.path.exists(path_2d)
        skip_3d = not overwrite and os.path.exists(path_3d)

        if skip_2d and skip_3d:
            continue

        print(f'  L{layer:>3} ({i+1}/{len(layers)})', end='\r', flush=True)

        if not skip_2d:
            if _plot_2d(data, layer, scale, model, path_2d):
                saved += 1

        if not skip_3d:
            if _plot_3d(data, layer, scale, model, path_3d):
                saved += 1

    print()  # newline after progress
    return saved


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def scale_from_name(filename):
    m = re.match(r'vectors_(.+)\.npz$', filename)
    return m.group(1) if m else None


def main():
    parser = argparse.ArgumentParser(
        description='Generate 2D+3D PCA plots for all layers from NPZ files')
    parser.add_argument('--model',
                        help='Restrict to this model directory (e.g. qwen)')
    parser.add_argument('--scale',
                        help='Restrict to this scale (e.g. vanilla, 80k)')
    parser.add_argument('--overwrite', action='store_true',
                        help='Regenerate plots even if they already exist')
    parser.add_argument('--results-dir', default=RESULTS_DIR,
                        help='Path to results/ directory')
    args = parser.parse_args()

    results_dir = args.results_dir
    if not os.path.isdir(results_dir):
        print(f'Results directory not found: {results_dir}')
        return

    model_dirs = sorted(
        m for m in os.listdir(results_dir)
        if os.path.isdir(os.path.join(results_dir, m))
    )
    if args.model:
        model_dirs = [m for m in model_dirs if m == args.model]
        if not model_dirs:
            print(f"Model '{args.model}' not found in {results_dir}")
            return

    total_saved = 0
    total_npz   = 0

    for model in model_dirs:
        model_dir    = os.path.join(results_dir, model)
        npz_dir      = os.path.join(model_dir, 'npz')
        plots_all_dir = os.path.join(model_dir, 'plots', 'all')

        if not os.path.isdir(npz_dir):
            print(f'[{model}] no npz/ directory, skipping')
            continue

        npz_files = sorted(
            f for f in os.listdir(npz_dir)
            if f.startswith('vectors_') and f.endswith('.npz')
        )
        if args.scale:
            npz_files = [f for f in npz_files if scale_from_name(f) == args.scale]
        if not npz_files:
            print(f'[{model}] no matching NPZ files, skipping')
            continue

        for npz_file in npz_files:
            scale = scale_from_name(npz_file)
            if scale is None:
                continue
            npz_path = os.path.join(npz_dir, npz_file)
            os.makedirs(plots_all_dir, exist_ok=True)
            n = process_npz(npz_path, scale, model, plots_all_dir, overwrite=args.overwrite)
            total_saved += n
            total_npz   += 1

    print(f'\nDone. Processed {total_npz} NPZ file(s), saved {total_saved} plots.')


if __name__ == '__main__':
    main()