scripts/exp01_affine_scaling.py

#!/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()