#!/usr/bin/env python3 """exp01 -- Affine Brenier scaling diagnostic (specs/exp01_affine_scaling.md). Measures the log-log slope beta_hat of the discrete support-tube proxy dbias(eps) vs eps, per dimension d, for the affine Brenier (Gaussian->Gaussian) regime, using two independent QOT solvers (nonlinear Gauss-Seidel and a semismooth-Newton solver warm-started from it). """ import argparse import json import math import os import sys import time import numpy as np from scipy import sparse from scipy.sparse.linalg import spsolve from joblib import Parallel, delayed HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) WORK_DIR = os.path.join(ROOT, "work") RESULTS_DIR = os.path.join(ROOT, "results") RESULTS_PATH = os.path.join(RESULTS_DIR, "exp01.json") BASE = 1.00005 A_PARAM = 0 TAU = 1e-12 INIT_TOL = 1e-2 FULL_EPS_MULTIPLIERS = [1e-8, 5e-8, 1e-7, 5e-7, 1e-6, 5e-6, 1e-5, 5e-5, 1e-4, 5e-4] SOLVERS = ["nonlinear_gauss_seidel", "semismooth_newton"] MAX_ITER_GS = 5000 MAX_ITER_NEWTON = 100 COST_CHUNK = 256 def log(msg): print(msg, file=sys.stderr, flush=True) # --------------------------------------------------------------------------- # Data generation (paper Appendix B.2/B.3) # --------------------------------------------------------------------------- def sigma0_coeffs(d, r_trunc): """Sigma0 = a_coef*I + b_coef*J (J = ones ones^T).""" diag = (1.0 / d - 45.0 / d ** 2) * r_trunc ** 2 off = (45.0 / d ** 2) * r_trunc ** 2 a_coef = diag - off b_coef = off return a_coef, b_coef def sample_z(n, d, a_coef, b_coef, rng): """Draw n iid samples from N(0, a_coef*I + b_coef*J), clipping negative eigenvalues to 0 (only matters at toy-scale d where the closed-form covariance is not PSD; full-scale d>=100 always yields a_coef>0).""" w = rng.standard_normal((n, d)) lam_perp = max(a_coef, 0.0) lam_par = max(a_coef + d * b_coef, 0.0) sqrt_perp = math.sqrt(lam_perp) sqrt_par = math.sqrt(lam_par) mean_w = w.mean(axis=1, keepdims=True) return sqrt_perp * w + (sqrt_par - sqrt_perp) * mean_w def sample_truncated(n, d, a_coef, b_coef, r_trunc, rng): out = [] got = 0 batch = max(n * 2, 256) while got < n: z = sample_z(batch, d, a_coef, b_coef, rng) norms = np.linalg.norm(z, axis=1) acc = z[norms <= r_trunc] if acc.shape[0]: out.append(acc) got += acc.shape[0] return np.concatenate(out, axis=0)[:n] def build_y(x, A_diag, p_pair, d, a_coef, b_coef, r_trunc, rng, M): n_pair = int(round(p_pair * M)) idx_all = np.arange(M) if n_pair > 0: paired_idx = rng.choice(idx_all, size=n_pair, replace=False) else: paired_idx = np.array([], dtype=int) paired_mask = np.zeros(M, dtype=bool) paired_mask[paired_idx] = True y = np.empty((M, d)) y[paired_mask] = x[paired_idx] * A_diag[None, :] n_unpaired = M - n_pair if n_unpaired > 0: x_tilde = sample_truncated(n_unpaired, d, a_coef, b_coef, r_trunc, rng) y[~paired_mask] = x_tilde * A_diag[None, :] return y def pairwise_sqdist(X, Y, chunk=COST_CHUNK): N = X.shape[0] X2 = np.sum(X ** 2, axis=1) Y2 = np.sum(Y ** 2, axis=1) D2 = np.empty((N, Y.shape[0])) for start in range(0, N, chunk): end = min(start + chunk, N) D2[start:end] = X2[start:end, None] + Y2[None, :] - 2.0 * X[start:end] @ Y.T np.maximum(D2, 0.0, out=D2) return D2 # --------------------------------------------------------------------------- # Solver 1: nonlinear Gauss-Seidel (Alg 1 + 2) # --------------------------------------------------------------------------- def _gs_half_sweep(c, other, weight, eps): """Solve, for each row i of `c`, f_i s.t. sum_j weight*(f_i-(c_ij-other_j))_+ = eps. Vectorized using uniform weights (a_i=1/N, b_j=1/M).""" y = c - other[None, :] M = c.shape[1] order = np.argsort(y, axis=1) y_sorted = np.take_along_axis(y, order, axis=1) cumsum = np.cumsum(y_sorted, axis=1) # unweighted prefix sum of sorted y k = np.arange(1, M + 1) # f*(weight*k) - weight*cumsum = eps => f = eps/(weight*k) + cumsum/k f_candidates = eps / (weight * k) + cumsum / k upper = np.empty_like(y_sorted) upper[:, :-1] = y_sorted[:, 1:] upper[:, -1] = np.inf tol_num = 1e-9 * (1.0 + np.abs(y_sorted)) valid = (f_candidates >= y_sorted - tol_num) & (f_candidates <= upper + tol_num) any_valid = valid.any(axis=1) idx = np.argmax(valid, axis=1) f = f_candidates[np.arange(c.shape[0]), idx] if not np.all(any_valid): f[~any_valid] = f_candidates[~any_valid, -1] return f def solve_gs(c, eps, N, M, tol, max_iter, f_init=None, g_init=None): a_w = 1.0 / N b_w = 1.0 / M f = np.zeros(N) if f_init is None else f_init.copy() g = np.zeros(M) if g_init is None else g_init.copy() converged = False it = 0 for it in range(1, max_iter + 1): f = _gs_half_sweep(c, g, b_w, eps) g = _gs_half_sweep(c.T, f, a_w, eps) kappa = a_w * f.sum() f = f - kappa g = g + kappa P = f[:, None] + g[None, :] - c pos = np.maximum(P, 0.0) r = b_w * pos.sum(axis=1) - eps s = a_w * pos.sum(axis=0) - eps resid = max(np.max(np.abs(r)), np.max(np.abs(s))) if resid <= tol: converged = True break return f, g, converged, it # --------------------------------------------------------------------------- # Solver 2: semismooth Newton (Alg 3), warm-started from a loose GS pass # --------------------------------------------------------------------------- def solve_newton(c, eps, N, M, tol, max_iter, f_init, g_init): a_w = 1.0 / N b_w = 1.0 / M f, g, _, it_bridge = solve_gs(c, eps, N, M, tol * 10.0, MAX_ITER_GS, f_init, g_init) converged = False theta = 1e-4 xi = 0.5 lam = 1e-8 newton_iters = 0 for newton_it in range(1, max_iter + 1): newton_iters = newton_it P = f[:, None] + g[None, :] - c sigma = P > 0 pos = np.where(sigma, P, 0.0) r = b_w * pos.sum(axis=1) - eps s = a_w * pos.sum(axis=0) - eps resid = max(np.max(np.abs(r)), np.max(np.abs(s))) if resid <= tol: converged = True break F = np.concatenate([r, s]) rows, cols = np.nonzero(sigma) w = b_w # == a_w since N == M in this spec R_diag = b_w * sigma.sum(axis=1) C_diag = a_w * sigma.sum(axis=0) diag_idx = np.arange(N + M) diag_vals = np.concatenate([R_diag, C_diag]) off_rows = np.concatenate([rows, cols + N]) off_cols = np.concatenate([cols + N, rows]) off_vals = np.full(off_rows.shape, w) all_rows = np.concatenate([diag_idx, off_rows]) all_cols = np.concatenate([diag_idx, off_cols]) all_vals = np.concatenate([diag_vals, off_vals]) G = sparse.csr_matrix((all_vals, (all_rows, all_cols)), shape=(N + M, N + M)) A_mat = (G + lam * sparse.eye(N + M, format="csr")).tocsc() try: delta = spsolve(A_mat, -F) if delta is None or not np.all(np.isfinite(delta)): raise ValueError("non-finite sparse solve") except Exception: A_dense = A_mat.toarray() delta, *_ = np.linalg.lstsq(A_dense, -F, rcond=None) df = delta[:N] dg = delta[N:] kappa = a_w * df.sum() df = df - kappa dg = dg + kappa phi0 = 0.5 * float(np.dot(F, F)) Gdelta = G.dot(delta) directional = float(np.dot(F, Gdelta)) t = 1.0 f_new, g_new = f, g for _bt in range(50): f_new = f + t * df g_new = g + t * dg P_new = f_new[:, None] + g_new[None, :] - c pos_new = np.maximum(P_new, 0.0) r_new = b_w * pos_new.sum(axis=1) - eps s_new = a_w * pos_new.sum(axis=0) - eps F_new = np.concatenate([r_new, s_new]) phi_new = 0.5 * float(np.dot(F_new, F_new)) if phi_new <= phi0 + theta * t * directional or t < 1e-6: break t *= xi f, g = f_new, g_new total_iters = it_bridge + newton_iters return f, g, converged, total_iters # --------------------------------------------------------------------------- # Per-unit (d, seed) computation # --------------------------------------------------------------------------- def run_unit(d, seed, N, M, eps_multipliers, work_dir, namespace): work_path = os.path.join(work_dir, f"{namespace}_d{d}_seed{seed}.json") if os.path.exists(work_path): try: with open(work_path) as fh: data = json.load(fh) log(f"[skip] unit d={d} seed={seed} checkpoint found") return data except Exception: log(f"[warn] unit d={d} seed={seed} checkpoint unreadable, recomputing") t_unit_start = time.time() rng = np.random.default_rng(seed) A_diag = BASE ** np.arange(1, d + 1) r_trunc = 0.8 / math.sqrt(d) a_coef, b_coef = sigma0_coeffs(d, r_trunc) p_pair = min(0.1, 0.1 * (200.0 / d) ** 2) x = sample_truncated(N, d, a_coef, b_coef, r_trunc, rng) y = build_y(x, A_diag, p_pair, d, a_coef, b_coef, r_trunc, rng, M) c = 0.5 * pairwise_sqdist(x, y) c_med = float(np.median(c)) Tx = x * A_diag[None, :] D = np.sqrt(pairwise_sqdist(Tx, y)) K = len(eps_multipliers) order_desc = list(range(K - 1, -1, -1)) # multipliers are ascending -> reverse for large->small unit_records = [] for solver_name in SOLVERS: f_prev, g_prev = None, None per_eps = {} for idx in order_desc: m_k = eps_multipliers[idx] eps_k = m_k * c_med tol = INIT_TOL * eps_k t0 = time.time() if solver_name == "nonlinear_gauss_seidel": f_sol, g_sol, converged, iters = solve_gs(c, eps_k, N, M, tol, MAX_ITER_GS, f_prev, g_prev) else: f_sol, g_sol, converged, iters = solve_newton(c, eps_k, N, M, tol, MAX_ITER_NEWTON, f_prev, g_prev) dt = time.time() - t0 pi_scale = (1.0 / N) * (1.0 / M) / eps_k P = f_sol[:, None] + g_sol[None, :] - c pos = np.maximum(P, 0.0) mask = (pi_scale * pos) > TAU n_active = int(mask.sum()) dbias = float(D[mask].max()) if n_active > 0 else None per_eps[idx] = dict(eps_actual=eps_k, dbias=dbias, converged=bool(converged), n_active=n_active, iters=int(iters)) f_prev, g_prev = f_sol, g_sol log(f"[unit-eps] d={d} seed={seed} solver={solver_name} eps_idx={idx} m={m_k:g} " f"eps={eps_k:.3e} converged={converged} iters={iters} n_active={n_active} " f"dbias={dbias} wall={dt:.2f}s") eps_actual_arr = [per_eps[i]["eps_actual"] for i in range(K)] dbias_arr = [per_eps[i]["dbias"] for i in range(K)] converged_arr = [per_eps[i]["converged"] for i in range(K)] n_active_arr = [per_eps[i]["n_active"] for i in range(K)] iters_arr = [per_eps[i]["iters"] for i in range(K)] logs_eps, logs_db = [], [] for e, db in zip(eps_actual_arr, dbias_arr): if db is not None and db > 0 and math.isfinite(db): logs_eps.append(math.log(e)) logs_db.append(math.log(db)) n_points_fit = len(logs_eps) if n_points_fit >= 2: Xv = np.array(logs_eps) Yv = np.array(logs_db) Xm, Ym = Xv.mean(), Yv.mean() denom = float(np.sum((Xv - Xm) ** 2)) beta_hat = float(np.sum((Xv - Xm) * (Yv - Ym)) / denom) if denom > 0 else float("nan") alpha_hat = float(Ym - beta_hat * Xm) else: beta_hat = float("nan") alpha_hat = float("nan") rel_err = (d + 2) * beta_hat - 1.0 if math.isfinite(beta_hat) else float("nan") unit_records.append({ "d": d, "seed": seed, "solver": solver_name, "c_med": c_med, "eps_actual": eps_actual_arr, "dbias": dbias_arr, "converged": converged_arr, "n_active": n_active_arr, "iters": iters_arr, "warm_start": "large_to_small", "n_points_fit": n_points_fit, "alpha_hat": alpha_hat, "beta_hat": beta_hat, "rel_err": rel_err, }) with open(work_path, "w") as fh: json.dump(unit_records, fh) log(f"[done unit] d={d} seed={seed} wall={time.time() - t_unit_start:.2f}s") return unit_records # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser() parser.add_argument("--toy", action="store_true") args = parser.parse_args() toy = args.toy # gates.py requires meta.eps_multipliers / record arrays to always be length 10 # (K is not relaxed for --toy); only N/M/R/d_grid shrink in toy mode. eps_multipliers = FULL_EPS_MULTIPLIERS if toy: d_grid = [10] N = M = 200 R = 2 namespace = "exp01_toy" else: d_grid = [100, 200, 500, 1000] N = M = 2000 R = 10 namespace = "exp01" os.makedirs(WORK_DIR, exist_ok=True) os.makedirs(RESULTS_DIR, exist_ok=True) units = [(d, seed) for d in d_grid for seed in range(R)] n_cores = int(os.environ.get("JOB_CORES", 4)) n_jobs = max(1, min(n_cores, len(units))) log(f"exp01 {'TOY' if toy else 'FULL'} start: {len(units)} units (d_grid={d_grid}, R={R}), " f"{n_jobs} workers (JOB_CORES={n_cores})") def _worker(d, seed): t0 = time.time() recs = run_unit(d, seed, N, M, eps_multipliers, WORK_DIR, namespace) log(f"[unit complete] d={d} seed={seed} wall={time.time() - t0:.2f}s") return recs nested = Parallel(n_jobs=n_jobs)(delayed(_worker)(d, s) for d, s in units) all_records = [r for pair in nested for r in pair] summary = [] for d in d_grid: for solver in SOLVERS: betas = [r["beta_hat"] for r in all_records if r["d"] == d and r["solver"] == solver and math.isfinite(r["beta_hat"])] rels = [r["rel_err"] for r in all_records if r["d"] == d and r["solver"] == solver and math.isfinite(r["rel_err"])] summary.append({ "d": d, "solver": solver, "theory": 1.0 / (d + 2), "beta_mean": float(np.mean(betas)) if betas else float("nan"), "beta_std": float(np.std(betas)) if betas else float("nan"), "rel_err_mean": float(np.mean(rels)) if rels else float("nan"), "rel_err_std": float(np.std(rels)) if rels else float("nan"), "n_seeds": len(betas), }) meta = { "N": N, "M": M, "R": R, "d_grid": d_grid, "eps_multipliers": eps_multipliers, "initTol": INIT_TOL, "tau": TAU, "base": BASE, "a": A_PARAM, "solvers": SOLVERS, } output = {"meta": meta, "records": all_records, "summary": summary} with open(RESULTS_PATH, "w") as fh: json.dump(output, fh, indent=1) print(f"exp01 {'toy' if toy else 'full'} complete: {len(units)} units, " f"{len(all_records)} records -> {RESULTS_PATH}") if __name__ == "__main__": main()