Blame for analyses/plot_matrices.py

"""
Heatmap figures for the divsim paper.

Produces H-matrix, swap-stability, in-group self-preference, and Elo-rating
figures in three variants each: dyadic-only, triadic-only, combined.

Figures are written to OUTDIR (default: same directory as this script).

Configuration:
    RUNS_DIR   — directory containing sweep_*.db files (env var or --runs-dir)
    OUTDIR     — output directory for .png files (env var or --outdir)

Usage:
    python plot_matrices.py
    python plot_matrices.py --runs-dir /path/to/runs --outdir /path/to/figures
"""

import os
import glob
import json
import math
import sqlite3
import itertools
import argparse
from collections import defaultdict
from pathlib import Path

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.font_manager import FontProperties, fontManager


# ── Font loading ──────────────────────────────────────────────────────────────
# Looks for Volkhov and Ubuntu Mono in ~/fonts; falls back gracefully.
FONT_DIR = Path.home() / "fonts"
if FONT_DIR.is_dir():
    for ttf in FONT_DIR.rglob("*.ttf"):
        fontManager.addfont(str(ttf))


def fp(family, size, bold=False):
    return FontProperties(family=family, size=size,
                          weight="bold" if bold else "normal")


FT = lambda s, bold=False: fp("Volkhov",     s, bold)
FB = lambda s, bold=False: fp("Ubuntu Mono", s, bold)

plt.rcParams.update({
    "font.family":       "Ubuntu Mono",
    "axes.spines.top":   False,
    "axes.spines.right": False,
    "figure.dpi":        300,
})

SHORT = {
    "Qwen/Qwen3-32B":                 "Qwen",
    "openai/gpt-oss-20b":             "gpt-oss",
    "mistralai/Magistral-Small-2509": "Mag",
    "zai-org/GLM-4-32B-0414":         "GLM-4",
    "google/gemma-4-31B-it":          "Gemma",
}
MODELS    = ["GLM-4", "Mag", "Qwen", "gpt-oss", "Gemma"]
MODEL_SET = set(MODELS)


# ── H computation ──────────────────────────────────────────────────────────────

def load_h(db_path):
    """Compute directed pairwise H matrix for one run DB."""
    mp = str(db_path).replace(".db", ".metadata.json")
    if not os.path.exists(mp):
        return {}
    with open(mp) as f:
        meta = json.load(f)
    amm = meta.get("agent_model_map", {})
    if not amm:
        return {}
    uf = {int(k)+1: SHORT.get(v["model"], v["model"][:6]) for k, v in amm.items()}
    fc = defaultdict(int)
    for fam in uf.values():
        fc[fam] += 1
    ec = defaultdict(int)
    conn = sqlite3.connect(db_path)
    for cu, pu in conn.execute(
            "SELECT c.user_id, p.user_id FROM comment c "
            "JOIN post p ON c.post_id=p.post_id WHERE c.user_id!=p.user_id"):
        sf, df = uf.get(cu), uf.get(pu)
        if sf and df:
            ec[(sf, df)] += 1
    conn.close()
    total = sum(ec.values())
    if not total:
        return {}
    n = sum(fc.values())
    H = {}
    for s in fc:
        for d in fc:
            obs = ec.get((s, d), 0) / total
            exp = (fc[s]/n) * ((fc[d] - (1 if s == d else 0)) / (n-1))
            if exp > 0:
                H[(s, d)] = obs/exp - 1
    return H


# ── Load all valid dyadic runs ────────────────────────────────────────────────

def load_dyadic(runs_dir: Path):
    all_H     = defaultdict(list)
    swap_vals = defaultdict(lambda: defaultdict(list))
    for db in sorted(runs_dir.glob("sweep_*.db")):
        name = str(db)
        if any(x in name for x in ["archive", "snapshot", "sweep_tri_",
                                    "olm", "hermes", "qwq", "glm47"]):
            continue
        try:
            mp = name.replace(".db", ".metadata.json")
            if not os.path.exists(mp):
                continue
            with open(mp) as f:
                meta = json.load(f)
            amm  = meta.get("agent_model_map", {})
            fams = set(SHORT.get(v["model"], v["model"][:6]) for v in amm.values())
            if len(fams) != 2 or not fams.issubset(MODEL_SET):
                continue
            conn = sqlite3.connect(db)
            nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
            nc = conn.execute("SELECT COUNT(*) FROM comment").fetchone()[0]
            conn.close()
            if nu < 18 or nc < 200:
                continue
            H = load_h(db)
            seed     = str(db).split("_s")[-1].replace(".db", "")
            dyad_key = frozenset(fams)
            for pair, h in H.items():
                all_H[pair].append(h)
                swap_vals[pair][(dyad_key, seed)].append(h)
        except Exception:
            pass
    return all_H, swap_vals


def load_triadic(runs_dir: Path):
    all_H           = defaultdict(list)
    by_triplet_seed = defaultdict(list)
    for db in sorted(runs_dir.glob("sweep_tri_*.db")):
        if "archive" in str(db):
            continue
        try:
            conn = sqlite3.connect(db)
            nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
            conn.close()
            if nu < 26:
                continue
            mp = str(db).replace(".db", ".metadata.json")
            if not os.path.exists(mp):
                continue
            H = load_h(db)
            if not H:
                continue
            with open(mp) as f:
                meta = json.load(f)
            amm = meta.get("agent_model_map", {})
            run_models = frozenset(
                SHORT.get(v["model"], v["model"][:6]) for v in amm.values()
            )
            seed = str(db).split("_s")[-1].replace(".db", "")
            by_triplet_seed[(run_models, seed)].append(H)
            for pair, h in H.items():
                all_H[pair].append(h)
        except Exception:
            pass
    return all_H, by_triplet_seed


# ── Swap-stability matrices ───────────────────────────────────────────────────

def dyadic_swap_matrix(swap_vals, keys):
    """Mean |ΔH| across seeds for dyadic runs (exactly 2 orientations per seed)."""
    n    = len(keys)
    mean = np.full((n, n), np.nan)
    std  = np.full((n, n), np.nan)
    for i, s in enumerate(keys):
        for j, d in enumerate(keys):
            by_seed = swap_vals.get((s, d), {})
            diffs   = [abs(vs[0]-vs[1]) for vs in by_seed.values() if len(vs) == 2]
            if diffs:
                mean[i, j] = np.mean(diffs)
                std[i, j]  = np.std(diffs, ddof=1) if len(diffs) > 1 else 0.
    return mean, std


def triadic_swap_matrix(tri_by_ts, keys):
    """Mean max-|ΔH| per (triplet, seed) group for triadic runs (3 orderings)."""
    n             = len(keys)
    pair_maxdiffs = defaultdict(list)
    for (triplet, seed), h_list in tri_by_ts.items():
        if len(h_list) < 2:
            continue
        all_pairs = set()
        for H in h_list:
            all_pairs.update(H.keys())
        for pair in all_pairs:
            vals = [H.get(pair, np.nan) for H in h_list]
            vals = [v for v in vals if not np.isnan(v)]
            if len(vals) < 2:
                continue
            max_diff = max(abs(a-b) for a, b in itertools.combinations(vals, 2))
            pair_maxdiffs[pair].append(max_diff)
    mean = np.full((n, n), np.nan)
    std  = np.full((n, n), np.nan)
    for i, s in enumerate(keys):
        for j, d in enumerate(keys):
            diffs = pair_maxdiffs.get((s, d), [])
            if diffs:
                mean[i, j] = np.mean(diffs)
                std[i, j]  = np.std(diffs, ddof=1) if len(diffs) > 1 else 0.
    return mean, std


def combined_swap_matrix(swap_dy_mean, swap_dy_std, swap_tri_mean, swap_tri_std, keys):
    """Unweighted average of dyadic and triadic swap means where both exist."""
    n    = len(keys)
    mean = np.full((n, n), np.nan)
    std  = np.full((n, n), np.nan)
    for i in range(n):
        for j in range(n):
            vals = []
            if not np.isnan(swap_dy_mean[i, j]):
                vals.append(swap_dy_mean[i, j])
            if not np.isnan(swap_tri_mean[i, j]):
                vals.append(swap_tri_mean[i, j])
            if vals:
                mean[i, j] = np.mean(vals)
                std[i, j]  = np.std(vals, ddof=0) if len(vals) > 1 else 0.
    return mean, std


# ── Per-matrix statistics ─────────────────────────────────────────────────────

def mat_stats(H_dict, keys):
    n    = len(keys)
    mean = np.full((n, n), np.nan)
    std  = np.full((n, n), np.nan)
    for i, s in enumerate(keys):
        for j, d in enumerate(keys):
            vals = H_dict.get((s, d), [])
            if vals:
                mean[i, j] = np.mean(vals)
                std[i, j]  = np.std(vals, ddof=1) if len(vals) > 1 else 0.
    return mean, std


# ── Cell annotation helpers ───────────────────────────────────────────────────

def label_cells(ax, mean, std, swap_mean=None, swap_std=None,
                skip_diag=False,
                fs_main=32, fs_std=22, fs_swap=20, thresh=0.28):
    n = mean.shape[0]
    for i in range(n):
        for j in range(n):
            if skip_diag and i == j:
                continue
            if np.isnan(mean[i, j]):
                continue
            v       = mean[i, j]
            txt_col = "white" if abs(v) > thresh else "#1a1a1a"
            ax.text(j, i - 0.28, f"{v:+.3f}",
                    ha="center", va="center",
                    fontproperties=FB(fs_main, bold=True), color=txt_col)
            ax.text(j, i + 0.02, f"±{std[i, j]:.2f}",
                    ha="center", va="center",
                    fontproperties=FB(fs_std), color=txt_col, alpha=0.90)
            if swap_mean is not None and not np.isnan(swap_mean[i, j]):
                s_v  = swap_mean[i, j]
                s_sd = swap_std[i, j] if swap_std is not None and not np.isnan(swap_std[i, j]) else 0.
                ax.text(j, i + 0.32,
                        f"|ΔH|={s_v:.2f}±{s_sd:.2f}",
                        ha="center", va="center",
                        fontproperties=FB(fs_swap, bold=True),
                        color=txt_col, alpha=0.85)


def style_axes(ax, labels, title, cbar_im, vmax, cbar_label="H"):
    n = len(labels)
    ax.set_xticks(range(n))
    ax.set_yticks(range(n))
    ax.set_xticklabels(labels, fontproperties=FB(22, bold=True), rotation=0)
    ax.set_yticklabels(labels, fontproperties=FB(22, bold=True))
    ax.set_xlabel("target family  (post author)", fontproperties=FB(20), labelpad=12)
    ax.set_ylabel("source family  (commenter)",   fontproperties=FB(20), labelpad=12)
    ax.set_title(title, fontproperties=FT(26, bold=True), pad=18)
    cb = plt.colorbar(cbar_im, ax=ax, fraction=0.046, pad=0.04)
    cb.set_label(cbar_label, fontproperties=FB(20))
    for tick in cb.ax.get_yticklabels():
        tick.set_fontproperties(FB(16))


# ── Plot functions ────────────────────────────────────────────────────────────

def plot_h_matrix(H_dict, keys, title, outpath, cross_only=False,
                  swap_mean=None, swap_std=None):
    mean, std = mat_stats(H_dict, keys)
    if cross_only:
        np.fill_diagonal(mean, np.nan)
        np.fill_diagonal(std,  np.nan)
    vmax = np.nanmax(np.abs(mean)) * 1.08
    fig, ax = plt.subplots(figsize=(15.0, 12.5))
    im = ax.imshow(mean, cmap="RdBu_r", vmin=-vmax, vmax=vmax, aspect="equal")
    label_cells(ax, mean, std,
                swap_mean=swap_mean, swap_std=swap_std,
                skip_diag=cross_only)
    style_axes(ax, keys, title, im, vmax)
    plt.tight_layout()
    fig.savefig(outpath, dpi=300, bbox_inches="tight")
    plt.close(fig)
    print(f"saved {Path(outpath).name}")


def plot_swap(swap_mean, swap_std, keys, title, outpath):
    vmax = np.nanmax(swap_mean[~np.isnan(swap_mean)]) * 1.05
    fig, ax = plt.subplots(figsize=(7.5, 6.2))
    im = ax.imshow(swap_mean, cmap="YlOrRd", vmin=0, vmax=vmax, aspect="equal")
    n = len(keys)
    for i in range(n):
        for j in range(n):
            if np.isnan(swap_mean[i, j]):
                continue
            v       = swap_mean[i, j]
            txt_col = "white" if v > vmax * 0.65 else "#1a1a1a"
            ax.text(j, i - 0.14, f"{v:.3f}",
                    ha="center", va="center",
                    fontproperties=FB(18, bold=True), color=txt_col)
            ax.text(j, i + 0.26, f"±{swap_std[i, j]:.2f}",
                    ha="center", va="center",
                    fontproperties=FB(12), color=txt_col, alpha=0.80)
    ax.set_xticks(range(n))
    ax.set_yticks(range(n))
    ax.set_xticklabels(keys, fontproperties=FB(13, bold=True), rotation=0)
    ax.set_yticklabels(keys, fontproperties=FB(13, bold=True))
    ax.set_xlabel("target family", fontproperties=FB(11), labelpad=7)
    ax.set_ylabel("source family", fontproperties=FB(11), labelpad=7)
    ax.set_title(title, fontproperties=FT(16, bold=True), pad=12)
    cb = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
    cb.set_label(r"$|\Delta H|$", fontproperties=FB(11))
    for tick in cb.ax.get_yticklabels():
        tick.set_fontproperties(FB(10))
    plt.tight_layout()
    fig.savefig(outpath, dpi=300, bbox_inches="tight")
    plt.close(fig)
    print(f"saved {Path(outpath).name}")


def model_color(m):
    import colorsys
    full = {v: k for k, v in SHORT.items()}.get(m, m)
    h = 0
    for c in full:
        h = (h*31 + ord(c)) & 0xFFFFFFFF
        if h >= 0x80000000:
            h -= 0x100000000
    hue = abs(h) % 360
    r, g, b = colorsys.hls_to_rgb(hue/360, 0.45, 0.55)
    return "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))


def plot_self_pref(H_data, tag, label, outdir):
    self_vals = [H_data.get((m, m), []) for m in MODELS]
    self_m    = [np.mean(v) if v else np.nan for v in self_vals]
    self_s    = [np.std(v, ddof=1) if len(v) > 1 else 0. for v in self_vals]
    self_n    = [len(v) for v in self_vals]

    colors = []
    for v in self_m:
        if np.isnan(v):   colors.append("#aaa")
        elif v > 0:       colors.append("#c0392b")
        else:             colors.append("#2980b9")

    fig, ax = plt.subplots(figsize=(5.5, 4.0))
    xs = range(len(MODELS))
    ax.bar(xs, self_m, color=colors, alpha=0.85, width=0.6,
           edgecolor="white", linewidth=0.6)
    ax.errorbar(xs, self_m, yerr=self_s, fmt="none", color="#333",
                capsize=5, lw=1.5, capthick=1.5)
    ax.axhline(0, color="#555", lw=0.8)
    for x, m, s, n in zip(xs, self_m, self_s, self_n):
        if np.isnan(m):
            continue
        yoff = m + s + 0.02 if m >= 0 else m - s - 0.07
        va   = "bottom" if m >= 0 else "top"
        ax.text(x, yoff, f"n={n}", ha="center", va=va,
                fontproperties=FB(9), color="#555")
    ax.set_xticks(list(xs))
    ax.set_xticklabels(MODELS, fontproperties=FB(11, bold=True))
    ax.set_ylabel(r"$H_{X \to X}$  (in-group self-preference)", fontproperties=FB(10))
    ax.set_title(f"{label} in-group self-preference", fontproperties=FT(14, bold=True), pad=10)
    plt.tight_layout()
    outpath = outdir / f"fig_self_pref_{tag}.png"
    fig.savefig(outpath, dpi=300, bbox_inches="tight")
    plt.close(fig)
    print(f"saved {outpath.name}")


def plot_elo(all_H_dy, outdir):
    """Elo rating from dyadic H-matrix net-attractor advantage."""
    matches = []
    for pair, vals in all_H_dy.items():
        if pair[0] == pair[1]:
            continue
        x, y = pair[0], pair[1]
        h_xy = np.mean(vals) if vals else 0
        rev_pair = (y, x)
        h_yx = np.mean(all_H_dy.get(rev_pair, [0]))
        net_x = h_yx - h_xy
        matches.append((x, y, net_x))

    elo = defaultdict(lambda: 1200.0)
    K   = 32
    for x, y, net in matches:
        exp_x = 1 / (1 + 10**((elo[y]-elo[x])/400))
        sx    = 1 / (1 + math.exp(-net/0.5))
        elo[x] += K * (sx - exp_x)
        elo[y] += K * ((1-sx) - (1-exp_x))

    elo_items  = sorted(elo.items(), key=lambda kv: -kv[1])
    elo_models = [k for k, v in elo_items]
    elo_vals   = [v for k, v in elo_items]
    cols       = [model_color(m) for m in elo_models]

    fig, ax = plt.subplots(figsize=(5.5, 4.0))
    ax.bar(range(len(elo_models)), elo_vals, color=cols, alpha=0.88,
           width=0.6, edgecolor="white", linewidth=0.6)
    ax.axhline(1200, color="#888", lw=0.8, ls="--", alpha=0.6)
    for x, v, m in zip(range(len(elo_models)), elo_vals, elo_models):
        ax.text(x, v+4, f"{v:.0f}", ha="center", va="bottom",
                fontproperties=FB(10, bold=True), color="#222")
    ax.set_xticks(list(range(len(elo_models))))
    ax.set_xticklabels(elo_models, fontproperties=FB(11, bold=True))
    ax.set_ylabel("Elo rating", fontproperties=FB(10))
    ax.set_title("Elo ranking  (net attractor advantage, dyadic)",
                 fontproperties=FT(14, bold=True), pad=10)
    plt.tight_layout()
    fig.savefig(outdir / "fig_elo.png", dpi=300, bbox_inches="tight")
    plt.close(fig)
    print("saved fig_elo.png")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--runs-dir", default=os.environ.get("RUNS_DIR", "./runs"),
                        help="Directory containing sweep_*.db files.")
    parser.add_argument("--outdir",   default=os.environ.get("OUTDIR", str(Path(__file__).parent)),
                        help="Output directory for figures.")
    args = parser.parse_args()

    runs_dir = Path(args.runs_dir)
    outdir   = Path(args.outdir)
    outdir.mkdir(parents=True, exist_ok=True)

    print(f"Loading dyadic runs from {runs_dir}...")
    all_H_dy, swap_vals_dy = load_dyadic(runs_dir)

    print(f"Loading triadic runs from {runs_dir}...")
    all_H_tri, tri_by_ts = load_triadic(runs_dir)

    all_H_combined = defaultdict(list)
    for pair, vals in all_H_dy.items():
        all_H_combined[pair].extend(vals)
    for pair, vals in all_H_tri.items():
        all_H_combined[pair].extend(vals)

    swap_dy_mean,   swap_dy_std   = dyadic_swap_matrix(swap_vals_dy, MODELS)
    swap_tri_mean,  swap_tri_std  = triadic_swap_matrix(tri_by_ts, MODELS)
    swap_comb_mean, swap_comb_std = combined_swap_matrix(
        swap_dy_mean, swap_dy_std, swap_tri_mean, swap_tri_std, MODELS)

    datasets = [
        ("dyadic",   all_H_dy,       swap_dy_mean,   swap_dy_std),
        ("triadic",  all_H_tri,      swap_tri_mean,  swap_tri_std),
        ("combined", all_H_combined, swap_comb_mean, swap_comb_std),
    ]

    for tag, H_data, sw_mean, sw_std in datasets:
        label = {"dyadic": "Dyadic", "triadic": "Triadic", "combined": "Combined"}[tag]

        plot_h_matrix(
            H_data, MODELS,
            rf"{label} directed engagement homophily  $H_{{X \to Y}}$",
            outdir / f"fig_h_matrix_{tag}.png",
            swap_mean=sw_mean, swap_std=sw_std,
        )
        plot_h_matrix(
            H_data, MODELS,
            rf"{label} cross-group homophily  $H_{{X \to Y}}$,  $X \neq Y$",
            outdir / f"fig_h_matrix_cross_{tag}.png",
            cross_only=True,
            swap_mean=sw_mean, swap_std=sw_std,
        )

        swap_title = {
            "dyadic":   r"Dyadic swap instability:  mean $|H_{AB} - H_{BA}|$",
            "triadic":  r"Triadic ordering instability:  mean max-$|\Delta H|$",
            "combined": r"Ordering instability:  mean max-$|\Delta H|$  (pooled)",
        }[tag]
        plot_swap(sw_mean, sw_std, MODELS, swap_title,
                  outdir / f"fig_swap_stability_{tag}.png")

        plot_self_pref(H_data, tag, label, outdir)

    plot_elo(all_H_dy, outdir)

    print(f"\nAll figures written to {outdir}")


if __name__ == "__main__":
    main()