scripts/warfarin_gamma_sweep.py

"""Is the paper's ~0.35 warfarin error rate attainable by RCB?

RCB's error decomposes as
    err = P(explore off-greedy) * err_explore + P(play b_t) * err(b_t),
so it is bounded below by the accuracy of the offline oracle b_t itself. We sweep a
multiplier on the spread parameter gamma_m (gamma -> 0 = uniform exploration,
gamma -> inf = pure greedy on the oracle) and report where the paper's 0.35 sits.
"""
import argparse, json, os, sys, time
import numpy as np

os.chdir(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
from rcb.core import RCB, N_eps, L_eps
from rcb.env import build_warfarin
from scripts.run_warfarin import ground_truth, weighted_risk_score, effective_phi0


def offline_ceiling(X, arm, mu_opt, sigma, seed=0, lam=1e-2):
    """Accuracy of the per-arm ridge oracle fit on the ENTIRE dataset -- the best any
    policy using this oracle class can do (the paper's Lasso-Bandit dotted line)."""
    rng = np.random.default_rng(seed)
    n, d = X.shape
    bh = []
    for i in range(3):
        y = np.where(arm == i, mu_opt, 0.0) + sigma * rng.standard_normal(n)
        bh.append(np.linalg.solve(X.T @ X + lam * np.eye(d), X.T @ y))
    pred = (X @ np.array(bh).T).argmax(1)
    return float((pred == arm).mean()), pred


def run(X, arm, mu_opt, sigma, eps, pv, seed, gmul, N, phi0):
    rng = np.random.default_rng(seed)
    n, d = X.shape
    order = rng.permutation(n)
    beta0 = [np.zeros(d), 0.05 * np.ones(d), np.zeros(d)]
    S0 = [pv * np.eye(d) for _ in range(3)]
    a = RCB(3, d, sigma, beta0, S0, N=N, L=L_eps(eps, 0.005, 0.95), offset=0.0,
            phi0=phi0, trust_mode="linear", gamma_const=4.0 * gmul,
            use_empirical_EF=True, rng=rng)
    ok = np.zeros(n, bool); expl = []; bok = []; gains = []
    rec_by_patient = np.empty(n, int)
    for t, idx in enumerate(order):
        x = X[idx]
        rec, info = a.recommend(x)
        rec_by_patient[idx] = rec
        gains.append(a.dbic_gain_expected(x, a.rec_kernel(x, info)))
        ok[t] = rec == arm[idx]
        if info["phase"] == "IPGS":
            expl.append(rec != info["b"]); bok.append(info["b"] == arm[idx])
        y = (mu_opt[idx] if ok[t] else 0.0) + sigma * rng.standard_normal()
        a.update(x, rec, y, info)
    return dict(err=float(1 - ok.mean()), explore=float(np.mean(expl)),
                b_acc=float(np.mean(bok)), Tcold=a.Tcold,
                gain_min=float(np.min(gains)), gain_mean=float(np.mean(gains)),
                rec=rec_by_patient)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--data", default="data/iwpc_warfarin_5528.csv")
    ap.add_argument("--out", default="outputs/warfarin_gamma_sweep.json")
    ap.add_argument("--perms", type=int, default=5)
    ap.add_argument("--N", type=int, default=10)
    args = ap.parse_args()

    X, arm, dose, cols = build_warfarin(args.data)
    _, mu_opt, _, sigma = ground_truth(X, arm, dose)
    n, d = X.shape
    prev = np.bincount(arm, minlength=3) / n
    phi0 = effective_phi0(X)

    acc_ceiling, pred = offline_ceiling(X, arm, mu_opt, sigma)
    print(f"offline ridge-oracle ceiling: accuracy={acc_ceiling:.3f} error={1-acc_ceiling:.3f} "
          f"score={weighted_risk_score(pred == arm, arm, prev):.3f}")
    print(f"physician (always Medium):    error={1-(arm==1).mean():.3f} "
          f"score={weighted_risk_score(arm == 1, arm, prev):.3f}")

    res = {"ceiling_error": 1 - acc_ceiling,
           "ceiling_score": weighted_risk_score(pred == arm, arm, prev),
           "physician_error": float(1 - (arm == 1).mean()),
           "physician_score": weighted_risk_score(arm == 1, arm, prev),
           "prevalence": prev.tolist(), "sweep": []}

    t0 = time.time()
    for gmul in [0.25, 1.0, 4.0, 16.0, 64.0, 256.0, 1e4]:
        rs = [run(X, arm, mu_opt, sigma, 0.025, 0.4, 1000 * p + 7, gmul, args.N, phi0)
              for p in range(args.perms)]
        sc = float(np.mean([weighted_risk_score(r["rec"] == arm, arm, prev) for r in rs]))
        e = dict(gamma_mult=gmul, error=float(np.mean([r["err"] for r in rs])),
                 explore=float(np.mean([r["explore"] for r in rs])),
                 b_acc=float(np.mean([r["b_acc"] for r in rs])), score=sc,
                 gain_min=float(np.mean([r["gain_min"] for r in rs])))
        res["sweep"].append(e)
        print(f"gamma x{gmul:<8g} error={e['error']:.3f} explore={e['explore']:.3f} "
              f"b_acc={e['b_acc']:.3f} score={sc:+.3f} min-gain={e['gain_min']:+.4f}")
    res["wall_clock_s"] = time.time() - t0
    os.makedirs(os.path.dirname(args.out), exist_ok=True)
    json.dump(res, open(args.out, "w"))
    print(f"wrote {args.out}  [{res['wall_clock_s']:.0f}s]")


if __name__ == "__main__":
    main()