| |
| """exp02_cs_coverage -- empirical anytime-valid coverage of the lifted welfare |
| confidence sequence (Claim 1 / Theorem 4.1) and the fixed-policy corollary |
| (specs/exp02_cs_coverage.md). No dataset (paper is fully simulated). |
| """ |
|
|
| import argparse |
| import json |
| import math |
| import os |
| import sys |
| import time |
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
|
|
| import numpy as np |
|
|
| from core import cs |
| from core.instance import gini_w, make_instance |
| from core.oracles import oracle |
| from core.parallel import run_grid |
| from core.rounding import dependent_round |
| from core.swf import swf |
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| RESULTS_PATH = os.path.join(ROOT, "results", "exp02.json") |
|
|
| SEED_BASE = 10_000 |
| N = 20 |
| TOL = 1e-9 |
|
|
| |
| FULL_GRID = [("wpm", "-inf"), ("wpm", -2.0), ("wpm", 0.0), ("wpm", 1.0), |
| ("kolm", "-inf"), ("kolm", -2.0), ("kolm", 0.0), ("gini", None)] |
| FULL_KS = [1, 5, 10] |
| FULL_DELTAS = [0.1, 0.25] |
|
|
| R_CANDIDATES_FULL = [2000, 1000, 500] |
| WALL_BUDGET_SEC = 3 * 3600 |
|
|
|
|
| def log(msg): |
| print(f"[exp02] {msg}", file=sys.stderr, flush=True) |
|
|
|
|
| def qlabel(q): |
| if q is None: |
| return None |
| if isinstance(q, str): |
| return q |
| return float(q) |
|
|
|
|
| def make_t_grid(T, n_points): |
| pts = np.unique(np.round(np.geomspace(1, T, n_points)).astype(int)) |
| pts = pts[(pts >= 1) & (pts <= T)] |
| if pts[0] != 1: |
| pts = np.concatenate(([1], pts)) |
| if pts[-1] != T: |
| pts = np.concatenate((pts, [T])) |
| return sorted(int(t) for t in np.unique(pts)) |
|
|
|
|
| |
|
|
| def simulate_replicate(mu, alpha, beta, w, family, q, k, p_star, W_star, T, delta, seed, t_grid): |
| n = len(mu) |
| rng = np.random.default_rng(seed) |
| init_rounds = math.ceil(n / k) |
| p_fix = np.full(n, k / n) |
| W_fix_true = swf(mu * p_fix, family, w, q) |
|
|
| mu_up = np.full(n, cs.U_MAX) |
| mu_low = np.full(n, cs.U_MIN) |
| N_i = np.zeros(n) |
| mu_hat = np.zeros(n) |
|
|
| L = len(t_grid) |
| pointwise_miss = np.zeros(L, dtype=bool) |
| running_missed = np.zeros(L, dtype=bool) |
| width_at_grid = np.zeros(L, dtype=float) |
| gi = 0 |
|
|
| missed_so_far = False |
| link_ever_bad = {"i": False, "ii": False, "iii": False, "iv": False} |
| fixed_ever_bad = False |
|
|
| for t in range(1, T + 1): |
| p_up_t = oracle(mu_up, family, w, q, k) |
| p_low_t = oracle(mu_low, family, w, q, k) |
| W_up_t = swf(mu_up * p_up_t, family, w, q) |
| W_low_t = swf(mu_low * p_low_t, family, w, q) |
| covered_t = (W_low_t <= W_star + TOL) and (W_up_t >= W_star - TOL) |
| if not covered_t: |
| missed_so_far = True |
|
|
| swf_mu_p_low = swf(mu * p_low_t, family, w, q) |
| swf_muup_p_star = swf(mu_up * p_star, family, w, q) |
| if not (W_star >= swf_mu_p_low - TOL): |
| link_ever_bad["i"] = True |
| if not (swf_mu_p_low >= W_low_t - TOL): |
| link_ever_bad["ii"] = True |
| if not (swf_muup_p_star >= W_star - TOL): |
| link_ever_bad["iii"] = True |
| if not (W_up_t >= swf_muup_p_star - TOL): |
| link_ever_bad["iv"] = True |
|
|
| W_fix_low = swf(mu_low * p_fix, family, w, q) |
| W_fix_up = swf(mu_up * p_fix, family, w, q) |
| if not (W_fix_low <= W_fix_true + TOL and W_fix_up >= W_fix_true - TOL): |
| fixed_ever_bad = True |
|
|
| if gi < L and t == t_grid[gi]: |
| pointwise_miss[gi] = not covered_t |
| running_missed[gi] = missed_so_far |
| width_at_grid[gi] = W_up_t - W_low_t |
| gi += 1 |
|
|
| if t <= init_rounds: |
| idx = [((t - 1) * k + j) % n for j in range(k)] |
| S_t = np.array(idx, dtype=int) |
| else: |
| S_t = np.nonzero(dependent_round(p_up_t, rng))[0] |
|
|
| for i in S_t: |
| N_old = N_i[i] |
| u_ti = 0.1 + 0.9 * rng.beta(alpha[i], beta[i]) |
| mu_hat[i] = (N_old * mu_hat[i] + u_ti) / (N_old + 1.0) |
| N_i[i] = N_old + 1.0 |
| mu_up[i] = float(np.clip(cs.update_up(mu_hat[i], N_old, n, delta), cs.U_MIN, cs.U_MAX)) |
| mu_low[i] = float(np.clip(cs.update_low(mu_hat[i], N_old, n, delta), cs.U_MIN, cs.U_MAX)) |
|
|
| return dict( |
| any_miss=missed_so_far, |
| pointwise_miss=pointwise_miss, |
| running_missed=running_missed, |
| width_at_grid=width_at_grid, |
| link_ever_bad=link_ever_bad, |
| fixed_ever_bad=fixed_ever_bad, |
| ) |
|
|
|
|
| def simulate_chunk(mu, alpha, beta, w, family, q, k, p_star, W_star, T, delta, seeds, t_grid): |
| L = len(t_grid) |
| sum_any_miss = 0 |
| sum_pointwise = np.zeros(L) |
| sum_running = np.zeros(L) |
| sum_width = np.zeros(L) |
| sum_link = {"i": 0, "ii": 0, "iii": 0, "iv": 0} |
| sum_fixed = 0 |
| for seed in seeds: |
| res = simulate_replicate(mu, alpha, beta, w, family, q, k, p_star, W_star, T, delta, seed, t_grid) |
| sum_any_miss += int(res["any_miss"]) |
| sum_pointwise += res["pointwise_miss"] |
| sum_running += res["running_missed"] |
| sum_width += res["width_at_grid"] |
| for key in sum_link: |
| sum_link[key] += int(res["link_ever_bad"][key]) |
| sum_fixed += int(res["fixed_ever_bad"]) |
| return dict(n=len(seeds), sum_any_miss=sum_any_miss, sum_pointwise=sum_pointwise.tolist(), |
| sum_running=sum_running.tolist(), sum_width=sum_width.tolist(), |
| sum_link=sum_link, sum_fixed=sum_fixed) |
|
|
|
|
| def combine_chunks(chunk_results, t_grid, family, q, k, delta, W_star): |
| R = sum(c["n"] for c in chunk_results) |
| sum_any_miss = sum(c["sum_any_miss"] for c in chunk_results) |
| sum_pointwise = np.sum([c["sum_pointwise"] for c in chunk_results], axis=0) |
| sum_running = np.sum([c["sum_running"] for c in chunk_results], axis=0) |
| sum_width = np.sum([c["sum_width"] for c in chunk_results], axis=0) |
| sum_link = {key: sum(c["sum_link"][key] for c in chunk_results) for key in ("i", "ii", "iii", "iv")} |
| sum_fixed = sum(c["sum_fixed"] for c in chunk_results) |
|
|
| anytime_miss_rate = sum_any_miss / R |
| anytime_miss_se = math.sqrt(anytime_miss_rate * (1.0 - anytime_miss_rate) / R) |
| pointwise_miss_rate = (sum_pointwise / R).tolist() |
| running_miss_rate = (sum_running / R).tolist() |
| mean_width = (sum_width / R).tolist() |
| link_miss_rates = {key: sum_link[key] / R for key in sum_link} |
| fixed_policy_anytime_miss_rate = sum_fixed / R |
|
|
| t_arr = np.array(t_grid, dtype=float) |
| mw_arr = np.array(mean_width, dtype=float) |
| last_decade = t_arr >= (t_arr[-1] / 10.0) |
| if last_decade.sum() < 2: |
| last_decade = np.ones_like(t_arr, dtype=bool) |
| slope, _ = np.polyfit(np.log(t_arr[last_decade]), np.log(np.maximum(mw_arr[last_decade], 1e-300)), 1) |
|
|
| return { |
| "family": family, "q": qlabel(q), "k": k, "delta": delta, "R": R, |
| "anytime_miss_rate": anytime_miss_rate, "anytime_miss_se": anytime_miss_se, |
| "running_miss_rate": running_miss_rate, |
| "pointwise_miss_rate": pointwise_miss_rate, |
| "link_miss_rates": link_miss_rates, |
| "fixed_policy_anytime_miss_rate": fixed_policy_anytime_miss_rate, |
| "mean_width": mean_width, |
| "width_decay_alpha": float(slope), |
| "W_star": float(W_star), |
| } |
|
|
|
|
| |
|
|
| def build_cells(toy): |
| if toy: |
| combos = [("wpm", "-inf"), ("wpm", 0.0), ("kolm", -2.0), ("gini", None)] |
| ks, deltas = [1, 5], [0.1] |
| T, R, n_grid_points, chunk_size = 60, 25, 8, 10 |
| else: |
| combos = FULL_GRID |
| ks, deltas = FULL_KS, FULL_DELTAS |
| T, R, n_grid_points, chunk_size = 2000, 2000, 40, 50 |
| cells = [(f, q, k, d) for f, q in combos for k in ks for d in deltas] |
| return cells, T, R, n_grid_points, chunk_size |
|
|
|
|
| def calibrate_and_pick_R(mu, alpha, beta, pstar_cache, cells_spec, T, n_jobs, candidates): |
| T_probe = 100 |
| probe_grid = make_t_grid(T_probe, 5) |
| combos = sorted(set((f, qlabel(q), k) for f, q, k, d in cells_spec), |
| key=lambda c: (c[0], str(c[1]), c[2])) |
| step_time = {} |
| for family, qk, k in combos: |
| q_actual = next(q for f, q, kk, d in cells_spec if f == family and qlabel(q) == qk and kk == k) |
| p_star, W_star, w_eff = pstar_cache[(family, qk, k)] |
| t0 = time.time() |
| simulate_replicate(mu, alpha, beta, w_eff, family, q_actual, k, p_star, W_star, |
| T_probe, 0.1, 999_999, probe_grid) |
| dt = (time.time() - t0) / T_probe |
| step_time[(family, qk, k)] = dt |
| log(f"calibration family={family} q={qk} k={k}: {dt * 1e6:.2f} us/step") |
|
|
| total_step_time = sum(step_time[(f, qlabel(q), k)] for f, q, k, d in cells_spec) |
| note = None |
| chosen = candidates[-1] |
| for R_cand in candidates: |
| projected = total_step_time * T * R_cand / n_jobs |
| log(f"projected wall time for R={R_cand}: {projected / 3600:.2f} h") |
| if projected <= WALL_BUDGET_SEC: |
| chosen = R_cand |
| if R_cand < candidates[0]: |
| note = (f"R reduced from {candidates[0]} to {R_cand}: projected wall time at " |
| f"R={candidates[0]} exceeded the {WALL_BUDGET_SEC / 3600:.0f}h budget") |
| break |
| else: |
| chosen = candidates[-1] |
| projected = total_step_time * T * chosen / n_jobs |
| note = (f"R reduced to floor {chosen}; projected wall time still " |
| f"{projected / 3600:.2f}h, exceeds {WALL_BUDGET_SEC / 3600:.0f}h budget") |
| return chosen, note |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--toy", action="store_true") |
| args = ap.parse_args() |
| t0 = time.time() |
|
|
| n_jobs = max(1, min(int(os.environ.get("JOB_CORES", "4")), 12)) |
| log(f"JOB_CORES(n_jobs)={n_jobs} numpy={np.__version__} toy={args.toy}") |
|
|
| instance = make_instance(n=N, weight_decay="exp", seed=0) |
| mu, alpha, beta, w = instance["mu"], instance["alpha"], instance["beta"], instance["w"] |
| log(f"instance built: n={N}, mu[:5]={np.round(mu[:5], 4).tolist()}") |
|
|
| cells_spec, T, R, n_grid_points, chunk_size = build_cells(args.toy) |
| t_grid = make_t_grid(T, n_grid_points) |
| log(f"cells={len(cells_spec)} T={T} R={R} t_grid: {len(t_grid)} points " |
| f"[{t_grid[0]}..{t_grid[-1]}]") |
|
|
| pstar_cache = {} |
| for family, q, k, delta in cells_spec: |
| key = (family, qlabel(q), k) |
| if key in pstar_cache: |
| continue |
| w_eff = gini_w(w, instance["weight_decay"]) if family == "gini" else w |
| p_star = oracle(mu, family, w_eff, q, k) |
| W_star = swf(mu * p_star, family, w_eff, q) |
| pstar_cache[key] = (p_star, W_star, w_eff) |
| log(f"precomputed p_star/W_star for {len(pstar_cache)} (family,q,k) combos") |
|
|
| R_used, R_note = R, None |
| if not args.toy: |
| R_used, R_note = calibrate_and_pick_R(mu, alpha, beta, pstar_cache, cells_spec, T, n_jobs, |
| R_CANDIDATES_FULL) |
| log(f"replicates per cell: R={R_used}" + (f" ({R_note})" if R_note else "")) |
|
|
| tasks = [] |
| for cell_idx, (family, q, k, delta) in enumerate(cells_spec): |
| key = (family, qlabel(q), k) |
| p_star, W_star, w_eff = pstar_cache[key] |
| seeds_all = [SEED_BASE + r for r in range(R_used)] |
| for start in range(0, R_used, chunk_size): |
| chunk_seeds = seeds_all[start:start + chunk_size] |
| tasks.append((cell_idx, family, q, k, delta, p_star, W_star, w_eff, T, chunk_seeds)) |
| log(f"built {len(tasks)} chunk tasks across {len(cells_spec)} cells (chunk_size={chunk_size})") |
|
|
| def _run_chunk_task(task): |
| cell_idx, family, q, k, delta, p_star, W_star, w_eff, T_, seeds = task |
| res = simulate_chunk(mu, alpha, beta, w_eff, family, q, k, p_star, W_star, T_, delta, seeds, t_grid) |
| return cell_idx, res |
|
|
| t_sim0 = time.time() |
| raw_results = run_grid(_run_chunk_task, tasks, n_jobs=n_jobs) |
| log(f"all {len(raw_results)} chunk tasks completed in {time.time() - t_sim0:.1f}s") |
|
|
| by_cell = {i: [] for i in range(len(cells_spec))} |
| for cell_idx, chunk_res in raw_results: |
| by_cell[cell_idx].append(chunk_res) |
|
|
| cells_out = [] |
| for cell_idx, (family, q, k, delta) in enumerate(cells_spec): |
| _, W_star, _ = pstar_cache[(family, qlabel(q), k)] |
| cell_out = combine_chunks(by_cell[cell_idx], t_grid, family, q, k, delta, W_star) |
| cells_out.append(cell_out) |
| log(f"cell family={family} q={q} k={k} delta={delta}: " |
| f"anytime_miss={cell_out['anytime_miss_rate']:.4f} se={cell_out['anytime_miss_se']:.4f} " |
| f"alpha={cell_out['width_decay_alpha']:.3f}") |
|
|
| max_anytime = max((c["anytime_miss_rate"] for c in cells_out), default=0.0) |
| n_exceed_delta = sum(1 for c in cells_out if c["anytime_miss_rate"] > c["delta"]) |
| n_exceed_delta_3se = sum(1 for c in cells_out |
| if c["anytime_miss_rate"] > c["delta"] + 3 * c["anytime_miss_se"]) |
|
|
| meta = dict( |
| exp="exp02", n_cores_used=n_jobs, wall_time_sec=time.time() - t0, |
| seed_base=SEED_BASE, numpy_version=np.__version__, n=N, T=T, R=R_used, |
| ambiguities={"beta_prior": "U[1,5] seed 0", "mu_up_init": 1.0, "mu_low_init": 0.1, |
| "clip_range": [0.1, 1.0], "init_rule": "round_robin"}, |
| ) |
| if R_note: |
| meta["R_reduction_note"] = R_note |
|
|
| out = dict( |
| meta=meta, |
| status="ok", |
| t_grid=t_grid, |
| cells=cells_out, |
| summary=dict(n_cells=len(cells_out), max_anytime_miss_rate=max_anytime, |
| n_cells_exceeding_delta=n_exceed_delta, |
| n_cells_exceeding_delta_plus_3se=n_exceed_delta_3se), |
| ) |
|
|
| os.makedirs(os.path.dirname(RESULTS_PATH), exist_ok=True) |
| with open(RESULTS_PATH, "w") as fh: |
| json.dump(out, fh, indent=2) |
|
|
| elapsed = time.time() - t0 |
| print(f"exp02 done in {elapsed:.1f}s (toy={args.toy}, n_jobs={n_jobs}, R={R_used})") |
| print(f"cells: {len(cells_out)}, max_anytime_miss_rate={max_anytime:.4f}") |
| print(f"n_cells_exceeding_delta={n_exceed_delta}, n_cells_exceeding_delta_plus_3se={n_exceed_delta_3se}") |
| print(f"results written to {RESULTS_PATH}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
