multivariate-probit 0.1.0__py3-none-any.whl

multivariate_probit/__init__.py

@@ -0,0 +1,56 @@
+"""Multivariate probit models for correlated binary outcomes.
+
+A multivariate probit is a Gaussian squashing function wrapped around an
+arbitrary inner model. This package fits one by Inference Functions for Margins
+(IFM): margins first, dependence second. The inner model is pluggable -- linear
+by default, gradient boosting or random forests via named presets, anything
+scikit-learn-shaped via the adapter.
+
+    >>> from multivariate_probit import MultivariateProbit
+    >>> model = MultivariateProbit(inner="linear").fit(X, Y)
+    >>> proba = model.predict_proba(X)
+    >>> proba.marginal              # P(Y_j = 1 | x)
+    >>> proba.all()                 # P(every outcome = 1 | x)
+    >>> proba.joint([1, 0, 1])      # P(Y = (1, 0, 1) | x)
+    >>> model.correlation_
+"""
+
+from ._mvn import bvn_cdf, mvn_orthant, orthant_prob, pattern_prob
+from .ifm import (
+    joint_correlation,
+    joint_log_likelihood,
+    pair_log_likelihood,
+    pairwise_correlation,
+)
+from .inner import (
+    ProbitCalibrated,
+    as_inner,
+    available_inners,
+    make_inner,
+    register_inner,
+)
+from .linear import ProbitRegressor
+from .model import MultivariateProbit
+from .results import MultivariateProbitProba
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MultivariateProbit",
+    "MultivariateProbitProba",
+    "ProbitRegressor",
+    "ProbitCalibrated",
+    "make_inner",
+    "register_inner",
+    "available_inners",
+    "as_inner",
+    "joint_correlation",
+    "joint_log_likelihood",
+    "pairwise_correlation",
+    "pair_log_likelihood",
+    "bvn_cdf",
+    "mvn_orthant",
+    "orthant_prob",
+    "pattern_prob",
+    "__version__",
+]

multivariate_probit/_corr.py

@@ -0,0 +1,51 @@
+"""Correlation-matrix utilities for the second IFM stage."""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["nearest_correlation", "is_positive_definite"]
+
+
+def is_positive_definite(mat, tol=0.0):
+    try:
+        np.linalg.cholesky(mat - tol * np.eye(mat.shape[0]))
+        return True
+    except np.linalg.LinAlgError:
+        return False
+
+
+def nearest_correlation(mat, eps=1e-8, max_iter=100):
+    """Project a symmetric matrix onto the nearest correlation matrix.
+
+    Pairwise IFM estimates each off-diagonal element separately, so the
+    assembled matrix is symmetric but not guaranteed positive definite. This is
+    Higham's alternating-projections algorithm, with a final eigenvalue floor so
+    the result is strictly PD and safe to Cholesky-factor.
+    """
+    mat = np.asarray(mat, dtype=float)
+    x = (mat + mat.T) / 2.0
+    np.fill_diagonal(x, 1.0)
+    if is_positive_definite(x, tol=eps):
+        return x
+
+    dykstra = np.zeros_like(x)
+    y = x.copy()
+    for _ in range(max_iter):
+        r = y - dykstra
+        # Projection onto the positive semi-definite cone.
+        vals, vecs = np.linalg.eigh((r + r.T) / 2.0)
+        s = (vecs * np.maximum(vals, eps)) @ vecs.T
+        dykstra = s - r
+        # Projection onto the unit-diagonal set.
+        y = s.copy()
+        np.fill_diagonal(y, 1.0)
+        if is_positive_definite(y, tol=eps):
+            break
+
+    vals, vecs = np.linalg.eigh((y + y.T) / 2.0)
+    y = (vecs * np.maximum(vals, eps)) @ vecs.T
+    scale = np.sqrt(np.diag(y))
+    y = y / np.outer(scale, scale)
+    np.fill_diagonal(y, 1.0)
+    return (y + y.T) / 2.0

multivariate_probit/_mvn.py

@@ -0,0 +1,155 @@
+"""Normal-CDF machinery: the only place multivariate integration happens.
+
+Everything here works on the *latent* scale. The inner models produce a
+real-valued index ``eta`` on (-inf, inf) and the Gaussian CDF is the only
+squashing function applied to it.
+
+The evaluator is deterministic and vectorised over observations, and it allows
+the correlation matrix to vary by row -- which is what makes the sign trick
+below (one expression for all 2^d outcome patterns) practical.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+import numpy as np
+from scipy.stats import norm
+
+__all__ = ["bvn_cdf", "mvn_orthant", "orthant_prob", "pattern_prob", "signed_corr_stack", "RHO_MAX"]
+
+# Correlations are kept strictly inside the unit interval: the quadrature below
+# degenerates at |rho| = 1, and a boundary correlation is never a defensible
+# estimate from finite data anyway.
+RHO_MAX = 0.999
+_EPS = 1e-12
+
+
+@lru_cache(maxsize=8)
+def _gl_nodes(n_quad):
+    """Gauss-Legendre nodes/weights on [-1, 1], cached per requested order."""
+    return np.polynomial.legendre.leggauss(n_quad)
+
+
+def bvn_cdf(a, b, rho, n_quad=24):
+    """P(Z1 <= a, Z2 <= b) for a standard bivariate normal with correlation rho.
+
+    Vectorised over ``a``, ``b`` and ``rho``, which broadcast against each
+    other -- so correlations may vary by row.
+
+    Uses the Drezner-Wesolowsky form of Plackett's identity,
+
+        Phi2(a, b, r) = Phi(a) Phi(b)
+                        + 1/(2 pi) * int_0^asin(r)
+                              exp(-(a^2 + b^2 - 2 a b sin t) / (2 cos^2 t)) dt
+
+    whose integrand is smooth and bounded, so a small fixed Gauss-Legendre rule
+    is accurate to ~1e-12 over |r| <= 0.999.
+    """
+    a, b, rho = np.broadcast_arrays(
+        np.asarray(a, dtype=float), np.asarray(b, dtype=float), np.asarray(rho, dtype=float)
+    )
+    rho = np.clip(rho, -RHO_MAX, RHO_MAX)
+    nodes, weights = _gl_nodes(n_quad)
+
+    # Map the quadrature nodes from [-1, 1] onto [0, asin(rho)].
+    half = np.arcsin(rho)[..., None] / 2.0
+    sin_t = np.sin(half * (nodes + 1.0))
+    cos2 = 1.0 - sin_t**2
+
+    aa, bb = a[..., None], b[..., None]
+    integrand = np.exp(-(aa**2 + bb**2 - 2.0 * aa * bb * sin_t) / (2.0 * cos2))
+    integral = np.sum(integrand * weights, axis=-1) * half[..., 0]
+
+    return np.clip(norm.cdf(a) * norm.cdf(b) + integral / (2.0 * np.pi), 0.0, 1.0)
+
+
+def mvn_orthant(A, corr_stack, n_quad=24):
+    """P(Z_1 <= A[:, 0], ..., Z_d <= A[:, d-1]) row by row, Z ~ N(0, corr_stack).
+
+    Parameters
+    ----------
+    A : array of shape (n, d)
+        Upper limits, one row per observation.
+    corr_stack : array of shape (d, d, n)
+        Correlation matrix per row (see :func:`signed_corr_stack`).
+    n_quad : int
+        Gauss-Legendre order.
+
+    Genz's (1992) recursive conditioning: peel off the last variable under a
+    fixed one-dimensional quadrature, reduce to a (d-1)-dimensional problem
+    with the conditional correlation matrix, and recurse. Bottoms out at the
+    closed-form :func:`bvn_cdf`, so cost is roughly ``n_quad**(d - 2)``
+    bivariate evaluations -- comfortable for d = 3-5, slow well before d = 10.
+    """
+    A = np.atleast_2d(np.asarray(A, dtype=float))
+    d = A.shape[1]
+    if d == 1:
+        return norm.cdf(A[:, 0])
+    if d == 2:
+        return bvn_cdf(A[:, 0], A[:, 1], corr_stack[0, 1], n_quad=n_quad)
+
+    rho_last = corr_stack[:-1, -1, :]                      # (d-1, n)
+    denom = np.sqrt(np.clip(1.0 - rho_last**2, 1e-10, None))
+    outer = rho_last[:, None, :] * rho_last[None, :, :]
+    cond = (corr_stack[:-1, :-1, :] - outer) / (denom[:, None, :] * denom[None, :, :])
+    diag = np.arange(d - 1)
+    cond[diag, diag, :] = 1.0
+    np.clip(cond, -RHO_MAX, RHO_MAX, out=cond)
+
+    phi_last = np.clip(norm.cdf(A[:, -1]), _EPS, 1.0 - _EPS)
+    nodes, weights = _gl_nodes(n_quad)
+    acc = np.zeros(A.shape[0])
+    for node, weight in zip(nodes, weights):
+        # Substituting u = Phi(z) / Phi(A_last) maps the conditioning integral
+        # onto [0, 1], where the fixed rule applies.
+        u = np.clip(0.5 * (node + 1.0) * phi_last, _EPS, 1.0 - _EPS)
+        z = norm.ppf(u)
+        reduced = (A[:, :-1] - (z[None, :] * rho_last).T) / denom.T
+        acc += 0.5 * weight * mvn_orthant(reduced, cond, n_quad=n_quad)
+    return np.clip(phi_last * acc, 0.0, 1.0)
+
+
+def signed_corr_stack(corr, signs):
+    """Stack ``corr_stack[i, j, row] = signs[row, i] * signs[row, j] * corr[i, j]``.
+
+    ``signs`` holds +-1. Flipping the sign of a latent variable flips the sign
+    of its correlations, which is what turns every outcome pattern into a plain
+    lower orthant.
+    """
+    corr = np.asarray(corr, dtype=float)
+    signs = np.atleast_2d(np.asarray(signs, dtype=float))
+    d = corr.shape[0]
+    stack = np.empty((d, d, signs.shape[0]))
+    for i in range(d):
+        stack[i, i, :] = 1.0
+        for j in range(i + 1, d):
+            value = signs[:, i] * signs[:, j] * corr[i, j]
+            stack[i, j, :] = value
+            stack[j, i, :] = value
+    return stack
+
+
+def orthant_prob(upper, corr, n_quad=24):
+    """P(Z_j <= upper[i, j] for all j) for a single shared correlation matrix."""
+    upper = np.atleast_2d(np.asarray(upper, dtype=float))
+    stack = signed_corr_stack(corr, np.ones_like(upper))
+    return mvn_orthant(upper, stack, n_quad=n_quad)
+
+
+def pattern_prob(eta, Y, corr, n_quad=24):
+    """``P(Y = y | x)`` for the multivariate probit, row by row.
+
+    With ``s = 2y - 1`` the event ``{Y = y}`` is the orthant
+    ``{s_j Z_j <= s_j eta_j for all j}``, so one signed expression covers all
+    ``2**d`` patterns -- no separate upper/lower-tail bookkeeping.
+    """
+    eta = np.atleast_2d(np.asarray(eta, dtype=float))
+    Y = np.atleast_2d(np.asarray(Y, dtype=float))
+    if Y.shape[0] == 1 and eta.shape[0] > 1:
+        Y = np.repeat(Y, eta.shape[0], axis=0)
+    if eta.shape != Y.shape:
+        raise ValueError(f"eta {eta.shape} and Y {Y.shape} must have the same shape")
+
+    signs = 2.0 * Y - 1.0
+    return mvn_orthant(signs * eta, signed_corr_stack(corr, signs), n_quad=n_quad)

multivariate_probit/ifm.py

@@ -0,0 +1,177 @@
+"""Stage two of IFM: the dependence parameters, given fixed margins."""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.optimize import minimize, minimize_scalar
+
+from ._corr import nearest_correlation
+from ._mvn import RHO_MAX, bvn_cdf, pattern_prob
+
+__all__ = [
+    "joint_correlation",
+    "pairwise_correlation",
+    "pair_log_likelihood",
+    "joint_log_likelihood",
+    "corr_from_free",
+    "free_from_corr",
+]
+
+_LL_EPS = 1e-12
+
+
+def pair_log_likelihood(rho, eta_j, eta_k, y_j, y_k, weights=None):
+    """Bivariate probit log-likelihood in ``rho`` with the margins held fixed.
+
+    With ``s = 2y - 1``, the probability of an observed pair is
+    ``Phi2(s_j eta_j, s_k eta_k, s_j s_k rho)`` -- one expression covering all
+    four cells of the 2x2 table.
+    """
+    s_j = 2.0 * np.asarray(y_j, dtype=float) - 1.0
+    s_k = 2.0 * np.asarray(y_k, dtype=float) - 1.0
+    prob = bvn_cdf(s_j * eta_j, s_k * eta_k, s_j * s_k * rho)
+    ll = np.log(np.clip(prob, _LL_EPS, None))
+    if weights is None:
+        return float(np.sum(ll))
+    return float(np.sum(np.asarray(weights, dtype=float) * ll))
+
+
+def _fit_pair(eta_j, eta_k, y_j, y_k, weights, tol):
+    finite = np.isfinite(eta_j) & np.isfinite(eta_k)
+    if not np.all(finite):
+        eta_j, eta_k, y_j, y_k = eta_j[finite], eta_k[finite], y_j[finite], y_k[finite]
+        weights = None if weights is None else np.asarray(weights)[finite]
+
+    # A margin with no variation carries no information about dependence.
+    if eta_j.size == 0 or np.ptp(y_j) == 0 or np.ptp(y_k) == 0:
+        return 0.0
+
+    def neg_ll(rho):
+        return -pair_log_likelihood(rho, eta_j, eta_k, y_j, y_k, weights)
+
+    result = minimize_scalar(
+        neg_ll, bounds=(-RHO_MAX, RHO_MAX), method="bounded", options={"xatol": tol}
+    )
+    return float(np.clip(result.x, -RHO_MAX, RHO_MAX))
+
+
+def pairwise_correlation(eta, Y, weights=None, tol=1e-6, project=True):
+    """Estimate the latent correlation matrix one pair at a time.
+
+    Parameters
+    ----------
+    eta : array of shape (n, d)
+        Latent indices from the stage-one margins. Out-of-fold indices are
+        strongly preferred for flexible inner models -- see
+        :class:`~multivariate_probit.model.MultivariateProbit`.
+    Y : array of shape (n, d)
+        Observed binary outcomes.
+    weights : array of shape (n,), optional
+    tol : float
+        Tolerance of the 1-D search for each rho.
+    project : bool
+        Project the assembled matrix onto the nearest positive-definite
+        correlation matrix. Pairwise estimates need not be jointly coherent, so
+        this is on by default.
+
+    Returns
+    -------
+    corr : array of shape (d, d)
+    """
+    eta = np.atleast_2d(np.asarray(eta, dtype=float))
+    Y = np.atleast_2d(np.asarray(Y, dtype=float))
+    if eta.shape != Y.shape:
+        raise ValueError(f"eta {eta.shape} and Y {Y.shape} must have the same shape")
+    d = eta.shape[1]
+
+    corr = np.eye(d)
+    for j in range(d):
+        for k in range(j + 1, d):
+            rho = _fit_pair(eta[:, j], eta[:, k], Y[:, j], Y[:, k], weights, tol)
+            corr[j, k] = corr[k, j] = rho
+
+    if project and d > 2:
+        corr = nearest_correlation(corr)
+    return corr
+
+
+# ---------------------------------------------------------------- joint MLE
+
+
+def corr_from_free(free, d):
+    """Build a symmetric unit-diagonal matrix from its d(d-1)/2 free entries."""
+    corr = np.eye(d)
+    upper = np.triu_indices(d, k=1)
+    corr[upper] = free
+    corr[(upper[1], upper[0])] = free
+    return corr
+
+
+def free_from_corr(corr):
+    """The free (strictly upper-triangular) entries of a correlation matrix."""
+    corr = np.asarray(corr, dtype=float)
+    return corr[np.triu_indices(corr.shape[0], k=1)]
+
+
+def joint_log_likelihood(corr, eta, Y, weights=None, n_quad=24):
+    """Full d-variate log-likelihood in ``corr``, with the margins held fixed."""
+    prob = np.clip(pattern_prob(eta, Y, corr, n_quad=n_quad), _LL_EPS, None)
+    ll = np.log(prob)
+    if weights is None:
+        return float(np.sum(ll))
+    return float(np.sum(np.asarray(weights, dtype=float) * ll))
+
+
+def joint_correlation(
+    eta,
+    Y,
+    weights=None,
+    n_quad=24,
+    optimizer="Nelder-Mead",
+    init=None,
+    min_eigenvalue=1e-8,
+    options=None,
+):
+    """Estimate the latent correlation matrix by full-information ML in ``R``.
+
+    This is the second IFM stage done exactly: with the margins frozen, the
+    d-variate orthant likelihood is maximised over the d(d-1)/2 free
+    correlations. The search is derivative-free -- the orthant probability has
+    no convenient closed-form gradient here -- and each evaluation costs an
+    orthant integral per observation, so the price grows quickly with ``d``.
+    For many outcomes prefer :func:`pairwise_correlation`.
+
+    Returns
+    -------
+    corr : ndarray of shape (d, d)
+    result : scipy.optimize.OptimizeResult
+    """
+    eta = np.atleast_2d(np.asarray(eta, dtype=float))
+    Y = np.atleast_2d(np.asarray(Y, dtype=float))
+    if eta.shape != Y.shape:
+        raise ValueError(f"eta {eta.shape} and Y {Y.shape} must have the same shape")
+    d = eta.shape[1]
+
+    if d == 1:
+        return np.ones((1, 1)), None
+
+    if init is None:
+        # The Pearson correlation of the latent indices is always PSD and lands
+        # close enough to start; pairwise IFM is a better but pricier start.
+        with np.errstate(invalid="ignore"):
+            start = np.corrcoef(eta, rowvar=False)
+        start = np.nan_to_num(start, nan=0.0)
+    else:
+        start = np.asarray(init, dtype=float)
+
+    def neg_ll(free):
+        corr = corr_from_free(np.clip(free, -RHO_MAX, RHO_MAX), d)
+        if np.linalg.eigvalsh(corr).min() <= min_eigenvalue:
+            return 1e10  # not positive definite -- push the optimizer away
+        return -joint_log_likelihood(corr, eta, Y, weights=weights, n_quad=n_quad)
+
+    result = minimize(neg_ll, free_from_corr(start), method=optimizer, options=options)
+    corr = corr_from_free(np.clip(result.x, -RHO_MAX, RHO_MAX), d)
+    if np.linalg.eigvalsh(corr).min() <= min_eigenvalue:
+        corr = nearest_correlation(corr)
+    return corr, result

multivariate_probit/inner.py

@@ -0,0 +1,187 @@
+"""Inner models and the named-preset registry.
+
+The multivariate probit here is a *squashing function around an arbitrary inner
+model*: each margin j owns a model that maps features to a real-valued index
+``eta_j(x)`` on (-inf, inf), and the Gaussian CDF turns that index into a
+marginal probability. Nothing about the fit cares how ``eta_j`` was produced,
+so any estimator that can be coaxed into emitting a real-valued score is a
+legal inner model.
+
+Two shapes are accepted:
+
+* Anything exposing ``fit(X, y)`` and ``latent(X) -> (n,)`` is used directly
+  (:class:`~multivariate_probit.linear.ProbitRegressor` is the canonical one).
+* Any scikit-learn-style classifier is wrapped by :class:`ProbitCalibrated`,
+  which converts ``predict_proba`` back onto the probit scale with the probit
+  quantile function. Estimators offering only ``decision_function`` have that
+  score used as the index as-is.
+
+The registry is deliberately thin. IFM has no per-family estimation logic --
+"linear", "xgboost" and "rf" differ only in which pre-wired estimator instance
+they hand back -- so a preset is a factory function and nothing more.
+"""
+
+from __future__ import annotations
+
+import copy
+
+import numpy as np
+from scipy.stats import norm
+
+from .linear import ProbitRegressor
+
+__all__ = [
+    "ProbitCalibrated",
+    "make_inner",
+    "register_inner",
+    "available_inners",
+    "as_inner",
+]
+
+_P_EPS = 1e-6
+
+
+class ProbitCalibrated:
+    """Adapt a probability-emitting classifier to the latent probit scale.
+
+    ``latent(X)`` returns ``Phi^-1(p_hat)``, clipped away from 0 and 1 so a
+    saturated tree ensemble cannot emit infinite indices.
+    """
+
+    def __init__(self, estimator, clip=_P_EPS):
+        self.estimator = estimator
+        self.clip = clip
+
+    def fit(self, X, y):
+        self.estimator_ = copy.deepcopy(self.estimator)
+        self.estimator_.fit(X, y)
+        return self
+
+    def latent(self, X):
+        est = getattr(self, "estimator_", self.estimator)
+        if hasattr(est, "predict_proba"):
+            proba = np.asarray(est.predict_proba(X), dtype=float)
+            p = proba[:, 1] if proba.ndim == 2 and proba.shape[1] == 2 else proba.ravel()
+            return norm.ppf(np.clip(p, self.clip, 1.0 - self.clip))
+        if hasattr(est, "decision_function"):
+            return np.asarray(est.decision_function(X), dtype=float).ravel()
+        raise TypeError(
+            f"{type(est).__name__} exposes neither predict_proba nor decision_function; "
+            "it cannot serve as an inner model."
+        )
+
+    def predict_proba(self, X):
+        p = norm.cdf(self.latent(X))
+        return np.column_stack([1.0 - p, p])
+
+    def __repr__(self):
+        return f"ProbitCalibrated({self.estimator!r})"
+
+
+def _linear(**kwargs):
+    return ProbitRegressor(**kwargs)
+
+
+def _xgboost(**kwargs):
+    try:
+        from xgboost import XGBClassifier
+    except ImportError as exc:  # pragma: no cover - exercised only without xgboost
+        raise ImportError(
+            "The 'xgboost' preset requires xgboost. Install it with "
+            "`pip install multivariate-probit[xgboost]`."
+        ) from exc
+
+    # Defaults tuned for probability calibration rather than ranking: shallow
+    # trees, plenty of shrinkage, and a logistic objective whose output maps
+    # cleanly back through Phi^-1.
+    params = dict(
+        n_estimators=300,
+        learning_rate=0.05,
+        max_depth=3,
+        subsample=0.8,
+        colsample_bytree=0.8,
+        min_child_weight=5.0,
+        reg_lambda=1.0,
+        objective="binary:logistic",
+        eval_metric="logloss",
+        tree_method="hist",
+        n_jobs=1,
+    )
+    params.update(kwargs)
+    return ProbitCalibrated(XGBClassifier(**params))
+
+
+def _random_forest(**kwargs):
+    try:
+        from sklearn.ensemble import RandomForestClassifier
+    except ImportError as exc:  # pragma: no cover - exercised only without sklearn
+        raise ImportError(
+            "The 'rf' preset requires scikit-learn. Install it with "
+            "`pip install multivariate-probit[sklearn]`."
+        ) from exc
+
+    params = dict(
+        n_estimators=500,
+        min_samples_leaf=5,
+        max_features="sqrt",
+        n_jobs=1,
+    )
+    params.update(kwargs)
+    return ProbitCalibrated(RandomForestClassifier(**params))
+
+
+_REGISTRY = {
+    "linear": _linear,
+    "probit": _linear,
+    "xgboost": _xgboost,
+    "xgb": _xgboost,
+    "rf": _random_forest,
+    "random_forest": _random_forest,
+}
+
+
+def register_inner(name, factory, overwrite=False):
+    """Register a named preset. ``factory(**kwargs)`` returns a fresh estimator."""
+    if not callable(factory):
+        raise TypeError("factory must be callable")
+    if name in _REGISTRY and not overwrite:
+        raise ValueError(f"preset {name!r} already registered; pass overwrite=True to replace it")
+    _REGISTRY[name] = factory
+    return factory
+
+
+def available_inners():
+    """Sorted names of the registered presets."""
+    return sorted(_REGISTRY)
+
+
+def make_inner(name, **kwargs):
+    """Instantiate a preset by name, forwarding ``kwargs`` to the estimator."""
+    try:
+        factory = _REGISTRY[name]
+    except KeyError:
+        raise ValueError(
+            f"unknown inner model {name!r}; available presets: {available_inners()}"
+        ) from None
+    return factory(**kwargs)
+
+
+def as_inner(spec, **kwargs):
+    """Coerce ``spec`` into an unfitted inner model.
+
+    ``spec`` may be a preset name, a callable factory, or an estimator instance
+    (which is deep-copied, then wrapped in :class:`ProbitCalibrated` unless it
+    already exposes ``latent``).
+    """
+    if isinstance(spec, str):
+        return make_inner(spec, **kwargs)
+    if isinstance(spec, type):
+        return as_inner(spec(**kwargs))
+    if callable(spec) and not hasattr(spec, "fit"):
+        return as_inner(spec(**kwargs))
+    if not hasattr(spec, "fit"):
+        raise TypeError(f"{spec!r} is not a valid inner model: no fit method")
+    est = copy.deepcopy(spec)
+    if hasattr(est, "latent"):
+        return est
+    return ProbitCalibrated(est)