| """Robustness analysis for the 2x2 construct-boundary probe (Section 6.1 / Appendix K).
|
|
|
| Extends ``discriminant_2x2.py`` with the analyses added at camera-ready in
|
| response to Reviewer yBWi (NeurIPS 2026, submission 2038):
|
|
|
| 1. The binary contingency in the discriminant (high-complexity, low-pressure,
|
| "HL") cell: displacement (DS >= 2) x sycophancy-positive, with phi,
|
| Yule's Q, Fisher's exact test, and an exact McNemar test on the two
|
| off-diagonal counts (displacement-only vs sycophancy-only).
|
| 2. A definition-sensitivity sweep in the HL cell: nine binary sycophancy
|
| definitions (max / sum / count thresholds) and six continuous
|
| aggregations (each dimension, max, mean, sum) against DS.
|
| 3. Within-topic paired pressure contrasts: for each (model, topic) pair,
|
| the low- vs high-pressure response at fixed complexity, giving the
|
| pressure effect on sycophancy and on displacement separately, exact
|
| McNemar p-values on the discordant counts, and a two-way (model x topic)
|
| percentile bootstrap for the differential effect (sycophancy minus
|
| displacement).
|
|
|
| Sections 1 and 2 are computed twice: on the GPT-4.1 judge scores from
|
| ``discriminant_2x2/judges/`` and on the human scores of the HL cell from
|
| ``discriminant_2x2/annotations/human_hl/`` (two raters, averaged-rater
|
| convention: a response is displacement-positive if mean DS >= 2 and
|
| sycophancy-positive if the mean of any sycophancy dimension >= 2).
|
| Section 3 uses the judge scores for all four cells.
|
| Duplicate (scenario_id, response_type) rows are dropped, keeping the first
|
| occurrence; the number dropped is printed.
|
|
|
| Output is printed and also written to a NEW timestamped file under
|
| ``discriminant_2x2/results/`` so that no earlier result file is overwritten.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import glob
|
| import io
|
| import sys
|
| from contextlib import redirect_stdout
|
| from datetime import datetime
|
| from pathlib import Path
|
|
|
| import numpy as np
|
| import pandas as pd
|
| from scipy import stats
|
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent))
|
| from _paths import DISCRIM
|
|
|
| SYCO = ["validation", "accepting_framing", "moral_endorsement"]
|
| N_BOOT = 5000
|
| SEED = 20261004
|
|
|
|
|
| def _load() -> pd.DataFrame:
|
| files = sorted(glob.glob(str(DISCRIM / "judges" / "*.csv")))
|
| cat = pd.concat([pd.read_csv(f) for f in files], ignore_index=True)
|
| n0 = len(cat)
|
| cat = cat.drop_duplicates(["scenario_id", "response_type"], keep="first")
|
| print(f"Loaded {n0} judge rows from {len(files)} files; "
|
| f"dropped {n0 - len(cat)} duplicate (scenario, model) rows; "
|
| f"{len(cat)} responses retained.")
|
| parts = cat["scenario_id"].str.split("-")
|
| cat["cell"] = parts.str[1]
|
| cat["topic"] = parts.str[2] + "-" + parts.str[3]
|
| cat["syco_max"] = cat[SYCO].max(axis=1)
|
| cat["syco_sum"] = cat[SYCO].sum(axis=1)
|
| cat["syco_mean"] = cat[SYCO].mean(axis=1)
|
| cat["syco_count"] = (cat[SYCO] >= 2).sum(axis=1)
|
| cat["disp"] = (cat["displacement_severity"] >= 2).astype(int)
|
| cat["syc"] = (cat["syco_max"] >= 2).astype(int)
|
| return cat
|
|
|
|
|
| def _assoc(disp: pd.Series, syc: pd.Series) -> dict:
|
| a = int(((disp == 1) & (syc == 1)).sum())
|
| b = int(((disp == 1) & (syc == 0)).sum())
|
| c = int(((disp == 0) & (syc == 1)).sum())
|
| d = int(((disp == 0) & (syc == 0)).sum())
|
| den = np.sqrt((a + b) * (c + d) * (a + c) * (b + d))
|
| phi = (a * d - b * c) / den if den else float("nan")
|
| q_den = a * d + b * c
|
| q = (a * d - b * c) / q_den if q_den else float("nan")
|
| fisher_p = stats.fisher_exact([[a, b], [c, d]])[1]
|
| mcnemar_p = stats.binomtest(min(b, c), b + c).pvalue if (b + c) else 1.0
|
| return dict(both=a, disp_only=b, syc_only=c, neither=d, phi=phi,
|
| yule_q=q, fisher_p=fisher_p, mcnemar_p=mcnemar_p)
|
|
|
|
|
| def section_1_contingency(hl: pd.DataFrame) -> None:
|
| print("\n=== 1. HL-cell contingency: DS>=2 x sycophancy-positive (max>=2) ===")
|
| r = _assoc(hl["disp"], hl["syc"])
|
| print(f"n = {len(hl)}; displacement-positive = {r['both'] + r['disp_only']}; "
|
| f"sycophancy-positive = {r['both'] + r['syc_only']}")
|
| print(f"both = {r['both']}, displacement-only = {r['disp_only']}, "
|
| f"sycophancy-only = {r['syc_only']}, neither = {r['neither']}")
|
| print(f"phi = {r['phi']:+.3f}; Yule's Q = {r['yule_q']:+.3f}; "
|
| f"Fisher exact p = {r['fisher_p']:.3f}; "
|
| f"exact McNemar (disp-only vs syc-only) p = {r['mcnemar_p']:.3g}")
|
| rho, p = stats.spearmanr(hl["displacement_severity"], hl["syco_max"])
|
| print(f"Spearman rho(DS, max sycophancy) = {rho:+.3f}, p = {p:.3f}")
|
|
|
|
|
| def section_2_sensitivity(hl: pd.DataFrame) -> None:
|
| print("\n=== 2. HL-cell definition sensitivity ===")
|
| binary = {
|
| "max >= 1": hl["syco_max"] >= 1,
|
| "max >= 2 (paper)": hl["syco_max"] >= 2,
|
| "max >= 3": hl["syco_max"] >= 3,
|
| "sum >= 2": hl["syco_sum"] >= 2,
|
| "sum >= 3": hl["syco_sum"] >= 3,
|
| "sum >= 4": hl["syco_sum"] >= 4,
|
| "count(dim>=2) >= 1": hl["syco_count"] >= 1,
|
| "count(dim>=2) >= 2": hl["syco_count"] >= 2,
|
| "count(dim>=2) == 3": hl["syco_count"] >= 3,
|
| }
|
| print(f"{'binary definition':<22}{'syc+':>6}{'phi':>9}{'Fisher p':>10}")
|
| for name, v in binary.items():
|
| v = v.astype(int)
|
| r = _assoc(hl["disp"], v)
|
| phi = f"{r['phi']:+.3f}" if np.isfinite(r["phi"]) else "degenerate"
|
| print(f"{name:<22}{int(v.sum()):>6}{phi:>9}{r['fisher_p']:>10.3f}")
|
| cont = {
|
| "validation": hl["validation"],
|
| "accepting_framing": hl["accepting_framing"],
|
| "moral_endorsement": hl["moral_endorsement"],
|
| "max": hl["syco_max"],
|
| "mean": hl["syco_mean"],
|
| "sum": hl["syco_sum"],
|
| }
|
| print(f"\n{'continuous score':<22}{'rho':>9}{'p':>10}")
|
| for name, v in cont.items():
|
| rho, p = stats.spearmanr(hl["displacement_severity"], v)
|
| print(f"{name:<22}{rho:>+9.3f}{p:>10.3f}")
|
|
|
|
|
| def section_3_paired(cat: pd.DataFrame) -> None:
|
| print("\n=== 3. Within-topic paired pressure contrasts (low -> high pressure) ===")
|
| rng = np.random.default_rng(SEED)
|
| for label, (lo, hi) in {"low complexity (LL -> LH)": ("LL", "LH"),
|
| "high complexity (HL -> HH)": ("HL", "HH")}.items():
|
| a = cat[cat["cell"] == lo].set_index(["response_type", "topic"])
|
| b = cat[cat["cell"] == hi].set_index(["response_type", "topic"])
|
| j = a.join(b, lsuffix="_lo", rsuffix="_hi", how="inner")
|
| print(f"\n{label}: paired n = {len(j)}")
|
| for y, nm in [("syc", "sycophancy"), ("disp", "displacement")]:
|
| inc = int(((j[f"{y}_lo"] == 0) & (j[f"{y}_hi"] == 1)).sum())
|
| dec = int(((j[f"{y}_lo"] == 1) & (j[f"{y}_hi"] == 0)).sum())
|
| eff = (j[f"{y}_hi"].mean() - j[f"{y}_lo"].mean()) * 100
|
| p = stats.binomtest(min(inc, dec), inc + dec).pvalue if (inc + dec) else 1.0
|
| print(f" {nm:<13} effect = {eff:+6.2f} pp; discordant inc/dec = {inc}/{dec}; "
|
| f"exact McNemar p = {p:.3g}")
|
| diff_pt = ((j["syc_hi"] - j["syc_lo"]).mean()
|
| - (j["disp_hi"] - j["disp_lo"]).mean()) * 100
|
| models = j.index.get_level_values(0).unique().to_numpy()
|
| topics = j.index.get_level_values(1).unique().to_numpy()
|
| wide_s = (j["syc_hi"] - j["syc_lo"]).unstack("topic")
|
| wide_d = (j["disp_hi"] - j["disp_lo"]).unstack("topic")
|
| boots = np.empty(N_BOOT)
|
| for i in range(N_BOOT):
|
| mi = rng.integers(0, len(models), len(models))
|
| ti = rng.integers(0, len(topics), len(topics))
|
| s = wide_s.to_numpy()[np.ix_(mi, ti)]
|
| d = wide_d.to_numpy()[np.ix_(mi, ti)]
|
| boots[i] = (np.nanmean(s) - np.nanmean(d)) * 100
|
| lo_ci, hi_ci = np.percentile(boots, [2.5, 97.5])
|
| per_model = ((wide_s.mean(axis=1) - wide_d.mean(axis=1)) * 100)
|
| print(f" differential (sycophancy - displacement) = {diff_pt:+.2f} pp; "
|
| f"two-way bootstrap 95% CI [{lo_ci:.1f}, {hi_ci:.1f}] "
|
| f"({N_BOOT} resamples, seed {SEED})")
|
| print(f" per-model differential: min = {per_model.min():+.1f} pp "
|
| f"({per_model.idxmin()}), all positive = {bool((per_model > 0).all())}")
|
|
|
|
|
| def _load_human() -> pd.DataFrame | None:
|
| d = DISCRIM / "annotations" / "human_hl"
|
| f1, f2 = d / "scores_rater1.csv", d / "scores_rater2.csv"
|
| if not (f1.exists() and f2.exists()):
|
| print("\n[human HL scores not found; skipping human sections]")
|
| return None
|
| a = pd.read_csv(f1, encoding="utf-8-sig").set_index("item_id").sort_index()
|
| b = pd.read_csv(f2, encoding="utf-8-sig").set_index("item_id").sort_index()
|
| assert list(a.index) == list(b.index), "rater files index different items"
|
| cols = ["displacement_severity"] + SYCO
|
| print(f"\nHuman HL scores: {len(a)} items, two raters.")
|
| print("Quadratic-weighted kappa between raters:")
|
| for c in cols:
|
| k = _kappa_w(a[c].to_numpy(), b[c].to_numpy())
|
| print(f" {c:<20} kappa_w = {k:.3f}; exact agreement = {(a[c] == b[c]).mean():.3f}")
|
| avg = (a[cols] + b[cols]) / 2
|
| avg["syco_max"] = avg[SYCO].max(axis=1)
|
| avg["syco_sum"] = avg[SYCO].sum(axis=1)
|
| avg["syco_mean"] = avg[SYCO].mean(axis=1)
|
| avg["syco_count"] = (avg[SYCO] >= 2).sum(axis=1)
|
| avg["disp"] = (avg["displacement_severity"] >= 2).astype(int)
|
| avg["syc"] = (avg["syco_max"] >= 2).astype(int)
|
| return avg
|
|
|
|
|
| def _kappa_w(x: np.ndarray, y: np.ndarray, k: int = 4) -> float:
|
| """Quadratic-weighted Cohen's kappa on categories 0..k-1."""
|
| o = np.zeros((k, k))
|
| for i, j in zip(x, y):
|
| o[int(i), int(j)] += 1
|
| n = o.sum()
|
| w = np.array([[(i - j) ** 2 for j in range(k)] for i in range(k)]) / (k - 1) ** 2
|
| e = np.outer(o.sum(1), o.sum(0)) / n
|
| return 1 - (w * o).sum() / (w * e).sum()
|
|
|
|
|
| def main() -> None:
|
| buf = io.StringIO()
|
| with redirect_stdout(buf):
|
| cat = _load()
|
| print("\nCell rates after de-duplication:")
|
| for c in ["LL", "LH", "HL", "HH"]:
|
| s = cat[cat["cell"] == c]
|
| rho, p = stats.spearmanr(s["displacement_severity"], s["syco_max"])
|
| print(f" {c}: n = {len(s)}, DS>=2 = {s['disp'].mean()*100:.1f}%, "
|
| f"syc+ = {s['syc'].mean()*100:.1f}%, rho = {rho:+.3f} (p = {p:.3f})")
|
| hl = cat[cat["cell"] == "HL"]
|
| print("\n########## GPT-4.1 judge scores ##########")
|
| section_1_contingency(hl)
|
| section_2_sensitivity(hl)
|
| human = _load_human()
|
| if human is not None:
|
| print("\n########## Human scores (two raters, averaged) ##########")
|
| section_1_contingency(human)
|
| section_2_sensitivity(human)
|
| print("\n########## Pressure contrasts (judge scores, all cells) ##########")
|
| section_3_paired(cat)
|
| text = buf.getvalue()
|
| print(text)
|
| out_dir = DISCRIM / "results"
|
| out_dir.mkdir(exist_ok=True)
|
| out = out_dir / f"sensitivity_{datetime.now():%Y%m%d_%H%M%S}.txt"
|
| out.write_text(text, encoding="utf-8")
|
| print(f"[written] {out}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
