scripts/sim.py

"""Core simulation library for reproducing arXiv:2602.02431 (ICML 2026 #26332).

Single-index model:  x_i ~ N(0, I_d),  y_i = sigma(<x_i, theta*>),  ||theta*|| = 1.

Activations
-----------
* ``quad``          sigma(z) = z^2                      (paper Sec. 3.1)
* ``trunc``         sigma(z) = min(z^2, M)              (paper eq. 4.3, hard truncation)
* ``smooth``        sigma(z) = int_0^{z^2} phi(u) du    (paper eq. 3.10, smooth truncation)

Algorithms
----------
* ``spherical_flow``  full-batch spherical GD on the correlation loss
                      L(theta) = -(1/n) sum_i y_i sigma(<x_i, theta>)
                      theta <- normalize(theta + eta (I - theta theta^T) A(theta) theta)
                      with A(theta) = (2/n) sum_i y_i phi(<x_i,theta>^2) x_i x_i^T.
* ``online_sgd``      one-pass spherical SGD on the same loss (each sample used once).
* ``squared_gd``      full-batch Euclidean GD on the squared loss (paper Sec. 4).
"""

from __future__ import annotations

import math
from dataclasses import dataclass

import torch


# --------------------------------------------------------------------------- #
# activations
# --------------------------------------------------------------------------- #
def _bump(u: torch.Tensor) -> torch.Tensor:
    """gamma(u) = exp(-1/u) for u > 0, else 0."""
    out = torch.zeros_like(u)
    pos = u > 0
    out[pos] = torch.exp(-1.0 / u[pos])
    return out


def phi_smooth(u: torch.Tensor, M: float) -> torch.Tensor:
    """C^inf cutoff: phi = 1 for |u| <= M, 0 for |u| >= 2M (paper Sec. 3.2)."""
    t = (u.abs() - M) / M
    g0, g1 = _bump(t), _bump(1.0 - t)
    S = torch.where(g0 + g1 > 0, g0 / (g0 + g1 + 1e-300), torch.zeros_like(t))
    return (1.0 - S).clamp_(0.0, 1.0)


_SMOOTH_TABLE: dict[tuple[float, str, str], tuple[torch.Tensor, torch.Tensor]] = {}


def _smooth_sigma_table(M: float, device, dtype, npts: int = 200_001):
    key = (M, str(device), str(dtype))
    if key not in _SMOOTH_TABLE:
        u = torch.linspace(0.0, 2.0 * M, npts, device=device, dtype=dtype)
        f = phi_smooth(u, M)
        du = u[1] - u[0]
        cum = torch.cumsum((f[1:] + f[:-1]) * 0.5 * du, dim=0)
        cum = torch.cat([torch.zeros(1, device=device, dtype=dtype), cum])
        _SMOOTH_TABLE[key] = (u, cum)
    return _SMOOTH_TABLE[key]


def sigma(z: torch.Tensor, act: str, M: float) -> torch.Tensor:
    if act == "quad":
        return z * z
    if act == "trunc":
        return torch.clamp(z * z, max=M)
    if act == "smooth":
        u, cum = _smooth_sigma_table(M, z.device, z.dtype)
        w = torch.clamp(z * z, max=2.0 * M)
        idx = torch.clamp(
            torch.searchsorted(u, w.reshape(-1).contiguous()), 1, u.numel() - 1
        )
        u0, u1 = u[idx - 1], u[idx]
        c0, c1 = cum[idx - 1], cum[idx]
        frac = (w.reshape(-1) - u0) / (u1 - u0)
        return (c0 + frac * (c1 - c0)).reshape(z.shape)
    raise ValueError(act)


def phi(w: torch.Tensor, act: str, M: float) -> torch.Tensor:
    """phi(u) with sigma'(z) = 2 z phi(z^2); argument ``w`` is z^2."""
    if act == "quad":
        return torch.ones_like(w)
    if act == "trunc":
        return (w < M).to(w.dtype)
    if act == "smooth":
        return phi_smooth(w, M)
    raise ValueError(act)


def sigma_prime(z: torch.Tensor, act: str, M: float) -> torch.Tensor:
    return 2.0 * z * phi(z * z, act, M)


# --------------------------------------------------------------------------- #
# data
# --------------------------------------------------------------------------- #
@dataclass
class Data:
    X: torch.Tensor
    y: torch.Tensor
    theta_star: torch.Tensor


def make_data(d: int, n: int, seed: int, act: str, M: float, device, dtype) -> Data:
    g = torch.Generator(device=device).manual_seed(seed)
    theta_star = torch.randn(d, generator=g, device=device, dtype=dtype)
    theta_star /= theta_star.norm()
    X = torch.randn(n, d, generator=g, device=device, dtype=dtype)
    y = sigma(X @ theta_star, act, M)
    return Data(X, y, theta_star)


def rand_sphere(d: int, seed: int, device, dtype) -> torch.Tensor:
    g = torch.Generator(device=device).manual_seed(seed)
    v = torch.randn(d, generator=g, device=device, dtype=dtype)
    return v / v.norm()


# --------------------------------------------------------------------------- #
# full-batch spherical gradient descent on the correlation loss
# --------------------------------------------------------------------------- #
def a_star(data: Data) -> torch.Tensor:
    """A* = (2/n) sum_i y_i x_i x_i^T  (paper eq. 3.3)."""
    n = data.X.shape[0]
    return (2.0 / n) * (data.X.T @ (data.y[:, None] * data.X))


def _Atheta_matvec(data: Data, theta: torch.Tensor, act: str, M: float) -> torch.Tensor:
    """A(theta) @ theta without forming A(theta)  (paper eq. 3.11)."""
    z = data.X @ theta
    w = data.y * phi(z * z, act, M) * z
    return (2.0 / data.X.shape[0]) * (data.X.T @ w)


def spherical_flow(
    data: Data,
    theta0: torch.Tensor,
    act: str,
    M: float,
    eta: float = 0.1,
    T: int = 1000,
    tol: float = 1e-12,
    check_every: int = 50,
    use_matrix: bool | None = None,
    record_every: int = 0,
):
    """Full-batch spherical GD on the correlation loss (paper eq. 3.4 / 3.12).

    Returns ``(theta, steps_run, trace)`` where ``trace`` is a list of
    ``(step, squared_overlap)`` when ``record_every > 0``.
    """
    if use_matrix is None:
        use_matrix = act == "quad"
    A = a_star(data) if use_matrix else None
    theta = theta0.clone()
    ts = data.theta_star
    trace = []
    prev_ray = None
    prev_ov = None
    steps = T
    for t in range(T):
        Ath = (A @ theta) if use_matrix else _Atheta_matvec(data, theta, act, M)
        ray = theta @ Ath
        grad = Ath - ray * theta                    # (I - theta theta^T) A(theta) theta
        theta = theta + eta * grad
        theta = theta / theta.norm()
        if record_every and (t % record_every == 0 or t == T - 1):
            trace.append((t + 1, float((theta @ ts) ** 2)))
        if (t + 1) % check_every == 0:
            # converged: Rayleigh quotient (= -loss) and overlap both stationary
            ray, ov = float(ray), float((theta @ ts) ** 2)
            if (
                prev_ray is not None
                and abs(ray - prev_ray) <= tol * max(abs(ray), 1e-30)
                and abs(ov - prev_ov) <= tol
            ):
                steps = t + 1
                break
            prev_ray, prev_ov = ray, ov
    return theta, steps, trace


# --------------------------------------------------------------------------- #
# one-pass (online) spherical SGD on the correlation loss
# --------------------------------------------------------------------------- #
def online_sgd(
    d: int,
    n: int,
    seeds: int,
    act: str,
    M: float,
    eta: float,
    seed0: int,
    device,
    dtype,
    checkpoints: list[int],
    chunk: int = 2048,
):
    """One-pass spherical SGD, vectorised over ``seeds`` independent replicas.

    theta <- normalize(theta + eta (I - theta theta^T) y_t sigma'(<x_t,theta>) x_t)

    Returns dict ``{n_used: mean squared overlap}`` measured at ``checkpoints``.
    """
    g = torch.Generator(device=device).manual_seed(seed0)
    ts = torch.randn(seeds, d, generator=g, device=device, dtype=dtype)
    ts /= ts.norm(dim=1, keepdim=True)
    th = torch.randn(seeds, d, generator=g, device=device, dtype=dtype)
    th /= th.norm(dim=1, keepdim=True)

    out: dict[int, float] = {}
    cps = sorted(checkpoints)
    ci = 0
    done = 0
    while done < n:
        m = min(chunk, n - done)
        Xc = torch.randn(seeds, m, d, generator=g, device=device, dtype=dtype)
        for j in range(m):
            x = Xc[:, j, :]                                   # (S, d)
            zstar = (x * ts).sum(1)
            y = sigma(zstar, act, M)
            z = (x * th).sum(1)
            coef = y * sigma_prime(z, act, M)                 # (S,)
            gvec = coef[:, None] * x
            gvec = gvec - (gvec * th).sum(1, keepdim=True) * th
            th = th + eta * gvec
            th = th / th.norm(dim=1, keepdim=True)
            done += 1
            while ci < len(cps) and done == cps[ci]:
                out[done] = float(((th * ts).sum(1) ** 2).mean())
                ci += 1
        del Xc
    return out


# --------------------------------------------------------------------------- #
# full-batch Euclidean GD on the squared loss (paper Sec. 4)
# --------------------------------------------------------------------------- #
def squared_gd(
    data: Data,
    theta0: torch.Tensor,
    act: str,
    M: float,
    eta: float,
    T: int,
    record_every: int = 1,
    stop_err: float | None = None,
):
    """theta_{t+1} = theta_t - eta * (1/n) sum_i (sigma(<x_i,th>) - y_i) sigma'(<x_i,th>) x_i.

    Returns a dict of trajectory arrays (step, sq_overlap, norm, dist2, loss).
    """
    X, y, ts = data.X, data.y, data.theta_star
    n = X.shape[0]
    theta = theta0.clone()
    rec = {"step": [], "sq_overlap": [], "norm": [], "dist2": [], "loss": []}

    def _record(t):
        nr = float(theta.norm())
        ov = float((theta @ ts) ** 2) / max(nr * nr, 1e-300)
        d2 = min(
            float(((theta - ts) ** 2).sum()), float(((theta + ts) ** 2).sum())
        )
        z = X @ theta
        loss = float((0.5 / n) * ((sigma(z, act, M) - y) ** 2).sum())
        rec["step"].append(t)
        rec["sq_overlap"].append(ov)
        rec["norm"].append(nr)
        rec["dist2"].append(d2)
        rec["loss"].append(loss)
        return d2

    _record(0)
    for t in range(1, T + 1):
        z = X @ theta
        resid = (sigma(z, act, M) - y) * sigma_prime(z, act, M)
        grad = (X.T @ resid) / n
        theta = theta - eta * grad
        if record_every and (t % record_every == 0 or t == T):
            d2 = _record(t)
            if stop_err is not None and d2 < stop_err:
                break
    return rec


# --------------------------------------------------------------------------- #
# helpers
# --------------------------------------------------------------------------- #
def top2_eig(A: torch.Tensor):
    """Top-two eigenvalues and top eigenvector of a symmetric matrix."""
    A = 0.5 * (A + A.T)
    evals, evecs = torch.linalg.eigh(A.double())
    return float(evals[-1]), float(evals[-2]), evecs[:, -1].to(A.dtype)


def log2_steps(d: int, mult: float = 1000.0) -> int:
    return int(mult * math.log(d) ** 2)