Blame for code/case1/analysis/case1_rank_analysis.py

"""Case 1 (ART) analysis under the per-start rank rule: Tables I, IV and V, sensitivity, physical pair tests.

TR logs (Chrono digital twin): B01 (S2, 400 starts, logged 40 s), B06 (S0/S1/S3/S4, 200 starts each), B07 (S2 starts
with the channel conditions D1a-D5, 200 starts each); per-start metrics from the extract stage. Physical reference
(Sim2Real): physical_runs.csv, mean of the per-run MAEs (5 runs per path and controller). NN-HD column of the TR
order: ctrl_label nnhdx175 for Path 1-2 targets and nnhdx150 for Path 3 targets. Baseline orders (nominal
simulation, Monte Carlo RF-A/RF-B, nominal simulation of Tables II-III) from baseline_orders.json.

Usage: python case1_rank_analysis.py <per_start_dir> <physical_runs.csv> <baseline_orders.json> <out_dir>
"""
import csv, glob, gzip, itertools, json, math, sys
import numpy as np

PER_START, PHYS_CSV, BASE_JSON, OUT = sys.argv[1:5]
RNG = np.random.default_rng(20261105)
B = 2000
BASE = ('mpc', 'nnmpc', 'pid')
LBL = {'mpc': 'MPC', 'nnmpc': 'NN-MPC', 'pid': 'PID', 'nnhd': 'NN-HD'}
ITEMS = ('mpc', 'nnmpc', 'pid', 'nnhd')
TARGETS = ('P1_lateral', 'P1_heading', 'P2_lateral', 'P2_heading', 'P3_lateral', 'P3_heading')
GAIN = {'P1': 'nnhdx175', 'P2': 'nnhdx175', 'P3': 'nnhdx150'}


def load(batch, col_fn):
    """scenario key -> {ctrl_label: row}"""
    d = {}
    for f in glob.glob(f'{PER_START}/{batch}/recovery_part*.csv.gz'):
        for r in csv.DictReader(gzip.open(f, 'rt')):
            d.setdefault((r['tag_family'], r['tag_condition'], r['scenario_id']), {})[r['ctrl_label']] = r
    return d


B01, B06, B07 = load('B01_main_tr', None), load('B06_severity_shape', None), load('B07_dist_recovery', None)


def times(d, fam, cond, L='L010', Hd='H010', H=25.0, gain='nnhdx175', ids=None):
    """N x 4 array of first tube-entry times (capped at H), columns ITEMS; NN-HD column uses `gain`."""
    col = f'T{25 if H <= 25 else 40}_trk100_{L}{Hd}_first'
    rows, keys = [], []
    for (f, c, sid), v in sorted(d.items()):
        if f != fam or c != cond or not all(k in v for k in BASE + (gain,)):
            continue
        if ids is not None and sid not in ids:
            continue
        rows.append([min(float(v[k][col]), H) for k in BASE + (gain,)]); keys.append(sid)
    return np.array(rows), keys


def ranks(T):
    """per-start ranks with shared ties (1 = fastest)"""
    less = (T[:, None, :] < T[:, :, None]).sum(2)
    eq = (T[:, None, :] == T[:, :, None]).sum(2) - 1
    return 1 + less + eq / 2.0


def order_of(score):  # ITEMS sorted by ascending score
    return [ITEMS[i] for i in np.argsort(score, kind='stable')]


def tau(a, b):
    pa = {c: i for i, c in enumerate(a)}; pb = {c: i for i, c in enumerate(b)}
    s = sum(np.sign((pa[x] - pa[y]) * (pb[x] - pb[y])) for x, y in itertools.combinations(ITEMS, 2))
    return s / 6.0


def summary(T, H):
    R = ranks(T); n = len(T)
    fail = (T >= H)
    ok = ~fail.any(1)
    rank_pct = {}
    for j, c in enumerate(ITEMS):
        cnt = np.zeros(4)
        for row_t in T:
            lo = 1 + (row_t < row_t[j]).sum(); k = (row_t == row_t[j]).sum()
            cnt[lo - 1:lo - 1 + k] += 1.0 / k
        rank_pct[LBL[c]] = [round(100 * x / n, 1) for x in cnt]
    win = {}
    for i, j in itertools.combinations(range(4), 2):
        w = (T[:, i] < T[:, j]) + 0.5 * (T[:, i] == T[:, j])
        bs = [w[RNG.integers(0, n, n)].mean() for _ in range(B)]
        win[f'{LBL[ITEMS[i]]} beats {LBL[ITEMS[j]]}'] = [round(w.mean(), 3), [round(float(np.percentile(bs, 2.5)), 3), round(float(np.percentile(bs, 97.5)), 3)]]
    return {'n': n, 'order': [LBL[c] for c in order_of(R.mean(0))],
            'mean_rank': {LBL[c]: round(float(R.mean(0)[j]), 2) for j, c in enumerate(ITEMS)},
            'rank_pct': rank_pct,
            'fail_pct': {LBL[c]: round(100 * float(fail[:, j].mean()), 1) for j, c in enumerate(ITEMS)},
            'n_all_recover': int(ok.sum()),
            'mean_st_all_recover': {LBL[c]: round(float(T[ok, j].mean()), 2) for j, c in enumerate(ITEMS)},
            'pairwise_win_rate_ci95': win}


# ---------------- physical reference ----------------
phys = {}
for r in csv.DictReader(open(PHYS_CSV)):
    c = {'MPC': 'mpc', 'NN-MPC': 'nnmpc', 'PID': 'pid', 'NN-HD': 'nnhd'}[r['controller']]
    phys.setdefault(f"{r['path']}_lateral", {}).setdefault(c, []).append(float(r['run_mae_lateral_m']))
    phys.setdefault(f"{r['path']}_heading", {}).setdefault(c, []).append(float(r['run_mae_heading_rad']))
phys = {t: {c: np.array(v) for c, v in phys[t].items()} for t in TARGETS}
phys_order = {t: order_of(np.array([phys[t][c].mean() for c in ITEMS])) for t in TARGETS}


def phys_boot():
    return {t: order_of(np.array([RNG.choice(phys[t][c], len(phys[t][c])).mean() for c in ITEMS])) for t in TARGETS}


def perm_p(a, b):  # exact two-sided permutation test on the difference of means
    x = np.concatenate([a, b]); n = len(a); obs = abs(a.mean() - b.mean()); cnt = tot = 0
    for idx in itertools.combinations(range(len(x)), n):
        m = np.zeros(len(x), bool); m[list(idx)] = True
        cnt += abs(x[m].mean() - x[~m].mean()) >= obs - 1e-12; tot += 1
    return cnt / tot


phys_tests = {}
for t in TARGETS:
    rows = []
    for a, b in itertools.combinations(ITEMS, 2):
        rows.append({'pair': f'{LBL[a]} vs {LBL[b]}', 'mean_a': round(float(phys[t][a].mean()), 4),
                     'mean_b': round(float(phys[t][b].mean()), 4), 'p_perm': round(perm_p(phys[t][a], phys[t][b]), 4)})
    ps = sorted(range(len(rows)), key=lambda i: rows[i]['p_perm']); run = 0.0
    for k, i in enumerate(ps):  # Holm step-down adjustment across the 6 pairs of this target
        run = max(run, min(1.0, (len(rows) - k) * rows[i]['p_perm'])); rows[i]['p_holm'] = round(run, 4)
    phys_tests[t] = rows

# ---------------- methods: TR (rank rule) and baselines ----------------
TS2 = {g: times(B01, 'S2', 'none', H=25.0, gain=g)[0] for g in ('nnhdx175', 'nnhdx150')}
RS2 = {g: ranks(T) for g, T in TS2.items()}
tr_order = {t: order_of(RS2[GAIN[t[:2]]].mean(0)) for t in TARGETS}
base = json.load(open(BASE_JSON))
methods = {'TR (rank rule, S2)': tr_order}
for m, name in (('M-NOM', 'Nominal simulation'), ('NOM-archived-2024', 'Nominal simulation (2024 archive)'),
                ('RF-A', 'Monte Carlo, start jitter (RF-A)'), ('RF-B', 'Monte Carlo, jitter + disturbances (RF-B)')):
    methods[name] = {t: base[m][t]['predicted_ordering'] for t in TARGETS}

boot_phys = [phys_boot() for _ in range(B)]
n = len(RS2['nnhdx175'])
boot_tr = []
for _ in range(B):
    idx = RNG.integers(0, n, n)
    boot_tr.append({t: order_of(RS2[GAIN[t[:2]]][idx].mean(0)) for t in TARGETS})


def ci(v):
    return [round(float(np.percentile(v, 2.5)), 2), round(float(np.percentile(v, 97.5)), 2)]


compare = {}
for name, ords in methods.items():
    taus = {t: tau(ords[t], phys_order[t]) for t in TARGETS}
    bt = {t: [tau((boot_tr[b][t] if name.startswith('TR') else ords[t]), boot_phys[b][t]) for b in range(B)] for t in TARGETS}
    bmean = [np.mean([bt[t][b] for t in TARGETS]) for b in range(B)]
    sel = {t: ords[t][0] for t in TARGETS}
    regret = {t: round(float(phys[t][sel[t]].mean() / min(phys[t][c].mean() for c in ITEMS)), 2) for t in TARGETS}
    # concordance on physically resolved pairs (Holm-adjusted permutation p < 0.05)
    conc = tot = 0
    for t in TARGETS:
        for r_ in phys_tests[t]:
            if r_['p_holm'] < 0.05:
                a, b = (next(k for k in ITEMS if LBL[k] == s) for s in r_['pair'].split(' vs '))
                pa = ords[t].index(a) < ords[t].index(b); pp = phys_order[t].index(a) < phys_order[t].index(b)
                conc += pa == pp; tot += 1
    compare[name] = {'order': {t: [LBL[c] for c in ords[t]] for t in TARGETS},
                     'tau': {t: round(taus[t], 2) for t in TARGETS}, 'tau_ci95': {t: ci(bt[t]) for t in TARGETS},
                     'mean_tau': round(float(np.mean(list(taus.values()))), 2), 'mean_tau_ci95': ci(bmean),
                     'exact_order_matches': int(sum(v == 1 for v in taus.values())),
                     'best_selected': int(sum(sel[t] == phys_order[t][0] for t in TARGETS)),
                     'selected_error_ratio_to_best': regret,
                     'resolved_pairs_correct': [conc, tot]}
# paired difference TR - nominal in mean tau
bt_tr = [np.mean([tau(boot_tr[b][t], boot_phys[b][t]) for t in TARGETS]) for b in range(B)]
bt_nom = [np.mean([tau(methods['Nominal simulation'][t], boot_phys[b][t]) for t in TARGETS]) for b in range(B)]
d = np.array(bt_tr) - np.array(bt_nom)
compare_delta = {'TR minus nominal, mean tau': round(compare['TR (rank rule, S2)']['mean_tau'] - compare['Nominal simulation']['mean_tau'], 2),
                 'ci95': ci(d)}
# same for the nominal simulation of Tables II-III (the paper's nominal baseline; no new random draws)
NOM_T = 'Nominal simulation (2024 archive)'
bt_nom_t = [np.mean([tau(methods[NOM_T][t], boot_phys[b][t]) for t in TARGETS]) for b in range(B)]
d_t = np.array(bt_tr) - np.array(bt_nom_t)
pt_t = np.mean([tau(tr_order[t], phys_order[t]) for t in TARGETS]) - np.mean([tau(methods[NOM_T][t], phys_order[t]) for t in TARGETS])
compare_delta_tables = {'TR minus nominal (Tables II-III), mean tau': round(float(pt_t), 2), 'ci95': ci(d_t),
                        'min': round(float(d_t.min()), 2), 'share_of_replicates_gt_0': float(np.mean(d_t > 0))}


def mean_tau(R_by_gain):
    return round(float(np.mean([tau(order_of(R_by_gain[GAIN[t[:2]]].mean(0)), phys_order[t]) for t in TARGETS])), 2)


# ---------------- Table I offset sweep ----------------
sweep = []
for fam, d_, H in (('S0', B06, 25.0), ('S1', B06, 25.0), ('S2', B01, 25.0), ('S3', B06, 25.0), ('S4', B06, 25.0)):
    T = {g: times(d_, fam, 'none', H=H, gain=g)[0] for g in ('nnhdx175', 'nnhdx150')}
    s = summary(T['nnhdx175'], H); s['range'] = fam
    s['mean_tau_vs_physical'] = mean_tau({g: ranks(v) for g, v in T.items()})
    sweep.append(s)

# ---------------- tube and horizon sensitivity (S2) ----------------
tube = []
for L in ('L005', 'L010', 'L020'):
    for Hd in ('H005', 'H010', 'H020'):
        for H in (15.0, 25.0, 40.0):
            T = {g: times(B01, 'S2', 'none', L, Hd, H, g)[0] for g in ('nnhdx175', 'nnhdx150')}
            R = ranks(T['nnhdx175'])
            tube.append({'tube_lat_m': int(L[1:]) / 100, 'tube_head_rad': int(Hd[1:]) / 100, 'H_s': H,
                         'order': [LBL[c] for c in order_of(R.mean(0))],
                         'mpc_first_pct': round(100 * float((R[:, 0] == 1).mean()), 1),
                         'fail_pct': {LBL[c]: round(100 * float((T['nnhdx175'][:, j] >= H).mean()), 1) for j, c in enumerate(ITEMS)},
                         'mean_tau_vs_physical': mean_tau({g: ranks(v) for g, v in T.items()})})

# ---------------- number of trials ----------------
R = RS2['nnhdx175']; full = order_of(R.mean(0)); nsens = []
for N in (10, 25, 50, 100, 200, 400):
    same = top = 0
    for _ in range(B):
        idx = RNG.choice(n, N, replace=False); o = order_of(R[idx].mean(0))
        same += o == full; top += o[0] == 'mpc'
    nsens.append({'N': N, 'p_same_order_as_400': round(same / B, 3), 'p_mpc_first': round(top / B, 3)})
mr = np.sort(R.mean(0)); gap = float(np.min(np.diff(mr)))
hoeff = {'loss': 'per-start rank, bounded in [1, 4] (B = 3)', 'K': 4, 'alpha': 0.05,
         'smallest_adjacent_mean_rank_gap_at_N400': round(gap, 3),
         'n_bound': int(math.ceil(2 * 9 / gap ** 2 * math.log(2 * 4 / 0.05)))}

# ---------------- ablation by channel (B07, CRN starts of B01) ----------------
CH = {'D1a': 'actuation: +0.10 s delay', 'D1b': 'actuation: +0.20 s delay', 'D2a': 'actuation: steering bias 0.013',
      'D2b': 'actuation: steering bias 0.026', 'D3a': 'observation: pose noise 0.02 m / 0.01 rad',
      'D3b': 'observation: pose noise 0.05 m / 0.03 rad', 'D4a': 'plant: friction 0.6', 'D4b': 'plant: friction 0.4',
      'D5': 'combined D1a + D2a + D3a'}
abl = []
ids = None
for cond, desc in CH.items():
    T = {g: times(B07, 'S2', cond, H=25.0, gain=g) for g in ('nnhdx175', 'nnhdx150')}
    keys = {k.split('_', 1)[1] for k in T['nnhdx175'][1]}
    T0 = {g: times(B01, 'S2', 'none', H=25.0, gain=g, ids=keys)[0] for g in ('nnhdx175', 'nnhdx150')}
    s = summary(T['nnhdx175'][0], 25.0)
    abl.append({'condition': cond, 'channel': desc, 'n': s['n'], 'order': s['order'], 'mean_rank': s['mean_rank'],
                'fail_pct': s['fail_pct'], 'mpc_first_pct': s['rank_pct']['MPC'][0],
                'mean_tau_vs_physical': mean_tau({g: ranks(v[0]) for g, v in T.items()}),
                'same_starts_no_disturbance': {'order': [LBL[c] for c in order_of(ranks(T0['nnhdx175']).mean(0))],
                                               'mean_tau_vs_physical': mean_tau({g: ranks(v) for g, v in T0.items()})}})

# MPC failures by start pose: see mpc_failures/d3_range.py (all 29 divergences start beyond the cost ridge).
res = {'label': 'Case 1 analysis. TR rows: Chrono digital-twin recovery tests; physical reference: archived physical runs (Sim2Real). Rule: per-start rank.',
       'physical_order': {t: [LBL[c] for c in o] for t, o in phys_order.items()},
       'physical_pairwise_tests': phys_tests, 'method_comparison': compare, 'tr_minus_nominal': compare_delta, 'tr_minus_nominal_tables_II_III': compare_delta_tables,
       'offset_sweep': sweep, 'tube_horizon_sensitivity': tube, 'trial_number_sensitivity': nsens,
       'hoeffding': hoeff, 'ablation_by_channel': abl, 'bootstrap_B': B}
json.dump(res, open(f'{OUT}/case1_rank_analysis.json', 'w'), indent=1)
print(json.dumps({k: res[k] for k in ('physical_order', 'tr_minus_nominal', 'tr_minus_nominal_tables_II_III', 'hoeffding')}, indent=1))
for name, v in compare.items():
    print(name, v['mean_tau'], v['mean_tau_ci95'], 'exact', v['exact_order_matches'], 'best', v['best_selected'], 'pairs', v['resolved_pairs_correct'], v['selected_error_ratio_to_best'])
for s in sweep:
    print(s['range'], s['n'], '>'.join(s['order']), 'fail', s['fail_pct'], 'tau', s['mean_tau_vs_physical'], 'MPC1st', s['rank_pct']['MPC'][0])
for s in tube:
    print(s['tube_lat_m'], s['tube_head_rad'], s['H_s'], '>'.join(s['order']), s['mpc_first_pct'], s['mean_tau_vs_physical'])
print(nsens)
for a in abl:
    print(a['condition'], a['channel'], '>'.join(a['order']), a['mpc_first_pct'], a['fail_pct'], a['mean_tau_vs_physical'], a['same_starts_no_disturbance'])