| """Per-scenario rank rule (the same rule as Case 1), pairwise win rates, Kendall tau and goal bootstrap. Sim2Sim. |
| |
| Times: array T[policy, goal, trial] in seconds, failure = HORIZON (40 s), so failures rank last and tie. |
| Rank rule: per (goal, trial) fractional ranks by time (1 = fastest, ties share the mean rank). |
| Policy score = mean rank, first over the trials of a goal, then over goals (equal goal weight). |
| Order = ascending mean rank. Win rate P(p beats q) = mean of 1[T_p < T_q] + 0.5 * 1[T_p == T_q]. |
| Bootstrap resamples goals (stratified by goal range), keeps all trials of a goal, and is paired across |
| methods (the same goal indices for ROM methods and Chrono). |
| """ |
| import numpy as np |
| from scipy.stats import rankdata |
|
|
| from common import HORIZON_S |
|
|
|
|
| def bounded(times, success): |
| t = np.where(success, times, HORIZON_S) |
| return np.minimum(np.nan_to_num(t, nan=HORIZON_S), HORIZON_S) |
|
|
|
|
| def per_goal_ranks(T): |
| """T[p, g, k] -> per-goal mean rank R[p, g] (fractional ranks within each (g, k)).""" |
| P, G, K = T.shape |
| r = rankdata(T.reshape(P, -1), axis=0, method='average').reshape(P, G, K) |
| return r.mean(2) |
|
|
|
|
| def per_goal_wins(T): |
| """W[p, q, g] = mean over trials of P(T_p < T_q) with ties 0.5.""" |
| lt = (T[:, None] < T[None, :]).astype(np.float64) |
| eq = (T[:, None] == T[None, :]).astype(np.float64) |
| return (lt + 0.5 * eq).mean(3) |
|
|
|
|
| def kendall_tau_b(a, b): |
| """Kendall tau-b between score vectors a[..., n] and b[..., n] (lower score = better; only sign matters).""" |
| i, j = np.triu_indices(a.shape[-1], 1) |
| sa = np.sign(a[..., i] - a[..., j]) |
| sb = np.sign(b[..., i] - b[..., j]) |
| n0 = len(i) |
| n1 = (sa == 0).sum(-1) |
| n2 = (sb == 0).sum(-1) |
| den = np.sqrt((n0 - n1) * (n0 - n2).astype(np.float64)) |
| with np.errstate(invalid='ignore', divide='ignore'): |
| return np.where(den > 0, (sa * sb).sum(-1) / den, np.nan) |
|
|
|
|
| def spearman(a, b): |
| ra = rankdata(a, axis=-1) |
| rb = rankdata(b, axis=-1) |
| ra = ra - ra.mean(-1, keepdims=True) |
| rb = rb - rb.mean(-1, keepdims=True) |
| with np.errstate(invalid='ignore', divide='ignore'): |
| return (ra * rb).sum(-1) / np.sqrt((ra ** 2).sum(-1) * (rb ** 2).sum(-1)) |
|
|
|
|
| def boot_indices(strata, B, seed): |
| """strata: array of stratum labels per goal. Returns (B, G) resampled goal indices, stratified.""" |
| rng = np.random.default_rng(seed) |
| strata = np.asarray(strata) |
| cols = [] |
| for s in np.unique(strata): |
| idx = np.flatnonzero(strata == s) |
| cols.append(idx[rng.integers(0, len(idx), (B, len(idx)))]) |
| return np.concatenate(cols, 1) |
|
|
|
|
| def ci(x, lo=2.5, hi=97.5): |
| x = np.asarray(x, dtype=np.float64) |
| x = x[np.isfinite(x)] |
| return [float(np.percentile(x, lo)), float(np.percentile(x, hi))] if len(x) else [None, None] |
|
|
|
|
| def summarize_method(T, success, policies, goal_range, boot=None): |
| """Success by range, mean rank, order, resolved pairs. T and success are [p, g, k].""" |
| R = per_goal_ranks(T) |
| mr = R.mean(1) |
| order = [policies[i] for i in np.argsort(mr, kind='stable')] |
| out = dict(mean_rank={p: float(mr[i]) for i, p in enumerate(policies)}, order=order) |
| gr = np.asarray(goal_range) |
| out['success_rate'] = {rng: {p: float(success[i][gr == rng].mean()) for i, p in enumerate(policies)} |
| for rng in sorted(set(gr))} |
| out['success_rate']['all'] = {p: float(success[i].mean()) for i, p in enumerate(policies)} |
| |
| allok = success.all(0) |
| out['common_success_units'] = int(allok.sum()) |
| out['mean_time_common_success'] = {p: (float(T[i][allok].mean()) if allok.any() else None) for i, p in enumerate(policies)} |
| if boot is not None: |
| W = per_goal_wins(T) |
| w = W.mean(2) |
| wb = W[:, :, boot].mean(3) |
| pairs = [] |
| for a in range(len(policies)): |
| for b in range(a + 1, len(policies)): |
| lo, hi = ci(wb[a, b]) |
| pairs.append(dict(a=policies[a], b=policies[b], win_a=float(w[a, b]), ci95=[lo, hi], |
| resolved=bool(lo > 0.5 or hi < 0.5))) |
| out['pairs'] = pairs |
| out['resolved_pairs'] = int(sum(p['resolved'] for p in pairs)) |
| mrb = R[:, boot].mean(2).T |
| out['mean_rank_ci95'] = {p: ci(mrb[:, i]) for i, p in enumerate(policies)} |
| return out |
|
|
|
|
| def compare_to_truth(methods, truth, boot): |
| """methods: dict name -> per-goal mean ranks R[p, g]; truth: R[p, g] (Chrono). Paired goal bootstrap.""" |
| t_mr = truth.mean(1) |
| t_b = truth[:, boot].mean(2).T |
| res = {} |
| taus_b = {} |
| for name, R in methods.items(): |
| mr = R.mean(1) |
| rb = R[:, boot].mean(2).T |
| tb = kendall_tau_b(rb, t_b) |
| taus_b[name] = tb |
| res[name] = dict(kendall_tau_b=float(kendall_tau_b(mr, t_mr)), kendall_ci95=ci(tb), |
| spearman=float(spearman(mr, t_mr)), spearman_ci95=ci(spearman(rb, t_b))) |
| return res, taus_b |
|
|
|
|
| def pair_agreement(R_method, R_base, R_truth, policies): |
| """Pairs where method and base disagree on order: how many does each get right relative to truth.""" |
| a, b, t = R_method.mean(1), R_base.mean(1), R_truth.mean(1) |
| i, j = np.triu_indices(len(policies), 1) |
| sm, sb, st = np.sign(a[i] - a[j]), np.sign(b[i] - b[j]), np.sign(t[i] - t[j]) |
| disc = (sm != sb) |
| return dict(pairs=int(len(i)), method_correct=int((sm == st).sum()), base_correct=int((sb == st).sum()), |
| discordant=int(disc.sum()), discordant_method_correct=int((disc & (sm == st)).sum()), |
| discordant_base_correct=int((disc & (sb == st)).sum())) |
|
|
