File size: 7,673 Bytes
6f2ed01 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | #!/usr/bin/env python
"""Do internal and external stability move together? (protocol 12, 13.2)
python src/joint.py --transport raw
Three levels, because they can disagree and each answers a different question:
1. ACROSS MODELS Does a model with higher BCS also have higher ISS?
n = number of evaluated models, so this is suggestive at
best -- it is the weakest of the three.
2. WITHIN MODEL, ACROSS FACTS Are the SAME facts unstable behaviourally and
internally? This is the real test. A model can sit at the
group mean while the two measures disagree completely
fact by fact, and only this level would reveal it.
3. BY BEHAVIOUR GROUP Protocol 13.2: mean ISS for Stable Correct vs Stable
Wrong vs Stable Abstention vs Unstable. This is the table
the paper needs, and it also separates the two ways a fact
can be "stable": stably right and stably wrong should both
show high ISS if internal state drives behaviour.
Protocol 12 lists cells such as "BCS high / ISS low" -- consistent answers
reached through inconsistent internal states. Reporting only a single pooled
correlation would hide exactly those cases, so the per-model breakdown is
printed even when the pooled number looks tidy.
"""
import os, sys, glob, json, argparse, collections
import numpy as np
from scipy.stats import spearmanr, pearsonr
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import mcommon as mc
GROUPS = ["Stable Correct", "Stable Wrong", "Stable Abstention",
"Stable Unresolved", "Unstable"]
def load_pairs(model, transport, mode):
ip = mc.out("metrics", "iss", f"{model}.{transport}.{mode}.per_fact.jsonl")
bp = mc.out("metrics", "behavioral", f"{model}.{mode}.per_fact.jsonl")
if not (os.path.exists(ip) and os.path.exists(bp)):
return None
iss = {r["fact_id"]: r for r in mc.read_jsonl(ip)}
beh = {r["fact_id"]: r for r in mc.read_jsonl(bp)}
common = sorted(set(iss) & set(beh))
if len(common) < 20:
return None
return [{"fact_id": f, "relation": iss[f]["relation"],
"iss": iss[f]["iss"], "iss_late": iss[f]["iss_late"],
"bcs": beh[f]["bcs"], "bes": beh[f]["bes"],
"group": beh[f]["behavior_group"]} for f in common]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
args = ap.parse_args()
mode = args.coverage or mc.cfg()["headline_coverage"]
names = [m["name"] for m in mc.models_cfg()["evaluated_models"]]
per_model, model_level = {}, []
for m in names:
rows = load_pairs(m, args.transport, mode)
if rows is None:
continue
per_model[m] = rows
isum = json.load(open(mc.out("metrics", "iss",
f"{m}.{args.transport}.{mode}.summary.json")))
bsum = json.load(open(mc.out("metrics", "behavioral",
f"{m}.{mode}.summary.json")))
kp = mc.out("metrics", "kts", f"{m}.{args.transport}.{mode}.summary.json")
ksum = json.load(open(kp)) if os.path.exists(kp) else {}
model_level.append({
"model": m, "family": mc.model_entry(m).get("family"),
"params_b": mc.model_entry(m).get("params_b"),
"tuning": mc.model_entry(m).get("tuning"),
"iss": isum["iss"], "bcs": bsum["bcs"], "bes": bsum["bes"],
"kts": ksum.get("kts"), "kts_id": ksum.get("kts_id"),
"unstable_rate": bsum["unstable_rate"],
"stable_correct_rate": bsum["stable_correct_rate"],
"n_joined": len(rows)})
if not model_level:
raise SystemExit("no model has BOTH ISS and BCS/BES yet")
out = {"transport": args.transport, "coverage_mode": mode,
"n_models": len(model_level), "model_level": model_level}
# ---- level 1: across models
def corr(a, b):
a, b = np.asarray(a, float), np.asarray(b, float)
ok = np.isfinite(a) & np.isfinite(b)
if ok.sum() < 3:
return None
return {"spearman": float(spearmanr(a[ok], b[ok]).statistic),
"pearson": float(pearsonr(a[ok], b[ok]).statistic), "n": int(ok.sum())}
across = {}
for x in ("bcs", "bes", "unstable_rate", "stable_correct_rate"):
for y in ("iss", "kts", "kts_id"):
c = corr([r[x] for r in model_level], [r[y] for r in model_level])
if c:
across[f"{x}__{y}"] = c
out["across_models"] = across
# ---- level 2: within model, across facts
within, pooled = {}, []
for m, rows in per_model.items():
within[m] = {
"n_facts": len(rows),
"iss_vs_bcs": corr([r["iss"] for r in rows], [r["bcs"] for r in rows]),
"iss_vs_bes": corr([r["iss"] for r in rows], [r["bes"] for r in rows]),
}
# Standardise inside each model before pooling, otherwise the pooled
# correlation would mostly reflect between-model level differences
# rather than the within-model fact-by-fact association we are after.
for key in ("iss", "bcs"):
v = np.array([r[key] for r in rows], float)
sd = v.std() or 1.0
for r, z in zip(rows, (v - v.mean()) / sd):
r[f"z_{key}"] = float(z)
pooled += rows
out["within_model"] = within
out["pooled_within_model"] = corr([r["z_iss"] for r in pooled],
[r["z_bcs"] for r in pooled])
# ---- level 3: behaviour groups (protocol 13.2)
by_group = collections.defaultdict(list)
for m, rows in per_model.items():
for r in rows:
by_group[r["group"]].append(r["iss"])
out["iss_by_behavior_group"] = {
g: {"n": len(by_group[g]), "iss_mean": float(np.mean(by_group[g])),
"iss_sd": float(np.std(by_group[g]))}
for g in GROUPS if by_group[g]}
out["iss_by_behavior_group_per_model"] = {
m: {g: float(np.mean([r["iss"] for r in rows if r["group"] == g]))
for g in GROUPS if any(r["group"] == g for r in rows)}
for m, rows in per_model.items()}
mc.write_json(mc.out("metrics", f"joint_internal_external.{args.transport}.{mode}.json"),
out)
# ------------------------------------------------------------ report
print(f"\n=== 1. ACROSS MODELS (n={len(model_level)}) ===")
print(f"{'pair':34s} {'Spearman':>9s} {'Pearson':>9s}")
for k, v in across.items():
print(f"{k:34s} {v['spearman']:>9.3f} {v['pearson']:>9.3f}")
print(f"\n=== 2. WITHIN MODEL, ACROSS FACTS ===")
print(f"{'model':30s} {'n':>5s} {'ISSvBCS':>8s} {'ISSvBES':>8s}")
for m, v in within.items():
a = v["iss_vs_bcs"]["spearman"] if v["iss_vs_bcs"] else float("nan")
b = v["iss_vs_bes"]["spearman"] if v["iss_vs_bes"] else float("nan")
print(f"{m:30s} {v['n_facts']:>5d} {a:>8.3f} {b:>8.3f}")
p = out["pooled_within_model"]
if p:
print(f"{'POOLED (z-scored per model)':30s} {p['n']:>5d} {p['spearman']:>8.3f}")
print(f"\n=== 3. ISS BY BEHAVIOUR GROUP (protocol 13.2) ===")
print(f"{'group':22s} {'facts':>7s} {'ISS mean':>9s} {'sd':>7s}")
for g, v in out["iss_by_behavior_group"].items():
print(f"{g:22s} {v['n']:>7d} {v['iss_mean']:>9.3f} {v['iss_sd']:>7.3f}")
print()
if __name__ == "__main__":
main()
|