| """Known-answer tests for the v2 statistics. |
| |
| Every expected value below is derivable by hand or by construction, so a bug in |
| the bootstrap, the correction, or the equivalence test fails loudly instead of |
| quietly widening or narrowing a published interval. |
| |
| python tests/test_stats.py |
| """ |
| from __future__ import annotations |
|
|
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) |
|
|
| import analysis_v2 as A |
|
|
| FAILS: list[str] = [] |
|
|
|
|
| def check(name: str, cond: bool, detail: str = "") -> None: |
| print(f"{'PASS' if cond else 'FAIL'} {name:<52}{detail}") |
| if not cond: |
| FAILS.append(name) |
|
|
|
|
| def test_holm() -> None: |
| print("\n[holm] hand-computed family p = 0.001, 0.02, 0.03, 0.2") |
| adj = A.holm({"a": 0.001, "b": 0.02, "c": 0.03, "d": 0.2}) |
| want = {"a": 0.004, "b": 0.06, "c": 0.06, "d": 0.2} |
| for k, v in want.items(): |
| check(f"holm {k}", abs(adj[k] - v) < 1e-12, f"got {adj[k]:.6f} want {v}") |
| check("holm monotone", all(adj[a] <= adj[b] for a, b in |
| [("a", "b"), ("b", "c"), ("c", "d")])) |
| check("holm only the smallest survives", adj["a"] < 0.05 and adj["b"] >= 0.05) |
|
|
|
|
| def test_tost() -> None: |
| print("\n[tost] equivalence decisions at margin 0.03") |
| eq = A.tost(delta=0.000, se=0.008) |
| check("delta 0.000, se 0.008 -> equivalent", eq["equivalent"], f"p={eq['p']:.2g}") |
| same = A.tost(delta=0.022, se=0.004) |
| check("delta 0.022, se 0.004 -> equivalent", same["equivalent"], |
| f"p={same['p']:.2g} ci90={same['ci90']}") |
| big = A.tost(delta=0.100, se=0.008) |
| check("delta 0.100 -> not equivalent", not big["equivalent"], f"p={big['p']:.2g}") |
| wide = A.tost(delta=0.000, se=0.400) |
| check("delta 0.000 but se 0.400 -> not equivalent", not wide["equivalent"], |
| "wide CI cannot prove equivalence") |
|
|
|
|
| def test_cluster_bootstrap() -> None: |
| print("\n[cluster bootstrap] duplicated captions must widen the interval") |
| n_clips, caps = 100, 5 |
| rng = np.random.default_rng(0) |
| clip_hits = (rng.random(n_clips) < 0.5).astype(float) |
| values = np.repeat(clip_hits, caps) |
| clusters = np.repeat(np.arange(n_clips), caps) |
|
|
| lo, hi, se_cluster = A.cluster_bootstrap_mean(values, clusters, lambda v: v.mean()) |
| naive_se = float(np.sqrt(values.mean() * (1 - values.mean()) / len(values))) |
| check("cluster SE exceeds naive SE by >1.5x", se_cluster > 1.5 * naive_se, |
| f"cluster={se_cluster:.4f} naive={naive_se:.4f}") |
| check("point estimate unchanged", abs(values.mean() - clip_hits.mean()) < 1e-12) |
|
|
|
|
| def test_paired_delta() -> None: |
| |
| |
| print("\n[paired delta] a real +0.14 gap must be detected") |
| n_clips, caps = 400, 5 |
| rng = np.random.default_rng(1) |
| a_clip = (rng.random(n_clips) < 0.30).astype(float) |
| |
| b_clip = np.clip(a_clip + (rng.random(n_clips) < 0.20), 0, 1) |
| a = np.repeat(a_clip, caps) |
| b = np.repeat(b_clip, caps) |
| clusters = np.repeat(np.arange(n_clips), caps) |
|
|
| lo, hi, se = A.cluster_bootstrap_delta(a, b, clusters) |
| delta = float(b.mean() - a.mean()) |
| check("delta near the constructed 0.14", 0.10 < delta < 0.18, f"delta={delta:+.3f}") |
| check("CI excludes zero", lo > 0, f"[{lo:+.3f}, {hi:+.3f}]") |
| check("points to the same delta as the cluster means", |
| abs(delta - (b_clip.mean() - a_clip.mean())) < 1e-12) |
|
|
| zero = A.cluster_bootstrap_delta(a, a, clusters) |
| check("identical arms give delta 0 with CI containing 0", |
| abs(zero[0]) < 1e-9 and zero[0] <= 0 <= zero[1]) |
|
|
|
|
| def test_mcnemar() -> None: |
| print("\n[mcnemar] hand-computed: 1 discordant one way, 9 the other") |
| a = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0], dtype=bool) |
| b = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], dtype=bool) |
| p, n01, n10 = A.mcnemar_exact(a, b) |
| want = 2 * (1 + 10) / 1024 |
| check("mcnemar p matches exact binomial", abs(p - want) < 1e-12, |
| f"got {p:.6f} want {want:.6f}") |
| check("discordant counts", (n01, n10) == (1, 9), f"({n01}, {n10})") |
| check("identical arms give p=1", A.mcnemar_exact(a, a)[0] == 1.0) |
|
|
|
|
| def test_cluster_sign_flip() -> None: |
| """10 clips favour b, 2 favour a: the exact two-sided sign-flip p is 2*(1+12+66)/4096.""" |
| print("\n[cluster sign-flip] 12 clips, 10 favour b") |
| a = np.zeros(12) |
| b = np.zeros(12) |
| for i in range(10): |
| b[i] = 1.0 |
| for i in range(10, 12): |
| a[i] = 1.0 |
| out = A.cluster_sign_flip(a, b, np.arange(12), n_perm=20000) |
| want = 2 * (1 + 12 + 66) / 4096 |
| check("delta = 8/12", abs(out["delta"] - 8 / 12) < 1e-12, f"delta={out['delta']:.6f}") |
| check("p near the exact sign-flip value", abs(out["p_cluster_perm"] - want) < 0.01, |
| f"got {out['p_cluster_perm']:.4f} want {want:.4f}") |
| check("n_clusters counted", out["n_clusters"] == 12, f"n={out['n_clusters']}") |
|
|
|
|
| def test_cluster_zero_effect() -> None: |
| print("\n[cluster sign-flip] identical arms give p = 1") |
| a = np.array([1.0, 0.0, 1.0, 0.0]) |
| out = A.cluster_sign_flip(a, a, np.arange(4), n_perm=1000) |
| check("identical arms p = 1", abs(out["p_cluster_perm"] - 1.0) < 1e-12, |
| f"p={out['p_cluster_perm']:.4f}") |
|
|
|
|
| def test_mdd() -> None: |
| print("\n[mdd] minimum detectable difference shrinks with sample size") |
| small = A.mdd(0.05) |
| large = A.mdd(0.01) |
| check("mdd(0.01) < mdd(0.05)", large < small, f"{large:.3f} vs {small:.3f}") |
| check("mdd matches 2.80 * se", abs(small - 2.8016 * 0.05) < 1e-3, f"{small:.4f}") |
|
|
|
|
| if __name__ == "__main__": |
| test_holm() |
| test_tost() |
| test_cluster_bootstrap() |
| test_paired_delta() |
| test_mcnemar() |
| test_cluster_sign_flip() |
| test_cluster_zero_effect() |
| test_mdd() |
| print("\n" + ("ALL STATS CHECKS PASSED" if not FAILS else f"FAILURES: {FAILS}")) |
| raise SystemExit(0 if not FAILS else 1) |
|
|
