| """ |
| 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_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) |
|
|
|
|
| |
|
|
| 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 |
|
|
|
|
| |
|
|
| 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 |
|
|
|
|
| |
|
|
| 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 |
|
|
|
|
| |
|
|
| 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 |
|
|
|
|
| |
|
|
| 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)) |
|
|
|
|
| |
|
|
| 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() |
|
|
