ENH add Array API to newton-cg in LogisticRegression - #34412

"""Cross-branch benchmark for LogisticRegression(solver="newton-cg").

Minimal, public-API only (no monkeypatching, no private instrumentation). Run
the SAME script once per branch and diff the two outputs:

    git checkout main   && mamba run -n dev python bench_newton_cg_branches.py
    git checkout <this> && mamba run -n dev python bench_newton_cg_branches.py

For each data shape it aggregates, over several seeds:
  * number of outer iterations via ``clf.n_iter_``
  * fit duration
  * warning counts (ConvergenceWarning / line-search / other)
  * convergence success rate  (converged := max(n_iter_) < max_iter)

"Ill-conditioned" shapes use nearly-collinear column pairs with the label
signal placed along the tiny-curvature (difference) directions; these are the
problems that exercise the small/zero-curvature CG guard present on ``main``.
Everything is unregularized (C=inf) so the Hessian is not lifted away from
singularity.
"""

import subprocess
import time
import warnings

import numpy as np

import sklearn
from sklearn.exceptions import ConvergenceWarning
from sklearn.linear_model import LogisticRegression

TOL = 1e-8
MAX_ITER = 300
N_SEEDS = 30


def git_label():
    try:
        branch = subprocess.check_output(
            ["git", "rev-parse", "--abbrev-ref", "HEAD"], text=True
        ).strip()
        commit = subprocess.check_output(
            ["git", "rev-parse", "--short", "HEAD"], text=True
        ).strip()
        return f"{branch}@{commit}"
    except Exception:  # noqa: BLE001
        return "unknown"


def make_problem(kind, seed, n_samples, n_features, dtype):
    """Build a binary-classification problem of the requested shape/kind."""
    rng = np.random.RandomState(seed)
    if kind == "wellcond":
        X = rng.randn(n_samples, n_features)
        w = rng.randn(n_features)
        y = (X @ w + 0.5 * rng.randn(n_samples) > 0).astype(int)
    elif kind == "illcond":
        # Nearly-collinear column pairs; the signal lives along the tiny-
        # curvature "difference" directions => low-curvature CG steps.
        delta_exp = (-6, -3) if np.dtype(dtype) == np.float32 else (-11, -7)
        delta = 10 ** rng.uniform(*delta_exp)
        cols, signal = [], np.zeros(n_samples)
        for _ in range(n_features // 2):
            u, v = rng.randn(n_samples), rng.randn(n_samples)
            cols += [u, u + delta * v]
            signal += rng.uniform(0.5, 4.0) * v
        while len(cols) < n_features:  # pad if n_features is odd
            z = rng.randn(n_samples)
            cols.append(z)
            signal += rng.uniform(0.5, 2.0) * z
        X = np.column_stack(cols)
        y = (signal + 0.3 * rng.randn(n_samples) > 0).astype(int)
    else:
        raise ValueError(kind)
    return X.astype(dtype), y


def run_config(kind, n_samples, n_features, dtype):
    iters, times = [], []
    n_converged = w_conv = w_ls = w_other = 0
    for seed in range(N_SEEDS):
        X, y = make_problem(kind, seed, n_samples, n_features, dtype)
        clf = LogisticRegression(
            solver="newton-cg", C=np.inf, max_iter=MAX_ITER, tol=TOL
        )
        with warnings.catch_warnings(record=True) as caught:
            warnings.simplefilter("always")
            t0 = time.perf_counter()
            clf.fit(X, y)
            times.append(time.perf_counter() - t0)
        n_it = int(np.max(clf.n_iter_))
        iters.append(n_it)
        if n_it < MAX_ITER:
            n_converged += 1
        for wm in caught:
            msg = str(wm.message).lower()
            if issubclass(wm.category, ConvergenceWarning):
                w_conv += 1
            elif "line search" in msg or "linesearch" in wm.category.__name__.lower():
                w_ls += 1
            else:
                w_other += 1
    return dict(
        iters_mean=float(np.mean(iters)),
        iters_max=int(np.max(iters)),
        t_total=float(np.sum(times)),
        t_mean_ms=float(np.mean(times)) * 1e3,
        conv_rate=100.0 * n_converged / N_SEEDS,
        w_conv=w_conv,
        w_ls=w_ls,
        w_other=w_other,
    )


CONFIGS = [
    # (kind,       n_samples, n_features, dtype)
    ("wellcond", 500, 20, np.float64),
    ("wellcond", 3000, 50, np.float64),
    ("illcond", 300, 2, np.float64),
    ("illcond", 1000, 10, np.float64),
    ("illcond", 2000, 30, np.float64),
    ("illcond", 300, 2, np.float32),
    ("illcond", 1000, 10, np.float32),
]


def main():
    print(f"sklearn {sklearn.__version__}   git {git_label()}")
    print(f"solver=newton-cg  C=inf  tol={TOL}  max_iter={MAX_ITER}  "
          f"n_seeds={N_SEEDS}\n")
    hdr = (f"{'kind':9} {'shape':12} {'dtype':7} {'iter_mean':>9} {'iter_max':>8} "
           f"{'t_total_s':>9} {'t_mean_ms':>9} {'conv_%':>7} "
           f"{'W_conv':>6} {'W_ls':>6} {'W_oth':>6}")
    print(hdr)
    print("-" * len(hdr))
    for kind, n, p, dtype in CONFIGS:
        m = run_config(kind, n, p, dtype)
        shape = f"{n}x{p}"
        print(f"{kind:9} {shape:12} {np.dtype(dtype).name:7} "
              f"{m['iters_mean']:>9.1f} {m['iters_max']:>8d} "
              f"{m['t_total']:>9.3f} {m['t_mean_ms']:>9.2f} {m['conv_rate']:>7.1f} "
              f"{m['w_conv']:>6d} {m['w_ls']:>6d} {m['w_other']:>6d}")


if __name__ == "__main__":
    main()