code/_killer_experiment.py

"""
Killer Experiment: Discrete vs Continuous Bottleneck Head-to-Head
=================================================================
Three arms, same features, same task, same receiver:
  Arm 1: Gumbel-Softmax discrete bottleneck (WMCP)
  Arm 2: Continuous MLP bottleneck (same dim)
  Arm 3: Raw features linear probe (no bottleneck)

10 seeds × 3 arms × 2 backbones = 60 runs.

Run:
  PYTHONUNBUFFERED=1 PYTORCH_ENABLE_MPS_FALLBACK=1 python3 _killer_experiment.py
"""

import time, json, math, os, sys
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from pathlib import Path
from collections import defaultdict
from scipy import stats

DEVICE = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
RESULTS_DIR = Path("results/killer_experiment")
RESULTS_DIR.mkdir(parents=True, exist_ok=True)

# Locked config
HIDDEN_DIM = 128
VOCAB_SIZE = 5
N_HEADS = 2
N_AGENTS = 4
MSG_DIM = N_AGENTS * N_HEADS * VOCAB_SIZE  # 40
CONT_DIM = 40  # Same dimensionality for continuous arm
COMM_EPOCHS = 400
BATCH_SIZE = 32
SENDER_LR = 1e-3
RECEIVER_LR = 3e-3
EARLY_STOP = 150
N_SEEDS = 10


# ═══ Shared components ═══

class TemporalEncoder(nn.Module):
    def __init__(self, hd=128, ind=1024, nf=4):
        super().__init__()
        ks = min(3, max(1, nf))
        self.temporal = nn.Sequential(
            nn.Conv1d(ind, 256, ks, padding=ks//2), nn.ReLU(),
            nn.Conv1d(256, 128, ks, padding=ks//2), nn.ReLU(),
            nn.AdaptiveAvgPool1d(1))
        self.fc = nn.Sequential(nn.Linear(128, hd), nn.ReLU())
    def forward(self, x):
        return self.fc(self.temporal(x.permute(0, 2, 1)).squeeze(-1))


# ═══ ARM 1: Discrete (WMCP) ═══

class DiscreteSender(nn.Module):
    def __init__(self, encoder, hd, vs, nh):
        super().__init__()
        self.encoder = encoder; self.vs = vs; self.nh = nh
        self.heads = nn.ModuleList([nn.Linear(hd, vs) for _ in range(nh)])

    def forward(self, x, tau=1.0, hard=True):
        h = self.encoder(x)
        msgs, logits_all = [], []
        for head in self.heads:
            logits = head(h)
            if self.training:
                msg = F.gumbel_softmax(logits, tau=tau, hard=hard)
            else:
                msg = F.one_hot(logits.argmax(-1), self.vs).float()
            msgs.append(msg); logits_all.append(logits)
        return torch.cat(msgs, -1), logits_all


class DiscreteMultiSender(nn.Module):
    def __init__(self, senders):
        super().__init__(); self.senders = nn.ModuleList(senders)
    def forward(self, views, tau=1.0, hard=True):
        msgs, all_logits = [], []
        for s, v in zip(self.senders, views):
            m, l = s(v, tau, hard); msgs.append(m); all_logits.extend(l)
        return torch.cat(msgs, -1), all_logits


# ═══ ARM 2: Continuous ═══

class ContinuousSender(nn.Module):
    """Same architecture but outputs continuous vectors instead of discrete tokens."""
    def __init__(self, encoder, hd, out_dim_per_agent):
        super().__init__()
        self.encoder = encoder
        self.proj = nn.Sequential(
            nn.Linear(hd, out_dim_per_agent),
            nn.Tanh(),  # Bounded like one-hot but continuous
        )

    def forward(self, x, tau=None, hard=None):
        h = self.encoder(x)
        msg = self.proj(h)
        return msg, []  # No logits for continuous


class ContinuousMultiSender(nn.Module):
    def __init__(self, senders):
        super().__init__(); self.senders = nn.ModuleList(senders)
    def forward(self, views, tau=None, hard=None):
        msgs = [s(v)[0] for s, v in zip(self.senders, views)]
        return torch.cat(msgs, -1), []


# ═══ ARM 3: Raw features (linear probe) ═══

class RawFeatureProbe(nn.Module):
    """Concatenate raw agent features, linear probe to prediction."""
    def __init__(self, feat_dim, n_agents, n_frames_per_agent):
        super().__init__()
        self.pool = nn.AdaptiveAvgPool1d(1)
        total_dim = feat_dim * n_agents
        self.proj = nn.Sequential(
            nn.Linear(total_dim, HIDDEN_DIM), nn.ReLU(),
            nn.Linear(HIDDEN_DIM, 40),  # Same dim as bottleneck for fair comparison
        )

    def forward(self, views, tau=None, hard=None):
        pooled = []
        for v in views:
            # v: [B, T, D] -> pool over T
            p = v.mean(dim=1)  # [B, D]
            pooled.append(p)
        cat = torch.cat(pooled, -1)  # [B, D*n_agents]
        return self.proj(cat), []


# ═══ Shared receiver ═══

class Receiver(nn.Module):
    def __init__(self, msg_dim, hd):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(msg_dim * 2, hd), nn.ReLU(),
            nn.Linear(hd, hd // 2), nn.ReLU(),
            nn.Linear(hd // 2, 1))
    def forward(self, a, b):
        return self.net(torch.cat([a, b], -1)).squeeze(-1)


# ═══ Metrics ═══

def mutual_information(x, y):
    xv, yv = np.unique(x), np.unique(y)
    n = len(x); mi = 0.0
    for a in xv:
        for b in yv:
            pxy = np.sum((x==a)&(y==b))/n; px = np.sum(x==a)/n; py = np.sum(y==b)/n
            if pxy>0 and px>0 and py>0: mi += pxy*np.log(pxy/(px*py))
    return mi

def positional_disentanglement(tokens, attrs, vs):
    np_, na = tokens.shape[1], attrs.shape[1]
    mi = np.zeros((np_, na)); ents = []
    for p in range(np_):
        for a in range(na): mi[p,a] = mutual_information(tokens[:,p], attrs[:,a])
        c = np.bincount(tokens[:,p], minlength=vs); pr = c/c.sum(); pr = pr[pr>0]
        ents.append(float(-np.sum(pr*np.log(pr))/max(np.log(vs),1e-10)))
    if np_>=2:
        pd = 0.0
        for p in range(np_):
            s = np.sort(mi[p])[::-1]
            if s[0]>1e-10: pd += (s[0]-s[1])/s[0]
        pd /= np_
    else: pd = 0.0
    return float(pd), mi, ents

def continuous_disentanglement(embeddings, attrs):
    """PosDis analog for continuous vectors: bin each dimension, compute MI."""
    n, d = embeddings.shape
    n_bins = 5  # Bin continuous dims into 5 levels like discrete vocab
    binned = np.zeros((n, d), dtype=int)
    for dim in range(d):
        try:
            q = np.quantile(embeddings[:, dim], [0.2, 0.4, 0.6, 0.8])
            binned[:, dim] = np.digitize(embeddings[:, dim], q)
        except:
            binned[:, dim] = 0
    return positional_disentanglement(binned, attrs, n_bins)

def causal_specificity(sender, agent_views, mass_values, receiver, n_positions, is_discrete=True):
    """Zero each position, measure per-property accuracy drop."""
    sender.eval(); receiver.eval()
    n = len(agent_views[0])
    mass_dev = torch.tensor(mass_values, dtype=torch.float32).to(DEVICE)

    # Baseline accuracy
    with torch.no_grad():
        msgs_all = []
        for i in range(0, n, BATCH_SIZE):
            vs = [v[i:i+BATCH_SIZE].to(DEVICE) for v in agent_views]
            m, _ = sender(vs)
            msgs_all.append(m.cpu())
        msgs_all = torch.cat(msgs_all, 0)

    # Evaluate baseline
    def eval_acc(msgs_tensor):
        correct = total = 0
        rng = np.random.RandomState(999)
        for _ in range(50):
            ia = rng.choice(n, min(32, n)); ib = rng.choice(n, min(32, n))
            s = ia == ib
            while s.any(): ib[s] = rng.choice(n, s.sum()); s = ia == ib
            md = np.abs(mass_values[ia] - mass_values[ib])
            k = md > 0.5
            if k.sum() < 2: continue
            ia, ib = ia[k], ib[k]
            with torch.no_grad():
                ma = msgs_tensor[ia].to(DEVICE); mb = msgs_tensor[ib].to(DEVICE)
                pred = receiver(ma, mb) > 0
                label = mass_dev[ia] > mass_dev[ib]
                correct += (pred == label).sum().item(); total += len(label)
        return correct / max(total, 1)

    baseline_acc = eval_acc(msgs_all)

    # Zero each position
    drops = []
    for pos in range(n_positions):
        ablated = msgs_all.clone()
        if is_discrete:
            # Zero out the one-hot block for this position
            start = pos * VOCAB_SIZE
            ablated[:, start:start + VOCAB_SIZE] = 0
        else:
            ablated[:, pos] = 0
        abl_acc = eval_acc(ablated)
        drops.append(baseline_acc - abl_acc)

    # Causal specificity = mean of (max_drop - mean_other_drops) / max_drop per position
    if len(drops) >= 2:
        specificity = []
        for i in range(len(drops)):
            others = [drops[j] for j in range(len(drops)) if j != i]
            if drops[i] > 0.01:
                specificity.append((drops[i] - np.mean(others)) / drops[i])
            else:
                specificity.append(0.0)
        return float(np.mean(specificity)), drops, baseline_acc
    return 0.0, drops, baseline_acc


# ═══ Training loop ═══

def train_arm(arm_name, sender, agent_views, mass_values, obj_names, seed, msg_dim=40):
    """Train one arm. Returns metrics dict."""
    n = len(agent_views[0])
    rng = np.random.RandomState(seed * 1000 + 42)
    unique_objs = sorted(set(obj_names))
    holdout_objs = set(rng.choice(unique_objs, max(4, len(unique_objs)//5), replace=False))
    tr = np.array([i for i, o in enumerate(obj_names) if o not in holdout_objs])
    ho = np.array([i for i, o in enumerate(obj_names) if o in holdout_objs])
    if len(ho) < 4: return None

    torch.manual_seed(seed); np.random.seed(seed)
    sender = sender.to(DEVICE)
    receivers = [Receiver(msg_dim, HIDDEN_DIM).to(DEVICE) for _ in range(3)]
    so = torch.optim.Adam(sender.parameters(), lr=SENDER_LR)
    ros = [torch.optim.Adam(r.parameters(), lr=RECEIVER_LR) for r in receivers]
    mass_dev = torch.tensor(mass_values, dtype=torch.float32).to(DEVICE)
    max_ent = math.log(VOCAB_SIZE)
    nb = max(1, len(tr) // BATCH_SIZE)
    best_acc, best_state, best_ep = 0.0, None, 0
    t0 = time.time()
    is_discrete = arm_name == "discrete"

    for ep in range(COMM_EPOCHS):
        if time.time() - t0 > 600: break
        if ep - best_ep > EARLY_STOP and best_acc > 0.55: break
        if ep > 0 and ep % 40 == 0:
            for i in range(len(receivers)):
                receivers[i] = Receiver(msg_dim, HIDDEN_DIM).to(DEVICE)
                ros[i] = torch.optim.Adam(receivers[i].parameters(), lr=RECEIVER_LR)

        sender.train(); [r.train() for r in receivers]
        tau = 3.0 + (1.0 - 3.0) * ep / max(1, COMM_EPOCHS - 1)
        hard = ep >= 30

        for _ in range(nb):
            ia = rng.choice(tr, BATCH_SIZE); ib = rng.choice(tr, BATCH_SIZE)
            s = ia == ib
            while s.any(): ib[s] = rng.choice(tr, s.sum()); s = ia == ib
            md = np.abs(mass_values[ia] - mass_values[ib]); k = md > 0.5
            if k.sum() < 4: continue
            ia, ib = ia[k], ib[k]
            va = [v[ia].to(DEVICE) for v in agent_views]
            vb = [v[ib].to(DEVICE) for v in agent_views]
            label = (mass_dev[ia] > mass_dev[ib]).float()

            if is_discrete:
                ma, la = sender(va, tau=tau, hard=hard)
                mb, lb = sender(vb, tau=tau, hard=hard)
            else:
                ma, la = sender(va)
                mb, lb = sender(vb)

            loss = sum(F.binary_cross_entropy_with_logits(r(ma, mb), label) for r in receivers) / len(receivers)

            # Entropy reg only for discrete
            if is_discrete and la:
                for lg in la + lb:
                    lp = F.log_softmax(lg, -1); p = lp.exp().clamp(min=1e-8)
                    ent = -(p * lp).sum(-1).mean()
                    if ent / max_ent < 0.1: loss = loss - 0.03 * ent

            if torch.isnan(loss): so.zero_grad(); [o.zero_grad() for o in ros]; continue
            so.zero_grad(); [o.zero_grad() for o in ros]; loss.backward()
            torch.nn.utils.clip_grad_norm_(sender.parameters(), 1.0)
            so.step(); [o.step() for o in ros]

        if ep % 50 == 0: torch.mps.empty_cache()
        if (ep+1) % 50 == 0 or ep == 0:
            sender.eval(); [r.eval() for r in receivers]
            with torch.no_grad():
                c = t = 0; er = np.random.RandomState(999)
                for _ in range(30):
                    ia_h = er.choice(ho, min(32, len(ho))); ib_h = er.choice(ho, min(32, len(ho)))
                    s2 = ia_h == ib_h
                    while s2.any(): ib_h[s2] = er.choice(ho, s2.sum()); s2 = ia_h == ib_h
                    mdh = np.abs(mass_values[ia_h] - mass_values[ib_h]); kh = mdh > 0.5
                    if kh.sum() < 2: continue
                    ia_h, ib_h = ia_h[kh], ib_h[kh]
                    vh = [v[ia_h].to(DEVICE) for v in agent_views]
                    wh = [v[ib_h].to(DEVICE) for v in agent_views]
                    mah, _ = sender(vh); mbh, _ = sender(wh)
                    for r in receivers:
                        c += ((r(mah, mbh) > 0) == (mass_dev[ia_h] > mass_dev[ib_h])).sum().item()
                        t += len(ia_h)
                acc = c / max(t, 1)
                if acc > best_acc:
                    best_acc = acc; best_ep = ep
                    best_state = {k: v.cpu().clone() for k, v in sender.state_dict().items()}

    if best_state: sender.load_state_dict(best_state)
    sender.eval()

    # Extract representations
    all_repr = []
    with torch.no_grad():
        for i in range(0, n, BATCH_SIZE):
            vs = [v[i:i+BATCH_SIZE].to(DEVICE) for v in agent_views]
            m, logits = sender(vs)
            all_repr.append(m.cpu())
    all_repr = torch.cat(all_repr, 0).numpy()

    # Compositionality
    mass_bins = np.digitize(mass_values, np.quantile(mass_values, [0.2, 0.4, 0.6, 0.8]))
    uo = sorted(set(obj_names)); oi = {o: i for i, o in enumerate(uo)}
    obj_bins = np.digitize(np.array([oi[o] for o in obj_names]),
                            np.quantile(np.arange(len(uo)), [0.2, 0.4, 0.6, 0.8]))
    attrs = np.stack([mass_bins, obj_bins], axis=1)

    if is_discrete:
        # Extract tokens
        tokens = []
        with torch.no_grad():
            for i in range(0, n, BATCH_SIZE):
                vs = [v[i:i+BATCH_SIZE].to(DEVICE) for v in agent_views]
                _, logits = sender(vs)
                tokens.append(np.stack([l.argmax(-1).cpu().numpy() for l in logits], 1))
        tokens = np.concatenate(tokens, 0)
        posdis, mi_mat, ents = positional_disentanglement(tokens, attrs, VOCAB_SIZE)
        n_positions = tokens.shape[1]
    else:
        posdis, mi_mat, ents = continuous_disentanglement(all_repr, attrs)
        n_positions = all_repr.shape[1]

    # Causal specificity
    cs, drops, base_acc = causal_specificity(
        sender, agent_views, mass_values, receivers[0], n_positions, is_discrete)

    # TopSim
    ts = 0.0
    if is_discrete:
        from scipy.stats import spearmanr
        rng2 = np.random.RandomState(42)
        idx_a = rng2.randint(0, n, 5000); idx_b = rng2.randint(0, n, 5000)
        meaning_d = np.abs(mass_bins[idx_a] - mass_bins[idx_b]) + np.abs(obj_bins[idx_a] - obj_bins[idx_b])
        msg_d = np.sum(tokens[idx_a] != tokens[idx_b], axis=1)
        ts_val, _ = spearmanr(meaning_d, msg_d)
        ts = float(ts_val) if not np.isnan(ts_val) else 0.0

    return {
        "arm": arm_name,
        "accuracy": float(best_acc),
        "posdis": float(posdis),
        "topsim": float(ts),
        "causal_specificity": float(cs),
        "causal_drops": [float(d) for d in drops],
        "converge_epoch": best_ep + 1,
        "elapsed_s": time.time() - t0,
    }


# ═══ Main ═══

def run():
    print("╔══════════════════════════════════════════════════════════╗", flush=True)
    print("║  KILLER EXPERIMENT: Discrete vs Continuous Bottleneck     ║", flush=True)
    print("╚══════════════════════════════════════════════════════════╝", flush=True)
    t_total = time.time()

    # Load features
    vjepa_data = torch.load("results/phase87_phys101_spring_features.pt", weights_only=False)
    dino_data = torch.load("results/phase87_phys101_spring_static.pt", weights_only=False)

    backbones = {
        "vjepa2": {
            "feat": vjepa_data["features"].float(),
            "dim": 1024,
        },
        "dinov2": {
            "feat": dino_data["features"].float().unsqueeze(1).expand(-1, 8, -1).contiguous(),
            "dim": 384,
        },
    }
    obj_names = vjepa_data["obj_names"]
    mass_values = vjepa_data["mass_values"]
    n_frames = 8
    fpa = n_frames // N_AGENTS

    all_results = []

    for bb_name, bb_data in backbones.items():
        feat = bb_data["feat"]
        dim = bb_data["dim"]
        print(f"\n{'='*60}", flush=True)
        print(f"  BACKBONE: {bb_name} ({dim}-dim)", flush=True)
        print(f"{'='*60}", flush=True)

        agent_views = [feat[:, i*fpa:(i+1)*fpa, :] for i in range(N_AGENTS)]

        for arm_name in ["discrete", "continuous", "raw_probe"]:
            print(f"\n  ── {arm_name} ──", flush=True)

            for seed in range(N_SEEDS):
                torch.manual_seed(seed)

                if arm_name == "discrete":
                    senders = [DiscreteSender(TemporalEncoder(HIDDEN_DIM, dim, fpa),
                               HIDDEN_DIM, VOCAB_SIZE, N_HEADS) for _ in range(N_AGENTS)]
                    sender = DiscreteMultiSender(senders)
                    msg_dim = MSG_DIM

                elif arm_name == "continuous":
                    per_agent_dim = CONT_DIM // N_AGENTS  # 10 per agent
                    senders = [ContinuousSender(TemporalEncoder(HIDDEN_DIM, dim, fpa),
                               HIDDEN_DIM, per_agent_dim) for _ in range(N_AGENTS)]
                    sender = ContinuousMultiSender(senders)
                    msg_dim = CONT_DIM

                elif arm_name == "raw_probe":
                    sender = RawFeatureProbe(dim, N_AGENTS, fpa)
                    msg_dim = 40

                r = train_arm(arm_name, sender, agent_views, mass_values, obj_names, seed, msg_dim)
                if r is None: continue
                r["backbone"] = bb_name
                r["seed"] = seed
                all_results.append(r)

                print(f"    Seed {seed}: acc={r['accuracy']:.1%} "
                      f"PD={r['posdis']:.3f} CS={r['causal_specificity']:.3f}", flush=True)

                torch.mps.empty_cache()

    # ═══ Summary ═══
    print(f"\n{'='*70}", flush=True)
    print(f"  DISCRETE vs CONTINUOUS: HEAD-TO-HEAD RESULTS", flush=True)
    print(f"{'='*70}", flush=True)
    print(f"  {'Backbone':<10s} {'Arm':<12s} │ {'Accuracy':>10s} │ {'PosDis':>10s} │ "
          f"{'Causal Spec':>12s} │ {'TopSim':>8s}", flush=True)
    print(f"  {'─'*10} {'─'*12} ┼ {'─'*10} ┼ {'─'*10} ┼ {'─'*12} ┼ {'─'*8}", flush=True)

    summary = {}
    for bb in ["vjepa2", "dinov2"]:
        for arm in ["discrete", "continuous", "raw_probe"]:
            runs = [r for r in all_results if r["backbone"] == bb and r["arm"] == arm]
            if not runs: continue
            accs = [r["accuracy"] for r in runs]
            pds = [r["posdis"] for r in runs]
            css = [r["causal_specificity"] for r in runs]
            tss = [r["topsim"] for r in runs]
            key = f"{bb}_{arm}"
            summary[key] = {
                "acc": f"{np.mean(accs):.1%}±{np.std(accs):.1%}",
                "posdis": f"{np.mean(pds):.3f}±{np.std(pds):.3f}",
                "causal_spec": f"{np.mean(css):.3f}±{np.std(css):.3f}",
                "topsim": f"{np.mean(tss):.3f}±{np.std(tss):.3f}",
                "acc_mean": float(np.mean(accs)),
                "pd_mean": float(np.mean(pds)),
                "cs_mean": float(np.mean(css)),
            }
            print(f"  {bb:<10s} {arm:<12s} │ {np.mean(accs):>9.1%} │ "
                  f"{np.mean(pds):>9.3f} │ {np.mean(css):>11.3f} │ "
                  f"{np.mean(tss):>7.3f}", flush=True)

    # ═══ THE VERDICT ═══
    print(f"\n  ╔═══ THE VERDICT ═══╗", flush=True)
    for bb in ["vjepa2", "dinov2"]:
        disc = summary.get(f"{bb}_discrete", {})
        cont = summary.get(f"{bb}_continuous", {})
        if disc and cont:
            pd_gap = disc.get("pd_mean", 0) - cont.get("pd_mean", 0)
            acc_gap = disc.get("acc_mean", 0) - cont.get("acc_mean", 0)
            cs_gap = disc.get("cs_mean", 0) - cont.get("cs_mean", 0)
            print(f"  ║ {bb}:", flush=True)
            print(f"  ║   PosDis: discrete {disc.get('pd_mean',0):.3f} vs continuous {cont.get('pd_mean',0):.3f} "
                  f"(Δ={pd_gap:+.3f})", flush=True)
            print(f"  ║   Accuracy: discrete {disc.get('acc_mean',0):.1%} vs continuous {cont.get('acc_mean',0):.1%} "
                  f"(Δ={acc_gap:+.1%})", flush=True)
            print(f"  ║   Causal: discrete {disc.get('cs_mean',0):.3f} vs continuous {cont.get('cs_mean',0):.3f} "
                  f"(Δ={cs_gap:+.3f})", flush=True)
            if pd_gap > 0.3 and abs(acc_gap) < 0.05:
                print(f"  ║   → DISCRETE WINS on interpretability, competitive on accuracy", flush=True)
            elif pd_gap < 0.1:
                print(f"  ║   → NO CLEAR WINNER on interpretability", flush=True)
            else:
                print(f"  ║   → DISCRETE ADVANTAGE: +{pd_gap:.3f} PosDis", flush=True)
    print(f"  ╚═══════════════════╝", flush=True)

    # Save
    with open(RESULTS_DIR / "results.json", "w") as f:
        json.dump({"summary": summary, "all_runs": all_results}, f, indent=2, default=str)

    # Plot
    import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt

    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
    fig.suptitle("Discrete vs Continuous Bottleneck: Head-to-Head", fontsize=14, fontweight='bold')
    colors = {"discrete": "#2196F3", "continuous": "#F44336", "raw_probe": "#9E9E9E"}
    labels = {"discrete": "WMCP (discrete)", "continuous": "Continuous MLP", "raw_probe": "Raw features"}

    for ax, metric, ylabel in [(axes[0], "acc_mean", "Accuracy"),
                                (axes[1], "pd_mean", "PosDis"),
                                (axes[2], "cs_mean", "Causal Specificity")]:
        x = np.arange(2); width = 0.25
        for i, arm in enumerate(["discrete", "continuous", "raw_probe"]):
            vals = []
            for bb in ["vjepa2", "dinov2"]:
                key = f"{bb}_{arm}"
                vals.append(summary.get(key, {}).get(metric, 0))
            ax.bar(x + i * width, vals, width, label=labels[arm], color=colors[arm], alpha=0.8)
        ax.set_xticks(x + width); ax.set_xticklabels(["V-JEPA 2", "DINOv2"])
        ax.set_ylabel(ylabel); ax.set_title(ylabel)
        if metric == "pd_mean": ax.set_ylim(0, 1); ax.legend(fontsize=8)

    plt.tight_layout()
    plt.savefig(RESULTS_DIR / "discrete_vs_continuous.png", dpi=200, bbox_inches='tight')
    plt.close()
    print(f"\n  Saved results/killer_experiment/", flush=True)

    total_min = (time.time() - t_total) / 60
    print(f"  Total: {total_min:.1f} min", flush=True)


if __name__ == "__main__":
    run()