| """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): |
| 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} |
|
|
|
|
| |
| 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): |
| 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): |
| run = max(run, min(1.0, (len(rows) - k) * rows[i]['p_perm'])); rows[i]['p_holm'] = round(run, 4) |
| phys_tests[t] = rows |
|
|
| |
| 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} |
| |
| 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]} |
| |
| 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)} |
| |
| 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) |
|
|
|
|
| |
| 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 = [] |
| 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()})}) |
|
|
| |
| 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)))} |
|
|
| |
| 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()})}}) |
|
|
| |
| 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']) |
|
|
