Datasets:

b4ph
/

clap-retrieval-benchmark

"""Pre-registered analysis for the v2 harness.
Implements exactly what `PREREGISTRATION.md` commits to:
  * primary endpoint: Clotho five-caption T2A R@1;
  * secondary: Clotho A2T R@1, AudioCaps T2A R@1, AudioCaps A2T R@1;
  * effect: unfused minus fused, paired by query;
  * cluster bootstrap that resamples CLIPS (five captions per clip are not
    independent), 2000 resamples, fixed seed;
  * Holm correction across the four endpoints;
  * TOST equivalence at a pre-committed margin, so "no difference" is a claim.
    python analysis_v2.py results_v2 --prereg PREREGISTRATION.md
"""
from __future__ import annotations

import argparse
import json
import math
from pathlib import Path

import numpy as np

SEED = 20261027
N_BOOT = 2000
EQUIV_MARGIN = 0.03          # pre-registered, do not tune after seeing results
ENDPOINTS = [
    ("clotho5", "t2a", "r@1", "primary"),
    ("clotho5", "a2t", "r@1", "secondary"),
    ("audiocaps", "t2a", "r@1", "secondary"),
    ("audiocaps", "a2t", "r@1", "secondary"),
]


# ---------------------------------------------------------------- estimators

def _hit(r: int, k: int) -> float:
    return 1.0 if r <= k else 0.0


def cluster_bootstrap_mean(values: np.ndarray, clusters: np.ndarray, stat,
                           n_boot: int = N_BOOT, seed: int = SEED):
    """Resample clusters with replacement; recompute the mean over all their rows."""
    rng = np.random.default_rng(seed)
    uniq = np.unique(clusters)
    idx_by_cluster = {c: np.flatnonzero(clusters == c) for c in uniq}
    draws = np.empty(n_boot)
    for i in range(n_boot):
        pick = rng.choice(uniq, size=len(uniq), replace=True)
        idx = np.concatenate([idx_by_cluster[c] for c in pick])
        draws[i] = stat(values[idx])
    return (float(np.percentile(draws, 2.5)),
            float(np.percentile(draws, 97.5)),
            float(draws.std(ddof=1)))


def cluster_bootstrap_delta(a: np.ndarray, b: np.ndarray, clusters: np.ndarray,
                            n_boot: int = N_BOOT, seed: int = SEED):
    """Paired bootstrap over clusters: the same resample is applied to both arms."""
    rng = np.random.default_rng(seed)
    uniq = np.unique(clusters)
    idx_by_cluster = {c: np.flatnonzero(clusters == c) for c in uniq}
    draws = np.empty(n_boot)
    for i in range(n_boot):
        pick = rng.choice(uniq, size=len(uniq), replace=True)
        idx = np.concatenate([idx_by_cluster[c] for c in pick])
        draws[i] = b[idx].mean() - a[idx].mean()
    return (float(np.percentile(draws, 2.5)), float(np.percentile(draws, 97.5)),
            float(draws.std(ddof=1)))


def tost(delta: float, se: float, margin: float = EQUIV_MARGIN, alpha: float = 0.05):
    """Two one-sided tests on a paired difference.
    Equivalent if the (1 - 2*alpha) CI lies inside [-margin, +margin]. Returned
    p-value is the larger of the two one-sided p-values, which is the standard
    TOST statistic. Normal approximation, appropriate at these n.
    """
    if se <= 0:
        return {"equivalent": abs(delta) < margin, "p": 0.0 if abs(delta) < margin else 1.0,
                "ci90": [delta, delta]}
    z = delta / se
    p_lower = 1.0 - _norm_cdf(z + margin / se)   # H0: delta <= -margin
    p_upper = _norm_cdf(z - margin / se)         # H0: delta >= +margin
    p = max(p_lower, p_upper)
    ci90 = [delta - 1.6448536269514722 * se, delta + 1.6448536269514722 * se]
    return {"equivalent": bool(p < alpha), "p": float(p),
            "ci90": [float(ci90[0]), float(ci90[1])]}


def _norm_cdf(x: float) -> float:
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))


def cluster_sign_flip(a_hits: np.ndarray, b_hits: np.ndarray, clusters: np.ndarray,
                      n_perm: int = 10000, seed: int = SEED) -> dict:
    """Permutation test at the clip level.
    McNemar assumes independent pairs, but five captions of one clip share their
    audio, so those five pairs are correlated and McNemar's p is anti-conservative.
    Here the labels are swapped *per cluster*: under the null the two checkpoints are
    exchangeable within a clip, so each clip contributes either +d or -d, where d is
    that clip's (b - a) contribution. Captions never move independently.
    """
    uniq, inv = np.unique(clusters, return_inverse=True)
    sa = np.bincount(inv, weights=a_hits.astype(float), minlength=len(uniq))
    sb = np.bincount(inv, weights=b_hits.astype(float), minlength=len(uniq))
    d = sb - sa
    total = float(len(a_hits))
    obs = float(d.sum() / total)

    rng = np.random.default_rng(seed)
    hits = 0
    done = 0
    while done < n_perm:
        chunk = min(1000, n_perm - done)
        signs = rng.choice(np.array([-1.0, 1.0]), size=(chunk, len(uniq)))
        sims = signs @ d / total
        hits += int(np.sum(np.abs(sims) >= abs(obs) - 1e-15))
        done += chunk
    p = (1.0 + hits) / (n_perm + 1.0)
    return {"delta": obs, "p_cluster_perm": float(p),
            "n_permutations": n_perm, "n_clusters": int(len(uniq))}


def mcnemar_exact(a_hits: np.ndarray, b_hits: np.ndarray) -> tuple[float, int, int]:
    """Exact two-sided McNemar on paired binary outcomes.
    Returns (p, b_only, a_only) where b_only counts queries only b gets right.
    This is the difference test; TOST answers a different question and must not be
    substituted for it.
    """
    n01 = int((~a_hits & b_hits).sum())
    n10 = int((a_hits & ~b_hits).sum())
    m = n01 + n10
    if m == 0:
        return 1.0, n01, n10
    tail = sum(math.comb(m, i) for i in range(0, min(n01, n10) + 1)) / 2 ** m
    return min(1.0, 2 * tail), n01, n10


def holm(pvals: dict[str, float], alpha: float = 0.05) -> dict[str, float]:
    """Holm-Bonferroni step-down. Returns adjusted p-values, monotone in the input."""
    items = sorted(pvals.items(), key=lambda kv: kv[1])
    m = len(items)
    adj, running = {}, 0.0
    for i, (name, p) in enumerate(items):
        val = min(1.0, (m - i) * p)
        running = max(running, val)
        adj[name] = running
    return adj


def mdd(se: float, alpha: float = 0.05, power: float = 0.8) -> float:
    """Minimum detectable difference at the given power (normal approximation)."""
    return float((1.959963984540054 + 0.8416212335729143) * se)


# ---------------------------------------------------------------- loading

def load_cell(path: Path) -> dict:
    d = json.loads(path.read_text(encoding="utf-8"))
    need = ("first_hit_rank", "cluster")
    if d["metrics"]["t2a"].get("cluster") is None:
        raise SystemExit(f"{path.name}: missing per-query clusters; rerun the cell")
    return d


def arm(d: dict, direction: str, k: int):
    m = d["metrics"][direction]
    ranks = np.asarray(m["first_hit_rank"], dtype=np.int64)
    clusters = np.asarray(m["cluster"], dtype=np.int64)
    return np.array([_hit(r, k) for r in ranks]), clusters


def summarise(d: dict, direction: str, k: int) -> dict:
    hits, clusters = arm(d, direction, k)
    lo, hi, se = cluster_bootstrap_mean(hits, clusters, lambda v: float(v.mean()))
    return {"value": float(hits.mean()), "ci95": [lo, hi], "se_cluster": se,
            "n_queries": int(len(hits)), "n_clusters": int(clusters.max() + 1)}


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("dir", nargs="?", default="results_v2")
    ap.add_argument("--out", default="analysis_v2.json")
    ap.add_argument("--prereg", default="PREREGISTRATION.md")
    args = ap.parse_args()

    if not Path(args.prereg).exists():
        raise SystemExit("PREREGISTRATION.md missing: analysis must follow a committed plan")

    root = Path(args.dir)
    cells = {}
    for f in sorted(root.glob("*__canon.json")):
        d = load_cell(f)
        cells[(d["dataset"], d["model"])] = d

    models = sorted({m for (_, m) in cells})
    if len(models) != 2:
        raise SystemExit(f"expected two checkpoints, found {models}")

    report = {"prereg": args.prereg, "equivalence_margin": EQUIV_MARGIN,
              "cells": {}, "endpoints": {}}
    for ds in sorted({d for (d, _) in cells}):
        for m in models:
            key = f"{m}|{ds}"
            report["cells"][key] = {
                "t2a_r1": summarise(cells[(ds, m)], "t2a", 1),
                "a2t_r1": summarise(cells[(ds, m)], "a2t", 1),
                "t2a_mrr": summarise_rank(cells[(ds, m)], "t2a"),
                "a2t_map": summarise_ap(cells[(ds, m)]),
            }

    fused = next(m for m in models if m.endswith("fused"))
    unfused = next(m for m in models if m.endswith("unfused"))
    pvals = {}
    for ds, direction, metric, role in ENDPOINTS:
        if (ds, fused) not in cells or (ds, unfused) not in cells:
            continue
        k = int(metric.split("@")[1])
        a, clusters = arm(cells[(ds, fused)], direction, k)
        b, _ = arm(cells[(ds, unfused)], direction, k)
        delta = float(b.mean() - a.mean())
        lo, hi, se = cluster_bootstrap_delta(a, b, clusters)
        eq = tost(delta, se)
        # difference test at the clip level: captions within a clip are correlated,
        # so McNemar's independent-pairs p is reported only for reference
        perm = cluster_sign_flip(a > 0.5, b > 0.5, clusters)
        mcn_p, n01, n10 = mcnemar_exact(a > 0.5, b > 0.5)
        name = f"{ds}_{direction}_{metric}"
        pvals[name] = perm["p_cluster_perm"]
        report["endpoints"][name] = {
            "role": role, "dataset": ds, "direction": direction, "metric": metric,
            "delta_unfused_minus_fused": delta,
            "ci95": [lo, hi], "se_cluster": se, "mdd80": mdd(se),
            "p_cluster_perm": perm["p_cluster_perm"],
            "n_permutations": perm["n_permutations"],
            "mcnemar_p_reference_only": mcn_p, "b_only": n01, "a_only": n10,
            "tost_p": eq["p"], "equivalent_at_margin": eq["equivalent"],
            "ci90_for_tost": eq["ci90"],
        }

    holm_adj = holm(pvals)
    for name, adj in holm_adj.items():
        report["endpoints"][name]["holm_adjusted_p"] = adj
        report["endpoints"][name]["significant_after_holm"] = bool(adj < 0.05)

    Path(args.out).write_text(json.dumps(report, indent=2), encoding="utf-8",
                              newline="\n")

    print(f"{'endpoint':<24}{'delta':>8}  {'95% CI':<19}{'perm p':>9}{'Holm':>8}"
          f"{'TOST':>8}  verdict")
    for name, e in report["endpoints"].items():
        ci = f"[{e['ci95'][0]:+.3f}, {e['ci95'][1]:+.3f}]"
        if e["significant_after_holm"]:
            verdict = "difference"
        elif e["equivalent_at_margin"]:
            verdict = "equivalent within +/-0.03"
        else:
            verdict = "inconclusive"
        print(f"{name:<24}{e['delta_unfused_minus_fused']:>+8.3f}  {ci:<19}"
              f"{e['p_cluster_perm']:>9.2g}{e['holm_adjusted_p']:>8.2g}"
              f"{e['tost_p']:>8.2g}  {verdict}")
    print(f"\nwrote {args.out}")
    return 0


def summarise_rank(d: dict, direction: str) -> dict:
    m = d["metrics"][direction]
    ranks = np.asarray(m["first_hit_rank"], dtype=np.float64)
    clusters = np.asarray(m["cluster"], dtype=np.int64)
    lo, hi, se = cluster_bootstrap_mean(ranks, clusters, lambda v: float((1.0 / v).mean()))
    return {"value": float((1.0 / ranks).mean()), "ci95": [lo, hi], "se_cluster": se}


def summarise_ap(d: dict) -> dict:
    m = d["metrics"]["a2t"]
    ap = np.asarray(m["ap"], dtype=np.float64)
    clusters = np.asarray(m["cluster"], dtype=np.int64)
    lo, hi, se = cluster_bootstrap_mean(ap, clusters, lambda v: float(v.mean()))
    return {"value": float(ap.mean()), "ci95": [lo, hi], "se_cluster": se}


if __name__ == "__main__":
    raise SystemExit(main())

	"""Pre-registered analysis for the v2 harness.

	Implements exactly what `PREREGISTRATION.md` commits to:

	* primary endpoint: Clotho five-caption T2A R@1;
	* secondary: Clotho A2T R@1, AudioCaps T2A R@1, AudioCaps A2T R@1;
	* effect: unfused minus fused, paired by query;
	* cluster bootstrap that resamples CLIPS (five captions per clip are not
	independent), 2000 resamples, fixed seed;
	* Holm correction across the four endpoints;
	* TOST equivalence at a pre-committed margin, so "no difference" is a claim.

	python analysis_v2.py results_v2 --prereg PREREGISTRATION.md
	"""
	from __future__ import annotations

	import argparse
	import json
	import math
	from pathlib import Path

	import numpy as np

	SEED = 20261027
	N_BOOT = 2000
	EQUIV_MARGIN = 0.03 # pre-registered, do not tune after seeing results
	ENDPOINTS = [
	("clotho5", "t2a", "r@1", "primary"),
	("clotho5", "a2t", "r@1", "secondary"),
	("audiocaps", "t2a", "r@1", "secondary"),
	("audiocaps", "a2t", "r@1", "secondary"),
	]


	# ---------------------------------------------------------------- estimators

	def _hit(r: int, k: int) -> float:
	return 1.0 if r <= k else 0.0


	def cluster_bootstrap_mean(values: np.ndarray, clusters: np.ndarray, stat,
	n_boot: int = N_BOOT, seed: int = SEED):
	"""Resample clusters with replacement; recompute the mean over all their rows."""
	rng = np.random.default_rng(seed)
	uniq = np.unique(clusters)
	idx_by_cluster = {c: np.flatnonzero(clusters == c) for c in uniq}
	draws = np.empty(n_boot)
	for i in range(n_boot):
	pick = rng.choice(uniq, size=len(uniq), replace=True)
	idx = np.concatenate([idx_by_cluster[c] for c in pick])
	draws[i] = stat(values[idx])
	return (float(np.percentile(draws, 2.5)),
	float(np.percentile(draws, 97.5)),
	float(draws.std(ddof=1)))


	def cluster_bootstrap_delta(a: np.ndarray, b: np.ndarray, clusters: np.ndarray,
	n_boot: int = N_BOOT, seed: int = SEED):
	"""Paired bootstrap over clusters: the same resample is applied to both arms."""
	rng = np.random.default_rng(seed)
	uniq = np.unique(clusters)
	idx_by_cluster = {c: np.flatnonzero(clusters == c) for c in uniq}
	draws = np.empty(n_boot)
	for i in range(n_boot):
	pick = rng.choice(uniq, size=len(uniq), replace=True)
	idx = np.concatenate([idx_by_cluster[c] for c in pick])
	draws[i] = b[idx].mean() - a[idx].mean()
	return (float(np.percentile(draws, 2.5)), float(np.percentile(draws, 97.5)),
	float(draws.std(ddof=1)))


	def tost(delta: float, se: float, margin: float = EQUIV_MARGIN, alpha: float = 0.05):
	"""Two one-sided tests on a paired difference.

	Equivalent if the (1 - 2*alpha) CI lies inside [-margin, +margin]. Returned
	p-value is the larger of the two one-sided p-values, which is the standard
	TOST statistic. Normal approximation, appropriate at these n.
	"""
	if se <= 0:
	return {"equivalent": abs(delta) < margin, "p": 0.0 if abs(delta) < margin else 1.0,
	"ci90": [delta, delta]}
	z = delta / se
	p_lower = 1.0 - _norm_cdf(z + margin / se) # H0: delta <= -margin
	p_upper = _norm_cdf(z - margin / se) # H0: delta >= +margin
	p = max(p_lower, p_upper)
	ci90 = [delta - 1.6448536269514722 * se, delta + 1.6448536269514722 * se]
	return {"equivalent": bool(p < alpha), "p": float(p),
	"ci90": [float(ci90[0]), float(ci90[1])]}


	def _norm_cdf(x: float) -> float:
	return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))


	def cluster_sign_flip(a_hits: np.ndarray, b_hits: np.ndarray, clusters: np.ndarray,
	n_perm: int = 10000, seed: int = SEED) -> dict:
	"""Permutation test at the clip level.

	McNemar assumes independent pairs, but five captions of one clip share their
	audio, so those five pairs are correlated and McNemar's p is anti-conservative.
	Here the labels are swapped per cluster: under the null the two checkpoints are
	exchangeable within a clip, so each clip contributes either +d or -d, where d is
	that clip's (b - a) contribution. Captions never move independently.
	"""
	uniq, inv = np.unique(clusters, return_inverse=True)
	sa = np.bincount(inv, weights=a_hits.astype(float), minlength=len(uniq))
	sb = np.bincount(inv, weights=b_hits.astype(float), minlength=len(uniq))
	d = sb - sa
	total = float(len(a_hits))
	obs = float(d.sum() / total)

	rng = np.random.default_rng(seed)
	hits = 0
	done = 0
	while done < n_perm:
	chunk = min(1000, n_perm - done)
	signs = rng.choice(np.array([-1.0, 1.0]), size=(chunk, len(uniq)))
	sims = signs @ d / total
	hits += int(np.sum(np.abs(sims) >= abs(obs) - 1e-15))
	done += chunk
	p = (1.0 + hits) / (n_perm + 1.0)
	return {"delta": obs, "p_cluster_perm": float(p),
	"n_permutations": n_perm, "n_clusters": int(len(uniq))}


	def mcnemar_exact(a_hits: np.ndarray, b_hits: np.ndarray) -> tuple[float, int, int]:
	"""Exact two-sided McNemar on paired binary outcomes.

	Returns (p, b_only, a_only) where b_only counts queries only b gets right.
	This is the difference test; TOST answers a different question and must not be
	substituted for it.
	"""
	n01 = int((~a_hits & b_hits).sum())
	n10 = int((a_hits & ~b_hits).sum())
	m = n01 + n10
	if m == 0:
	return 1.0, n01, n10
	tail = sum(math.comb(m, i) for i in range(0, min(n01, n10) + 1)) / 2 ** m
	return min(1.0, 2 * tail), n01, n10


	def holm(pvals: dict[str, float], alpha: float = 0.05) -> dict[str, float]:
	"""Holm-Bonferroni step-down. Returns adjusted p-values, monotone in the input."""
	items = sorted(pvals.items(), key=lambda kv: kv[1])
	m = len(items)
	adj, running = {}, 0.0
	for i, (name, p) in enumerate(items):
	val = min(1.0, (m - i) * p)
	running = max(running, val)
	adj[name] = running
	return adj


	def mdd(se: float, alpha: float = 0.05, power: float = 0.8) -> float:
	"""Minimum detectable difference at the given power (normal approximation)."""
	return float((1.959963984540054 + 0.8416212335729143) * se)


	# ---------------------------------------------------------------- loading

	def load_cell(path: Path) -> dict:
	d = json.loads(path.read_text(encoding="utf-8"))
	need = ("first_hit_rank", "cluster")
	if d["metrics"]["t2a"].get("cluster") is None:
	raise SystemExit(f"{path.name}: missing per-query clusters; rerun the cell")
	return d


	def arm(d: dict, direction: str, k: int):
	m = d["metrics"][direction]
	ranks = np.asarray(m["first_hit_rank"], dtype=np.int64)
	clusters = np.asarray(m["cluster"], dtype=np.int64)
	return np.array([_hit(r, k) for r in ranks]), clusters


	def summarise(d: dict, direction: str, k: int) -> dict:
	hits, clusters = arm(d, direction, k)
	lo, hi, se = cluster_bootstrap_mean(hits, clusters, lambda v: float(v.mean()))
	return {"value": float(hits.mean()), "ci95": [lo, hi], "se_cluster": se,
	"n_queries": int(len(hits)), "n_clusters": int(clusters.max() + 1)}


	def main() -> int:
	ap = argparse.ArgumentParser()
	ap.add_argument("dir", nargs="?", default="results_v2")
	ap.add_argument("--out", default="analysis_v2.json")
	ap.add_argument("--prereg", default="PREREGISTRATION.md")
	args = ap.parse_args()

	if not Path(args.prereg).exists():
	raise SystemExit("PREREGISTRATION.md missing: analysis must follow a committed plan")

	root = Path(args.dir)
	cells = {}
	for f in sorted(root.glob("*__canon.json")):
	d = load_cell(f)
	cells[(d["dataset"], d["model"])] = d

	models = sorted({m for (_, m) in cells})
	if len(models) != 2:
	raise SystemExit(f"expected two checkpoints, found {models}")

	report = {"prereg": args.prereg, "equivalence_margin": EQUIV_MARGIN,
	"cells": {}, "endpoints": {}}
	for ds in sorted({d for (d, _) in cells}):
	for m in models:
	key = f"{m}\|{ds}"
	report["cells"][key] = {
	"t2a_r1": summarise(cells[(ds, m)], "t2a", 1),
	"a2t_r1": summarise(cells[(ds, m)], "a2t", 1),
	"t2a_mrr": summarise_rank(cells[(ds, m)], "t2a"),
	"a2t_map": summarise_ap(cells[(ds, m)]),
	}

	fused = next(m for m in models if m.endswith("fused"))
	unfused = next(m for m in models if m.endswith("unfused"))
	pvals = {}
	for ds, direction, metric, role in ENDPOINTS:
	if (ds, fused) not in cells or (ds, unfused) not in cells:
	continue
	k = int(metric.split("@")[1])
	a, clusters = arm(cells[(ds, fused)], direction, k)
	b, _ = arm(cells[(ds, unfused)], direction, k)
	delta = float(b.mean() - a.mean())
	lo, hi, se = cluster_bootstrap_delta(a, b, clusters)
	eq = tost(delta, se)
	# difference test at the clip level: captions within a clip are correlated,
	# so McNemar's independent-pairs p is reported only for reference
	perm = cluster_sign_flip(a > 0.5, b > 0.5, clusters)
	mcn_p, n01, n10 = mcnemar_exact(a > 0.5, b > 0.5)
	name = f"{ds}_{direction}_{metric}"
	pvals[name] = perm["p_cluster_perm"]
	report["endpoints"][name] = {
	"role": role, "dataset": ds, "direction": direction, "metric": metric,
	"delta_unfused_minus_fused": delta,
	"ci95": [lo, hi], "se_cluster": se, "mdd80": mdd(se),
	"p_cluster_perm": perm["p_cluster_perm"],
	"n_permutations": perm["n_permutations"],
	"mcnemar_p_reference_only": mcn_p, "b_only": n01, "a_only": n10,
	"tost_p": eq["p"], "equivalent_at_margin": eq["equivalent"],
	"ci90_for_tost": eq["ci90"],
	}

	holm_adj = holm(pvals)
	for name, adj in holm_adj.items():
	report["endpoints"][name]["holm_adjusted_p"] = adj
	report["endpoints"][name]["significant_after_holm"] = bool(adj < 0.05)

	Path(args.out).write_text(json.dumps(report, indent=2), encoding="utf-8",
	newline="\n")

	print(f"{'endpoint':<24}{'delta':>8} {'95% CI':<19}{'perm p':>9}{'Holm':>8}"
	f"{'TOST':>8} verdict")
	for name, e in report["endpoints"].items():
	ci = f"[{e['ci95'][0]:+.3f}, {e['ci95'][1]:+.3f}]"
	if e["significant_after_holm"]:
	verdict = "difference"
	elif e["equivalent_at_margin"]:
	verdict = "equivalent within +/-0.03"
	else:
	verdict = "inconclusive"
	print(f"{name:<24}{e['delta_unfused_minus_fused']:>+8.3f} {ci:<19}"
	f"{e['p_cluster_perm']:>9.2g}{e['holm_adjusted_p']:>8.2g}"
	f"{e['tost_p']:>8.2g} {verdict}")
	print(f"\nwrote {args.out}")
	return 0


	def summarise_rank(d: dict, direction: str) -> dict:
	m = d["metrics"][direction]
	ranks = np.asarray(m["first_hit_rank"], dtype=np.float64)
	clusters = np.asarray(m["cluster"], dtype=np.int64)
	lo, hi, se = cluster_bootstrap_mean(ranks, clusters, lambda v: float((1.0 / v).mean()))
	return {"value": float((1.0 / ranks).mean()), "ci95": [lo, hi], "se_cluster": se}


	def summarise_ap(d: dict) -> dict:
	m = d["metrics"]["a2t"]
	ap = np.asarray(m["ap"], dtype=np.float64)
	clusters = np.asarray(m["cluster"], dtype=np.int64)
	lo, hi, se = cluster_bootstrap_mean(ap, clusters, lambda v: float(v.mean()))
	return {"value": float(ap.mean()), "ci95": [lo, hi], "se_cluster": se}


	if __name__ == "__main__":
	raise SystemExit(main())