hapc 0.1.2__cp39-cp39-win_amd64.whl

hapc/__init__.py

@@ -0,0 +1,33 @@
+"""HAPC: Highly Adaptive Principal Components."""
+
+__version__ = "0.1.2"
+
+from .core import (
+    pchal_design,
+    ridge_regression,
+    mkernel,
+    kernel_cross,
+    pcghal,
+    pcghal_classification,
+    fast_pchal,
+)
+from .single import single_lambda_fit, single_pcghal, hapc, SinglePcghalResult
+from .cv import pcghal_cv, CVResult, fasthal_cv, cv_hapc
+
+__all__ = [
+    "pchal_design",
+    "ridge_regression",
+    "mkernel",
+    "kernel_cross",
+    "pcghal",
+    "pcghal_classification",
+    "fast_pchal",
+    "single_lambda_fit",
+    "single_pcghal",
+    "hapc",
+    "SinglePcghalResult",
+    "pcghal_cv",
+    "cv_hapc",
+    "fasthal_cv",
+    "CVResult",
+]

hapc/core.py

@@ -0,0 +1,148 @@
+"""Python interface to shared HAPC C++ library."""
+
+import numpy as np
+from typing import NamedTuple, Optional
+import sys
+from pathlib import Path
+
+# Try to import hapc_core module
+hapc_core = None
+
+# Try direct import
+try:
+    import hapc_core
+except ImportError:
+    pass
+
+# Try relative import
+if hapc_core is None:
+    try:
+        from .. import hapc_core
+    except ImportError:
+        pass
+
+# Try to find it in known locations
+if hapc_core is None:
+    search_paths = [
+        Path(__file__).parent,  # Same directory as this file
+        Path(__file__).parent.parent.parent / "build",  # Build directory
+    ]
+    
+    for path in search_paths:
+        if path.exists():
+            sys.path.insert(0, str(path))
+            try:
+                import hapc_core
+                break
+            except ImportError:
+                continue
+
+if hapc_core is None:
+    raise ImportError(
+        "hapc_core module not found. The C++ extension may not be built.\n"
+        "Try: pip install -e . --force-reinstall --no-cache-dir"
+    )
+
+class DesignOutput(NamedTuple):
+    """Output from pchal_design."""
+    H: np.ndarray
+    U: np.ndarray
+    d: np.ndarray
+    V: np.ndarray
+
+class OptimizerOutput(NamedTuple):
+    """Output from optimizer functions."""
+    alpha: np.ndarray
+    alphaiters: np.ndarray
+    beta: np.ndarray
+    risk: float
+    iter: int
+
+def _ensure_c_contiguous(arr: np.ndarray, dtype=np.float64) -> np.ndarray:
+    """Ensure array is C-contiguous double."""
+    arr = np.asarray(arr, dtype=dtype)
+    return np.ascontiguousarray(arr) if not arr.flags['C_CONTIGUOUS'] else arr
+
+def pchal_design(X: np.ndarray, maxdeg: int, npc: int, center: bool = True) -> DesignOutput:
+    """Generate PC-HAL design components."""
+    X = _ensure_c_contiguous(X)
+    n = X.shape[0]
+    
+    # Cap npc at n-1 when center=True (rank reduction due to centering)
+    # Cap npc at n when center=False
+    max_npc = n - 1 if center else n
+    npc = min(npc, max_npc)
+    npc = max(1, npc)  # At least 1
+    
+    result = hapc_core.pchal_des(X, int(maxdeg), int(npc), bool(center))
+    return DesignOutput(result.H, result.U, result.d, result.V)
+
+def ridge_regression(Y: np.ndarray, U: np.ndarray, D2: np.ndarray, 
+                     lambda_: float) -> np.ndarray:
+    """Ridge regression solver."""
+    Y = _ensure_c_contiguous(Y, np.float64)
+    U = _ensure_c_contiguous(U, np.float64)
+    D2 = _ensure_c_contiguous(D2, np.float64)
+    return hapc_core.ridge_call(Y, U, D2, float(lambda_))
+
+def mkernel(X: np.ndarray, m: int, center: bool = True) -> np.ndarray:
+    """Compute Haar-like kernel matrix."""
+    X = _ensure_c_contiguous(X)
+    return hapc_core.mkernel_call(X, int(m), bool(center))
+
+def kernel_cross(Xtr: np.ndarray, Xte: np.ndarray, m: int, 
+                 center: bool = True) -> np.ndarray:
+    """Compute cross-kernel between training and test data."""
+    Xtr = _ensure_c_contiguous(Xtr)
+    Xte = _ensure_c_contiguous(Xte)
+    return hapc_core.kernel_cross_call(Xtr, Xte, int(m), bool(center))
+
+def pcghal(Y: np.ndarray, Xtilde: np.ndarray, ENn: np.ndarray, 
+           alpha0: np.ndarray, max_iter: int = 100, tol: float = 1e-6,
+           step_factor: float = 1.0, verbose: bool = False,
+           crit: str = "grad") -> OptimizerOutput:
+    """PC-GHAL optimizer (regression)."""
+    Y = _ensure_c_contiguous(Y)
+    Xtilde = _ensure_c_contiguous(Xtilde)
+    ENn = _ensure_c_contiguous(ENn)
+    alpha0 = _ensure_c_contiguous(alpha0)
+    
+    result = hapc_core.pcghal_call(Y, Xtilde, ENn, alpha0, int(max_iter), 
+                          float(tol), float(step_factor), bool(verbose), str(crit))
+    return OptimizerOutput(result.alpha, result.alphaiters, result.beta, 
+                          result.risk, result.iter)
+
+def pcghal_classification(Y: np.ndarray, Xtilde: np.ndarray, ENn: np.ndarray,
+                          alpha0: np.ndarray, max_iter: int = 100, 
+                          tol: float = 1e-6, step_factor: float = 1.0,
+                          verbose: bool = False) -> OptimizerOutput:
+    """PC-GHAL optimizer (classification)."""
+    Y = _ensure_c_contiguous(Y)
+    Xtilde = _ensure_c_contiguous(Xtilde)
+    ENn = _ensure_c_contiguous(ENn)
+    alpha0 = _ensure_c_contiguous(alpha0)
+    
+    result = hapc_core.pcghal_classi_call(Y, Xtilde, ENn, alpha0, int(max_iter),
+                                 float(tol), float(step_factor), bool(verbose))
+    return OptimizerOutput(result.alpha, result.alphaiters, result.beta,
+                          result.risk, result.iter)
+
+def fast_pchal(U: np.ndarray, D2: np.ndarray, Y: np.ndarray, 
+               lambda_: float) -> np.ndarray:
+    """Fast LASSO-type solver."""
+    U = _ensure_c_contiguous(U)
+    D2 = _ensure_c_contiguous(D2)
+    Y = _ensure_c_contiguous(Y)
+    return hapc_core.fast_pchal_call(U, D2, Y, float(lambda_))
+
+__all__ = [
+    "DesignOutput",
+    "OptimizerOutput",
+    "pchal_design",
+    "ridge_regression",
+    "mkernel",
+    "kernel_cross",
+    "pcghal",
+    "pcghal_classification",
+    "fast_pchal",
+]

hapc/cv.py

@@ -0,0 +1,340 @@
+"""Cross-validation functions - calls C++ fasthal_cv_call."""
+
+import numpy as np
+from typing import Optional, NamedTuple
+import ctypes
+from .core import kernel_cross, mkernel
+
+class CVResult(NamedTuple):
+    """Cross-validation result."""
+    mses: np.ndarray
+    lambdas: np.ndarray
+    best_lambda: float
+    best_model_alpha: np.ndarray
+    predictions: Optional[np.ndarray] = None
+
+def pcghal_cv(X: np.ndarray, Y: np.ndarray, maxdeg: int, npc: int,
+              lambdas: Optional[np.ndarray] = None,
+              log_lambda_min: float = -5, 
+              log_lambda_max: float = -3,
+              grid_length: int = 10,
+              nfolds: int = 5,
+              predict: Optional[np.ndarray] = None,
+              center: bool = True, verbose: bool = False,
+              max_iter: int = 100, tol: float = 1e-6) -> CVResult:
+    """
+    Cross-validation for PC-GHAL with gradient descent optimizer.
+    Calls C++ pcghal_cv_fit directly (matches R pchal_cv_call).
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    maxdeg : int
+        Maximum degree of interactions
+    npc : int
+        Number of principal components
+    lambdas : np.ndarray, optional
+        Array of lambda regularization parameters to test.
+        If None, generates grid from log_lambda_min to log_lambda_max.
+    log_lambda_min : float, default=-5
+        Minimum log(lambda) for grid generation (if lambdas is None)
+    log_lambda_max : float, default=-3
+        Maximum log(lambda) for grid generation (if lambdas is None)
+    grid_length : int, default=10
+        Number of lambda values to generate (if lambdas is None)
+    nfolds : int, default=5
+        Number of folds for cross-validation
+    predict : np.ndarray, optional
+        Test data for predictions
+    center : bool, default=True
+        Center the design matrix
+    verbose : bool, default=False
+        Print progress information
+    max_iter : int, default=100
+        Maximum iterations for optimizer
+    tol : float, default=1e-6
+        Convergence tolerance
+    
+    Returns
+    -------
+    CVResult
+        Cross-validation results with best lambda and predictions
+    """
+    from .core import _ensure_c_contiguous, hapc_core
+    
+    X = _ensure_c_contiguous(X)
+    Y = _ensure_c_contiguous(Y)
+    
+    # Generate lambda grid if not provided
+    if lambdas is None:
+        log_lambdas = np.linspace(log_lambda_min, log_lambda_max, grid_length)
+        lambdas = np.exp(log_lambdas)
+    
+    lambdas = np.asarray(lambdas, dtype=np.float64)
+    n, p = X.shape
+    
+    if predict is not None:
+        predict = _ensure_c_contiguous(predict)
+    else:
+        predict = np.array([], dtype=np.float64).reshape(0, p)
+    
+    if verbose:
+        print("=" * 60)
+        print("PC-GHAL Cross-Validation (C++ Implementation)")
+        print("=" * 60)
+        print(f"Lambda grid: {len(lambdas)} values from {lambdas.min():.6f} to {lambdas.max():.6f}")
+    
+    # Call C++ pcghal_cv_fit directly
+    result_cpp = hapc_core.pcghal_cv_fit(
+        X, Y, maxdeg, npc, lambdas.tolist(), nfolds,
+        predict,
+        max_iter, tol, 1.0, verbose, "risk", center, False
+    )
+    
+    # Extract predictions
+    predictions_out = None
+    if predict.shape[0] > 0 and result_cpp.predictions.size > 0:
+        predictions_out = result_cpp.predictions
+    
+    return CVResult(
+        mses=np.array(result_cpp.mses),
+        lambdas=np.array(result_cpp.lambdas),
+        best_lambda=result_cpp.best_lambda,
+        best_model_alpha=result_cpp.best_alpha,
+        predictions=predictions_out
+    )
+
+
+def fasthal_cv(X: np.ndarray, Y: np.ndarray, npc: int,
+               lambdas: np.ndarray, nfolds: int = 5,
+               predict: Optional[np.ndarray] = None,
+               maxdeg: int = 1, center: bool = True,
+               approx: bool = False, l1: bool = False) -> CVResult:
+    """
+    Fast cross-validation with L1 (LASSO) or L2 (Ridge) penalties.
+    Matches R cv.hapc with norm="1" or norm="2".
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    npc : int
+        Number of principal components
+    lambdas : np.ndarray
+        Array of lambda regularization parameters to test
+    nfolds : int, default=5
+        Number of folds for cross-validation
+    predict : np.ndarray, optional
+        Test data for predictions
+    maxdeg : int, default=1
+        Maximum degree of interactions
+    center : bool, default=True
+        Center the design matrix
+    approx : bool, default=False
+        Use approximate eigendecomposition
+    l1 : bool, default=False
+        Use L1 penalty (LASSO), otherwise L2 (Ridge)
+    
+    Returns
+    -------
+    CVResult
+        Cross-validation results with best lambda and predictions
+    """
+    from .single import single_lambda_fit
+    from .core import _ensure_c_contiguous, pchal_design
+    from sklearn.model_selection import KFold
+    
+    X = _ensure_c_contiguous(X)
+    Y = _ensure_c_contiguous(Y)
+    lambdas = np.asarray(lambdas, dtype=np.float64)
+    n, p = X.shape
+    
+    if predict is not None:
+        predict = _ensure_c_contiguous(predict)
+    else:
+        predict = np.array([], dtype=np.float64).reshape(0, p)
+    
+    # CV loop
+    cv = KFold(n_splits=nfolds, shuffle=True, random_state=42)
+    cv_mses = np.zeros((nfolds, len(lambdas)))
+    
+    fold_idx = 0
+    for train_idx, test_idx in cv.split(X):
+        X_train, X_test = X[train_idx], X[test_idx]
+        Y_train, Y_test = Y[train_idx], Y[test_idx]
+        
+        for j, lam in enumerate(lambdas):
+            # Fit on train
+            result = single_lambda_fit(X_train, Y_train, maxdeg=maxdeg, 
+                                       npc=npc, single_lambda=lam, 
+                                       center=center, approx=approx, l1=l1)
+            
+            # Predict on test
+            if X_test.shape[0] > 0 and result.alpha is not None:
+                # Make predictions on test set using predict parameter
+                result_test = single_lambda_fit(X_train, Y_train, maxdeg=maxdeg, 
+                                                npc=npc, single_lambda=lam, 
+                                                predict=X_test,
+                                                center=center, approx=approx, l1=l1)
+                
+                if result_test.predictions is not None:
+                    y_pred = result_test.predictions
+                    cv_mses[fold_idx, j] = np.mean((Y_test - y_pred) ** 2)
+                else:
+                    cv_mses[fold_idx, j] = np.inf
+            else:
+                cv_mses[fold_idx, j] = np.inf
+        
+        fold_idx += 1
+    
+    # Average CV MSE
+    mean_mses = np.nanmean(cv_mses, axis=0)
+    best_idx = np.nanargmin(mean_mses)
+    best_lambda = lambdas[best_idx]
+    
+    # Refit on full data with best lambda
+    result_final = single_lambda_fit(X, Y, maxdeg=maxdeg, npc=npc,
+                                     single_lambda=best_lambda, center=center,
+                                     approx=approx, l1=l1)
+    
+    # Predictions on test set if provided
+    predictions_out = None
+    if predict is not None and predict.shape[0] > 0:
+        K_pred = kernel_cross(X, predict, m=maxdeg, center=center)
+        K = mkernel(X, m=maxdeg, center=center)
+        
+        evals, evecs = np.linalg.eigh(K)
+        des = pchal_design(X, maxdeg=maxdeg, npc=npc, center=center)
+        final_npc = des.d.shape[0]
+        
+        idx = np.argsort(-evals)[:final_npc]
+        U = evecs[:, idx]
+        D = np.sqrt(evals[idx])
+        D_inv = np.diag(1.0 / (D + 1e-12))
+        
+        predictions_out = K_pred @ U @ D_inv @ result_final.alpha
+        
+        if center:
+            predictions_out += Y.mean()
+    
+    return CVResult(
+        mses=mean_mses,
+        lambdas=lambdas,
+        best_lambda=best_lambda,
+        best_model_alpha=result_final.alpha,
+        predictions=predictions_out
+    )
+
+
+def cv_hapc(X: np.ndarray, Y: np.ndarray, maxdeg: int, npc: int,
+            log_lambda_min: float = -5, log_lambda_max: float = -3,
+            grid_length: int = 10, nfolds: int = 5,
+            norm: str = "sv", predict: Optional[np.ndarray] = None,
+            center: bool = True, approx: bool = False,
+            verbose: bool = False, max_iter: int = 100, 
+            tol: float = 1e-6) -> CVResult:
+    """
+    High-level cross-validation dispatcher matching R cv.hapc().
+    
+    Automatically generates lambda grid and routes to appropriate solver
+    based on norm parameter.
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    maxdeg : int
+        Maximum degree of interactions
+    npc : int
+        Number of principal components
+    log_lambda_min : float, default=-5
+        Minimum log(lambda) for grid generation
+    log_lambda_max : float, default=-3
+        Maximum log(lambda) for grid generation
+    grid_length : int, default=10
+        Number of lambda values to generate
+    nfolds : int, default=5
+        Number of CV folds
+    norm : str, default="sv"
+        Normalization/solver type:
+        - "sv": Gradient descent (PC-GHAL) via pcghal_cv
+        - "1": L1 penalty (LASSO) via fasthal_cv with l1=True
+        - "2": L2 penalty (Ridge) via fasthal_cv with l1=False
+    predict : np.ndarray, optional
+        Test data for predictions (shape: (m, p))
+    center : bool, default=True
+        Center the design matrix
+    approx : bool, default=False
+        Use approximate eigendecomposition (for norm="1" or "2")
+    verbose : bool, default=False
+        Print progress information
+    max_iter : int, default=100
+        Maximum iterations for optimizer (norm="sv" only)
+    tol : float, default=1e-6
+        Convergence tolerance (norm="sv" only)
+    
+    Returns
+    -------
+    CVResult
+        Cross-validation results with fields:
+        - mses: MSE for each lambda
+        - lambdas: Lambda values tested
+        - best_lambda: Optimal lambda
+        - best_model_alpha: Coefficients for best model
+        - predictions: Predictions on test set (if predict provided)
+    
+    Examples
+    --------
+    >>> # Gradient descent (PC-GHAL)
+    >>> cv_sv = cv_hapc(X, Y, maxdeg=2, npc=10, norm="sv")
+    
+    >>> # Ridge regression
+    >>> cv_l2 = cv_hapc(X, Y, maxdeg=2, npc=10, norm="2")
+    
+    >>> # LASSO
+    >>> cv_l1 = cv_hapc(X, Y, maxdeg=2, npc=10, norm="1")
+    
+    >>> # With predictions
+    >>> cv_sv = cv_hapc(X, Y, maxdeg=2, npc=10, norm="sv", predict=Xnew)
+    """
+    # Generate lambda grid from log scale
+    log_lambdas = np.linspace(log_lambda_min, log_lambda_max, grid_length)
+    lambdas = np.exp(log_lambdas)
+    
+    if verbose:
+        print(f"CV with norm='{norm}'")
+        print(f"Lambda grid: {len(lambdas)} values from {lambdas.min():.6f} to {lambdas.max():.6f}")
+    
+    if norm == "sv":
+        # Gradient descent optimizer (PC-GHAL)
+        if verbose:
+            print("Using PC-GHAL gradient descent optimizer")
+        return pcghal_cv(X, Y, maxdeg, npc, lambdas=lambdas, nfolds=nfolds,
+                        predict=predict, center=center, verbose=verbose,
+                        max_iter=max_iter, tol=tol)
+    
+    elif norm == "1":
+        # L1 penalty (LASSO)
+        if verbose:
+            print("Using L1 penalty (LASSO soft-thresholding)")
+        return fasthal_cv(X, Y, npc, lambdas, nfolds=nfolds,
+                         predict=predict, maxdeg=maxdeg, center=center,
+                         approx=approx, l1=True)
+    
+    elif norm == "2":
+        # L2 penalty (Ridge)
+        if verbose:
+            print("Using L2 penalty (Ridge regression)")
+        return fasthal_cv(X, Y, npc, lambdas, nfolds=nfolds,
+                         predict=predict, maxdeg=maxdeg, center=center,
+                         approx=approx, l1=False)
+    
+    else:
+        raise ValueError(f"Unknown norm='{norm}'. Must be 'sv', '1', or '2'")

hapc/single.py

@@ -0,0 +1,259 @@
+"""Single lambda model fitting - wraps C++ single_lambda_pchar."""
+
+import numpy as np
+from typing import Optional, NamedTuple
+from .core import (pchal_design, ridge_regression, kernel_cross, mkernel, 
+                   pcghal, pcghal_classification)
+
+class SingleLambdaResult(NamedTuple):
+    """Result from single_lambda_pchar."""
+    alpha: np.ndarray
+    predictions: Optional[np.ndarray] = None
+    lambda_: float = None
+    optimizer_output: Optional[NamedTuple] = None  # Full optimizer output for norm="sv"
+
+class SinglePcghalResult(NamedTuple):
+    """Result from single_pcghal (gradient descent optimizer)."""
+    alpha: np.ndarray
+    predictions: Optional[np.ndarray] = None
+    lambda_: float = None
+    optimizer_output: Optional[NamedTuple] = None
+    risk: float = None
+    iter: int = None
+
+def single_lambda_fit(X: np.ndarray, Y: np.ndarray, maxdeg: int, npc: int,
+                      single_lambda: float, predict: Optional[np.ndarray] = None,
+                      center: bool = True, approx: bool = False, l1: bool = False) -> SingleLambdaResult:
+    """
+    Fit model with single lambda using either L1 or L2 penalty.
+    Mirrors C++ single_lambda_pchar implementation.
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    maxdeg : int
+        Maximum degree of interactions
+    npc : int
+        Number of principal components
+    single_lambda : float
+        Regularization parameter
+    predict : np.ndarray, optional
+        Test data for predictions
+    center : bool, default=True
+        Center the design matrix
+    approx : bool, default=False
+        Use approximate eigendecomposition
+    l1 : bool, default=False
+        Use L1 penalty (LASSO), otherwise L2 (Ridge)
+    
+    Returns
+    -------
+    SingleLambdaResult
+        Named tuple with alpha coefficients and optional predictions
+    """
+    X = np.asarray(X, dtype=np.float64, order='C')
+    Y = np.asarray(Y, dtype=np.float64, order='C')
+    n, p = X.shape
+    
+    # Generate design
+    des = pchal_design(X, maxdeg, npc, center=center)
+    final_npc = des.d.shape[0]
+    
+    # Kernel matrix
+    K = mkernel(X, maxdeg, center=center)
+    
+    # Eigendecomposition
+    evals, evecs = np.linalg.eigh(K)
+    idx = np.argsort(-evals)[:final_npc]
+    U = evecs[:, idx]
+    D = np.sqrt(evals[idx])  # Singular values (square root of eigenvalues)
+    D2 = evals[idx]  # Eigenvalues for ridge_call
+    
+    # Xtilde = U * D (singular values)
+    Xtilde = U @ np.diag(D)
+    
+    # Center Y
+    ymean = Y.mean() if center else 0.0
+    Y_centered = Y - ymean if center else Y
+    
+    # Solve
+    if l1:
+        # LASSO: use fast_pchal_call logic
+        from .core import fast_pchal
+        alpha = fast_pchal(U, D2, Y_centered, single_lambda)
+    else:
+        # Ridge: use ridge_call logic
+        from .core import ridge_regression
+        alpha = ridge_regression(Y_centered, U, D2, single_lambda)
+    
+    # Predictions
+    predictions_out = None
+    if predict is not None:
+        predict = np.asarray(predict, dtype=np.float64, order='C')
+        if predict.shape[1] != p:
+            raise ValueError(f"predict must have {p} columns")
+        
+        Ktest = kernel_cross(X, predict, maxdeg, center=center)
+        D2_inv_sqrt = np.diag(1.0 / np.sqrt(D2 + 1e-12))
+        predictions_out = Ktest @ U @ D2_inv_sqrt @ alpha
+        
+        if center:
+            predictions_out += ymean
+    
+    return SingleLambdaResult(alpha=alpha, predictions=predictions_out, lambda_=single_lambda)
+
+
+def single_pcghal(X: np.ndarray, Y: np.ndarray, maxdeg: int, npc: int,
+                  single_lambda: float, predict: Optional[np.ndarray] = None,
+                  center: bool = True, approx: bool = False, verbose: bool = False,
+                  max_iter: int = 100, tol: float = 1e-6) -> SinglePcghalResult:
+    """
+    Fit model with single lambda using gradient descent optimizer (PC-GHAL).
+    This is the high-level interface matching R's hapc() with norm="sv".
+    **Calls the C++ single_pcghal_fit function directly.**
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    maxdeg : int
+        Maximum degree of interactions
+    npc : int
+        Number of principal components
+    single_lambda : float
+        Regularization parameter
+    predict : np.ndarray, optional
+        Test data for predictions
+    center : bool, default=True
+        Center the design matrix
+    approx : bool, default=False
+        Use approximate eigendecomposition
+    verbose : bool, default=False
+        Print iteration details
+    max_iter : int, default=100
+        Maximum iterations for gradient descent
+    tol : float, default=1e-6
+        Convergence tolerance
+    
+    Returns
+    -------
+    SinglePcghalResult
+        Named tuple with alpha, predictions, optimizer output, and convergence info
+    """
+    from .core import _ensure_c_contiguous, hapc_core
+    
+    X = _ensure_c_contiguous(X)
+    Y = _ensure_c_contiguous(Y)
+    n, p = X.shape
+    
+    # Prepare prediction data
+    if predict is not None:
+        predict = _ensure_c_contiguous(predict)
+        if predict.shape[1] != p:
+            raise ValueError(f"predict must have {p} columns")
+        predict_data = predict
+    else:
+        # Empty matrix for no predictions
+        predict_data = np.array([], dtype=np.float64).reshape(0, p)
+    
+    if verbose:
+        print("=" * 60)
+        print("PC-GHAL Single Lambda Optimization (C++ Implementation)")
+        print("=" * 60)
+        print()
+    
+    # Call C++ single_pcghal_fit directly
+    result_cpp = hapc_core.single_pcghal_fit(
+        X, Y, maxdeg, npc, single_lambda, predict_data,
+        max_iter, tol, 1.0, verbose, "grad", center, approx
+    )
+    
+    # Extract predictions
+    predictions_out = None
+    if predict is not None and result_cpp.predictions.size > 0:
+        predictions_out = result_cpp.predictions
+    
+    return SinglePcghalResult(
+        alpha=result_cpp.alpha,
+        predictions=predictions_out,
+        lambda_=single_lambda,
+        optimizer_output=None,  # Not available from C++ output
+        risk=result_cpp.risk,
+        iter=result_cpp.iter
+    )
+
+
+
+def hapc(X: np.ndarray, Y: np.ndarray, maxdeg: int, npc: int,
+         single_lambda: float, norm: str = "sv", predict: Optional[np.ndarray] = None,
+         center: bool = True, approx: bool = False, verbose: bool = False,
+         max_iter: int = 100, tol: float = 1e-6) -> SinglePcghalResult:
+    """
+    High-level interface matching R's hapc() function.
+    Dispatches to appropriate solver based on norm parameter.
+    
+    Parameters
+    ----------
+    X : np.ndarray, shape (n, p)
+        Input features
+    Y : np.ndarray, shape (n,)
+        Response variable
+    maxdeg : int
+        Maximum degree of interactions
+    npc : int
+        Number of principal components
+    single_lambda : float
+        Regularization parameter
+    norm : str, default="sv"
+        Normalization/solver type:
+        - "1": L1 penalty (LASSO soft-thresholding)
+        - "2": L2 penalty (Ridge regression, closed-form)
+        - "sv": Supervised (gradient descent optimizer PC-GHAL)
+    predict : np.ndarray, optional
+        Test data for predictions
+    center : bool, default=True
+        Center the design matrix
+    approx : bool, default=False
+        Use approximate eigendecomposition
+    verbose : bool, default=False
+        Print iteration details
+    max_iter : int, default=100
+        Maximum iterations (for norm="sv")
+    tol : float, default=1e-6
+        Convergence tolerance (for norm="sv")
+    
+    Returns
+    -------
+    SinglePcghalResult or SingleLambdaResult
+        Fit results with predictions
+    """
+    if verbose:
+        print(f"HAPC with norm='{norm}'")
+    
+    if norm == "1":
+        # L1 (LASSO)
+        if verbose:
+            print("Using L1 penalty (soft-thresholding)")
+        return single_lambda_fit(X, Y, maxdeg, npc, single_lambda, predict=predict,
+                                center=center, approx=approx, l1=True)
+    elif norm == "2":
+        # L2 (Ridge)
+        if verbose:
+            print("Using L2 penalty (ridge regression)")
+        return single_lambda_fit(X, Y, maxdeg, npc, single_lambda, predict=predict,
+                                center=center, approx=approx, l1=False)
+    elif norm == "sv":
+        # Supervised (Gradient Descent)
+        if verbose:
+            print("Using gradient descent optimizer (PC-GHAL)")
+        return single_pcghal(X, Y, maxdeg, npc, single_lambda, predict=predict,
+                            center=center, approx=approx, verbose=verbose,
+                            max_iter=max_iter, tol=tol)
+    else:
+        raise ValueError(f"Unknown norm='{norm}'. Must be '1', '2', or 'sv'")
+

hapc-0.1.2.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: hapc
+Version: 0.1.2
+Summary: Hierarchical Additive Polynomial Complexity regression
+Home-page: https://github.com/meixide/hapc
+Author: Carlos García Meixide
+Author-email: Carlos García Meixide <cgmeixide@gmail.com>
+License: YEAR: 2025
+        COPYRIGHT HOLDER: Carlos García Meixide
+Project-URL: Homepage, https://github.com/meixide/hapc
+Project-URL: Documentation, https://github.com/meixide/hapc#readme
+Project-URL: Repository, https://github.com/meixide/hapc.git
+Project-URL: Issues, https://github.com/meixide/hapc/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.3,>=1.24
+Requires-Dist: scipy>=1.7
+Requires-Dist: scikit-learn>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# HAPC: Highly Adaptive Prinicipal Components
+
+A fast and flexible machine learning library for nonparametric high-dimensional regression and classification with guarantees.
+
+## Installation
+
+### Prerequisites
+
+- Python 3.8+
+- C++ compiler (g++, clang, or MSVC)
+- CMake 3.15+
+- Eigen3
+
+### Quick Install
+
+```bash
+pip install hapc
+```
+
+### Install from GitHub (latest development version)
+
+```bash
+pip install git+https://github.com/yourusername/hapc.git
+```
+
+Or with editable install for development:
+
+```bash
+git clone https://github.com/yourusername/hapc.git
+cd hapc
+pip install -e .
+```
+
+### Install build dependencies
+
+If installation fails, you may need to install build dependencies:
+
+**macOS:**
+```bash
+brew install cmake eigen
+```
+
+**Ubuntu/Debian:**
+```bash
+sudo apt-get install cmake libeigen3-dev build-essential
+```
+
+**Windows:**
+```bash
+pip install cmake
+# Install Visual Studio Build Tools or use conda
+conda install -c conda-forge eigen
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from hapc.single import single_pcghal
+from hapc.cv import pcghal_cv
+
+# Generate sample data
+X = np.random.randn(100, 5)
+Y = X[:, 0] + 0.5 * X[:, 1] + np.random.randn(100) * 0.1
+
+# Single fit with fixed lambda
+result = single_pcghal(X, Y, maxdeg=2, npc=5, single_lambda=0.01)
+print(f"Risk: {result.optimizer_output.risk:.6f}")
+
+# Cross-validation to select lambda
+lambdas = np.logspace(-4, 0, 10)
+cv_result = pcghal_cv(X, Y, maxdeg=2, npc=5, lambdas=lambdas, nfolds=5)
+print(f"Best lambda: {cv_result.best_lambda:.6f}")
+
+# Make predictions
+X_test = np.random.randn(20, 5)
+result = single_pcghal(X, Y, maxdeg=2, npc=5, single_lambda=0.01, predict=X_test)
+print(f"Predictions: {result.predictions}")
+```
+
+## Usage
+
+### Regression
+
+```python
+from hapc.single import single_pcghal
+
+result = single_pcghal(
+    X, Y,
+    maxdeg=2,        # Maximum degree of interactions
+    npc=10,          # Number of principal components
+    single_lambda=0.01,
+    predict=X_test   # Optional: test data for predictions
+)
+```
+
+### Classification
+
+```python
+from hapc.single import single_pcghal
+
+result = single_pcghal(
+    X, Y_binary,
+    maxdeg=2,
+    npc=10,
+    single_lambda=0.01,
+    predict=X_test
+)
+```
+
+### Cross-Validation
+
+```python
+from hapc.cv import pcghal_cv
+
+cv_result = pcghal_cv(
+    X, Y,
+    maxdeg=2,
+    npc=10,
+    lambdas=np.logspace(-4, 0, 20),
+    nfolds=5
+)
+print(cv_result.best_lambda)
+```
+
+## API Reference
+
+### `hapc.single.single_pcghal()`
+
+Fit PC-GHAL with a single lambda value.
+
+**Parameters:**
+- `X` (ndarray, shape (n, p)): Input features
+- `Y` (ndarray, shape (n,)): Response variable
+- `maxdeg` (int): Maximum degree of interactions
+- `npc` (int): Number of principal components
+- `single_lambda` (float): Regularization parameter
+- `max_iter` (int, default=100): Maximum iterations
+- `tol` (float, default=1e-6): Convergence tolerance
+- `verbose` (bool, default=False): Print progress
+- `predict` (ndarray, optional): Test data for predictions
+- `center` (bool, default=True): Center the design matrix
+
+**Returns:**
+- `result.optimizer_output.alpha`: Coefficients
+- `result.optimizer_output.risk`: Final risk
+- `result.optimizer_output.iter`: Iterations until convergence
+- `result.predictions`: Predictions on test data (if provided)
+
+### `hapc.cv.pcghal_cv()`
+
+Cross-validation to select lambda.
+
+**Parameters:**
+- `lambdas` (ndarray): Grid of lambda values to test
+- `nfolds` (int, default=5): Number of CV folds
+- ...other parameters same as `single_pcghal`
+
+**Returns:**
+- `cv_result.best_lambda`: Optimal lambda
+- `cv_result.mses`: CV errors for each lambda
+- `cv_result.best_model`: Fitted model with best lambda
+- `cv_result.predictions`: Predictions on test data (if provided)
+
+## Contributing
+
+Contributions welcome! The C++ core is shared between R and Python packages.
+
+```bash
+git clone https://github.com/yourusername/hapc.git
+cd hapc
+pip install -e .
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file

hapc-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+hapc/__init__.py,sha256=88Qoy-X9m1I-CyiJaHP0NZaZEok4_dcX9SKTuyQEtzA,696
+hapc/core.py,sha256=Uw75VwMOQ-4RoNjNAAA34TDTQxYtFxeRKOe8ZIToB2c,5184
+hapc/cv.py,sha256=M5_TB7oPyaZBoILY2cf6R2CMoXhHUSnGanNgAl6g3rk,12424
+hapc/single.py,sha256=_KWfTPLEcvMc8hWllyjGARkxYznSDNhhOn8qv0kURVA,9149
+hapc-0.1.2.dist-info/licenses/LICENSE,sha256=xsHdXeHSuT_rM0lZucaImzebBKKguXPMxSfXZSv_Tto,52
+hapc-0.1.2.dist-info/METADATA,sha256=tLG5p8lpTFPe8a_pdRT3SeV0jmuWhR9Fi8C3ByqBHMM,5499
+hapc-0.1.2.dist-info/WHEEL,sha256=XkFE14KmFh7mutkkb-qn_ueuH2lwfT8rLdfc5xpQ7wE,99
+hapc-0.1.2.dist-info/top_level.txt,sha256=wlXqf3dR7pUrCp1U_cLzGyKzGcVoinK6DjtIMqHWGDA,5
+hapc-0.1.2.dist-info/RECORD,,

hapc-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64
+

hapc-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,2 @@
+YEAR: 2025
+COPYRIGHT HOLDER: Carlos García Meixide

hapc-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+hapc