exp2/code/knob_table.py

"""Selection lookup table (no training): kept-% <-> d_target at fixed acc-share, and acc-share <-> lambda_acc at fixed kept-%.
    python knob_table.py --trajs trajs_aloha_transfer_cube --out tables/transfer_cube
Definitions: acc-share = (lambda_acc * sum|a|) / (sum|dp| + lambda_acc * sum|a|) over all episodes (what fraction of 'information' comes from acceleration).
Pause frames = frames whose 10-frame smoothed secant < 1.5 deg (quiet holds)."""
import argparse, json, sys
from pathlib import Path
import numpy as np
from scipy.ndimage import gaussian_filter1d
sys.path.insert(0, "/workspace/isr/src/teleop_std_poc"); from isr_resample import isr_resample, _acceleration_magnitudes, _gripper_forced  # noqa

def load(trajs):
    eps = []
    for f in sorted(Path(trajs).glob("ep*.npz")):
        d = np.load(f); eps.append((d["positions"], d["timestamps"], d["gripper"]))
    return eps

def totals(eps):
    dp = sum(np.linalg.norm(np.diff(P, axis=0), axis=1).sum() for P, t, g in eps); acc = sum(_acceleration_magnitudes(P, t).sum() for P, t, g in eps); return dp, acc

def lam_for_share(share, dp, acc):   # share = lam*acc/(dp+lam*acc)  ->  lam = share*dp/((1-share)*acc)
    return 0.0 if share <= 0 else share * dp / ((1 - share) * acc)

def run(eps, d, lam, gthr):
    kept = 0; n = 0; forced = 0; hold_kept = 0; hold_n = 0
    for P, t, g in eps:
        k = isr_resample(P, t, g, d, 1.0, lam, gthr); kept += len(k); n += len(P); forced += len(_gripper_forced(g, len(P), gthr))
        Ps = gaussian_filter1d(P, 4, axis=0); w = 10; sec = np.linalg.norm(Ps[w:] - Ps[:-w], axis=1); hold = np.zeros(len(P), bool); hold[w // 2: w // 2 + len(sec)] = sec < 1.5
        m = np.zeros(len(P), bool); m[k] = True; hold_kept += m[hold].sum(); hold_n += hold.sum()
    return kept / n, kept, forced, (hold_kept / hold_n if hold_n else float("nan")), hold_n / n

def solve_d(eps, target, lam, gthr, lo=0.05, hi=60.0, it=18):
    for _ in range(it):
        mid = (lo * hi) ** 0.5; r = run(eps, mid, lam, gthr)[0]
        if r > target: lo = mid
        else: hi = mid
    return (lo * hi) ** 0.5

if __name__ == "__main__":
    ap = argparse.ArgumentParser(); ap.add_argument("--trajs", required=True); ap.add_argument("--out", required=True)
    ap.add_argument("--kept", default="20,30,40,50,60,70,80"); ap.add_argument("--shares", default="0,10,20,30,40"); ap.add_argument("--fixed-share", type=float, default=20); ap.add_argument("--fixed-kept", type=float, default=50)
    a = ap.parse_args(); out = Path(a.out); out.mkdir(parents=True, exist_ok=True); eps = load(a.trajs); dp, acc = totals(eps)
    idx = json.load(open(Path(a.trajs) / "index.json")); gthr = idx["calib"]["gripper_thr_5pct"]; med = idx["calib"]["median_step"]
    rows_d = []
    lam0 = lam_for_share(a.fixed_share / 100, dp, acc)
    for kp in [float(x) for x in a.kept.split(",")]:
        d = solve_d(eps, kp / 100, lam0, gthr); r = run(eps, d, lam0, gthr)
        rows_d.append(dict(target_kept=kp, kept=round(100 * r[0], 1), d_target=round(d, 4), d_over_median=round(d / med, 2), lambda_acc=round(lam0, 7), acc_share=a.fixed_share, frames=r[1], gripper_forced=r[2], hold_kept=round(100 * r[3], 1))); print(rows_d[-1], flush=True)
    rows_l = []
    for sh in [float(x) for x in a.shares.split(",")]:
        lam = lam_for_share(sh / 100, dp, acc); d = solve_d(eps, a.fixed_kept / 100, lam, gthr); r = run(eps, d, lam, gthr)
        rows_l.append(dict(acc_share=sh, lambda_acc=round(lam, 7), kept=round(100 * r[0], 1), d_target=round(d, 4), d_over_median=round(d / med, 2), frames=r[1], gripper_forced=r[2], hold_kept=round(100 * r[3], 1))); print(rows_l[-1], flush=True)
    uni = [dict(k=k, kept=round(100 * sum(len(range(0, len(P), k)) + 1 for P, t, g in eps) / sum(len(P) for P, t, g in eps), 1)) for k in (2, 3, 4, 5)]
    md = f"# Selection table — {a.trajs}\n\nmedian moving step {med:.3f}°, gripper_thr {gthr:.2f}°, quiet-hold frames = {100*r[4]:.1f} % of data. `hold_kept` = % of quiet-hold frames retained (uniform keeps them at the kept-%; ISR should keep fewer).\n\n"
    md += f"## A. kept-% sweep (acc-share fixed {a.fixed_share} %)\n\n| target kept | kept % | d_target (°) | d / median | λ_acc | frames | gripper-forced | hold kept % |\n|---|---|---|---|---|---|---|---|\n"
    md += "".join(f"| {r['target_kept']:.0f} | {r['kept']} | {r['d_target']} | {r['d_over_median']} | {r['lambda_acc']} | {r['frames']} | {r['gripper_forced']} | {r['hold_kept']} |\n" for r in rows_d)
    md += f"\n## B. acc-share sweep (kept fixed {a.fixed_kept} %)\n\n| acc-share % | λ_acc | kept % | d_target (°) | d / median | frames | gripper-forced | hold kept % |\n|---|---|---|---|---|---|---|---|\n"
    md += "".join(f"| {r['acc_share']:.0f} | {r['lambda_acc']} | {r['kept']} | {r['d_target']} | {r['d_over_median']} | {r['frames']} | {r['gripper_forced']} | {r['hold_kept']} |\n" for r in rows_l)
    md += "\n## C. uniform baselines\n\n| every k-th | kept % |\n|---|---|\n" + "".join(f"| {u['k']} | {u['kept']} |\n" for u in uni)
    (out / "table.md").write_text(md); json.dump(dict(kept_sweep=rows_d, share_sweep=rows_l, uniform=uni, median_step=med, gripper_thr=gthr), open(out / "table.json", "w"), indent=1); print(md)