File size: 3,871 Bytes
4bfaa5d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | """Sequential test: stopping boundaries and path simulator.
beta_theory(n, alpha) = 1 + log(2(1+n)/alpha) eq. (7)
beta_practical(n, alpha) = log(1/alpha) eq. (8)
tau = inf{ n >= 1 : n * KL_inf(q_hat_n, m_o) >= beta(n, alpha) } eq. (3)
"""
import math
import numpy as np
from core.klinf import ell, klinf_emp
_HT_TOL = 1e-9
_SANDWICH_TOL = 1e-6
def beta_theory(n, alpha):
return 1.0 + math.log(2.0 * (1.0 + n) / alpha)
def beta_practical(n, alpha):
return math.log(1.0 / alpha)
def _beta_fn(beta_kind):
if beta_kind == "theory":
return beta_theory
if beta_kind == "practical":
return beta_practical
raise ValueError(f"unknown beta_kind {beta_kind!r}")
def run_path(rng, sampler, m_o, alphas, beta_kind, n_max, n_chunk=256):
"""Simulate one path, recording the first crossing n for every alpha in
`alphas` on a single shared stream. Returns a dict keyed by alpha with
tau, klinf/lam_star/sigma2 at tau and tau-1, and a censored flag."""
beta_fn = _beta_fn(beta_kind)
# eq (11) bounds the '+' branch (m_o >= mean) by 1/(1-m_o); by the
# mirrored argument the '-' branch (m_o < mean) is bounded by 1/m_o.
ht_bound_plus = 1.0 / (1.0 - m_o)
ht_bound_minus = 1.0 / m_o
x = np.empty(n_max, dtype=float)
n = 0
lam_prev = None
prev_snapshot = None # (val, lam, sigma2) at n-1
pending = set(alphas)
out = {}
while n < n_max and pending:
take = min(n_chunk, n_max - n)
x[n:n + take] = sampler(rng, take)
for i in range(take):
n += 1
xk = x[:n]
val, lam, case = klinf_emp(xk, m_o, lam_hint=lam_prev)
lam_prev = lam if case == "interior" else None
running_mean = float(np.mean(xk))
ht_bound = ht_bound_plus if m_o >= running_mean else ht_bound_minus
assert val <= ht_bound + _HT_TOL, f"HT bound violated at n={n}: {val} > {ht_bound}"
resid = ell(lam, xk, m_o) - val
sigma2_hat = float(np.mean(resid ** 2))
snapshot = dict(n=n, klinf=val, lam_star=lam, sigma2=sigma2_hat)
stat = n * val
crossed_now = []
for a in list(pending):
b = beta_fn(n, a)
if stat >= b:
crossed_now.append(a)
for a in crossed_now:
b_tau = beta_fn(n, a)
if n >= 2 and prev_snapshot is not None:
b_tau_m1 = beta_fn(n - 1, a)
lower = b_tau / val if val > 0 else float("inf")
upper = 1.0 + (b_tau_m1 / prev_snapshot["klinf"]
if prev_snapshot["klinf"] > 0 else float("inf"))
assert lower - _SANDWICH_TOL <= n < upper + _SANDWICH_TOL, \
f"eq(17) sandwich violated at tau={n}, alpha={a}: {lower} <= {n} < {upper}"
out[a] = dict(
tau=n, censored=False,
klinf_tau=snapshot["klinf"], lam_star_tau=snapshot["lam_star"],
sigma2_tau=snapshot["sigma2"],
klinf_tau_m1=(prev_snapshot["klinf"] if prev_snapshot else None),
lam_star_tau_m1=(prev_snapshot["lam_star"] if prev_snapshot else None),
sigma2_tau_m1=(prev_snapshot["sigma2"] if prev_snapshot else None),
)
pending.discard(a)
prev_snapshot = snapshot
if not pending:
break
for a in pending:
out[a] = dict(tau=n, censored=True, klinf_tau=None, lam_star_tau=None,
sigma2_tau=None, klinf_tau_m1=None, lam_star_tau_m1=None,
sigma2_tau_m1=None)
for a in out:
if "censored" not in out[a]:
out[a]["censored"] = False
return out
|