twoblock 0.0.1__tar.gz

twoblock-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sven Serneels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

twoblock-0.0.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: twoblock
+Version: 0.0.1
+Summary: A Scikit-Learn Compatible Library for Simultaneous Two-Block Sufficient Dimension Reduction Methods
+Home-page: https://github.com/SvenSerneels/twoblock
+Author: Sven Serneels
+Author-email: svenserneels@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: scipy>=1.8.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: pandas>=1.4.0
+
+# twoblock
+Two-block simultaneous dimension reduction 
+
+A scikitlearn compatible implementation of simultaneous two-block dimension reduction as proposed in [1]. 
+
+References
+----------
+[1] Cook, R. Dennis, Liliana Forzani, and Lan Liu.
+    "Partial least squares for simultaneous reduction of response and predictor
+    vectors in regression." Journal of Multivariate Analysis 196 (2023): 105163.

twoblock-0.0.1/README.md

@@ -0,0 +1,10 @@
+# twoblock
+Two-block simultaneous dimension reduction 
+
+A scikitlearn compatible implementation of simultaneous two-block dimension reduction as proposed in [1]. 
+
+References
+----------
+[1] Cook, R. Dennis, Liliana Forzani, and Lan Liu.
+    "Partial least squares for simultaneous reduction of response and predictor
+    vectors in regression." Journal of Multivariate Analysis 196 (2023): 105163.

twoblock-0.0.1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description-file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

twoblock-0.0.1/setup.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Jul 22 12:18:53 2018
+
+@author: Sven serneels, Ponalytics
+"""
+
+from setuptools import setup, find_packages
+import re
+import sys
+import os
+
+SRC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "./src")
+if SRC_DIR not in sys.path:
+    sys.path.insert(0, SRC_DIR)
+from twoblock import __version__, __author__, __license__
+
+readme_file = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "README.md"
+)
+try:
+    from m2r import parse_from_file
+
+    readme = parse_from_file(readme_file)
+except ImportError:
+    # m2r may not be installed in user environment
+    with open(readme_file) as f:
+        readme = f.read()
+
+setup(
+    name="twoblock",
+    version=__version__,
+    author=__author__,
+    author_email="svenserneels@gmail.com",
+    description="A Scikit-Learn Compatible Library for Simultaneous Two-Block Sufficient Dimension Reduction Methods",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    url="https://github.com/SvenSerneels/twoblock",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    packages=find_packages("src"),  # include all packages under src
+    package_dir={"": "src"},  # tell distutils packages are under src
+    include_package_data=True,
+    install_requires=[
+        "numpy>=1.22.0",
+        "scipy>=1.8.0",
+        "scikit-learn>=1.3.0",
+        "pandas>=1.4.0",
+    ],
+)

twoblock-0.0.1/src/twoblock/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Jul 22 12:17:17 2018
+
+@author: Sven Serneels, Ponalytics
+"""
+
+__name__ = "twoblock"
+__author__ = "Sven Serneels"
+__license__ = "MIT"
+__version__ = "0.0.1"
+__date__ = "2024-08-07"
+
+# The commented lines can be uncommented if IPOPT has been installed independently.
+
+from .twoblock import twoblock

twoblock-0.0.1/src/twoblock/_preproc_utilities.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Dec 21 10:55:24 2019
+
+Set of help functions for robust centring and scaling 
+
+@author: Sven Serneels, Ponalytics
+"""
+
+import numpy as np
+import pandas as ps
+import scipy.stats as sps
+import scipy.optimize as spo
+import copy
+
+
+def _handle_zeros_in_scale(scale, copy=True):
+    """
+    Makes sure that whenever scale is zero, we handle it correctly.
+    This happens in most scalers when we have constant features.
+    Taken from ScikitLearn.preprocesssing"""
+
+    # if we are fitting on 1D arrays, scale might be a scalar
+    if np.isscalar(scale):
+        if scale == 0.0:
+            scale = 1.0
+        return scale
+    elif isinstance(scale, np.ndarray):
+        if copy:
+            # New array to avoid side-effects
+            scale = scale.copy()
+        scale[scale == 0.0] = 1.0
+        return scale
+
+
+def _check_trimming(t):
+
+    if (t > 0.99) or (t < 0):
+        raise (ValueError("Trimming fraction must be in [0,1)"))
+
+
+def mad(X, c=0.6744897501960817, **kwargs):
+    """
+    Column-wise median absolute deviation. **kwargs included to allow
+    general function call in scale_data.
+    """
+
+    s = median(np.abs(X - median(X, axis=0)), axis=0) / c
+    s = np.array(s).reshape(-1)
+    # statsmodels.robust.mad is not as flexible toward matrix input,
+    # sometimes throws a value error in ufunc
+    return s
+
+
+def median(X, **kwargs):
+    """
+    Column-wise median. **kwargs included to allow
+    general function call in scale_data.
+    """
+
+    if np.isnan(X).any():
+        m = np.nanmedian(X, axis=0)
+    else:
+        m = np.median(X, axis=0)
+    m = np.array(m).reshape(-1)
+
+    return m
+
+
+def mean(X, trimming=0):
+    """
+    Column-wise mean or trimmed mean. Trimming to be entered as fraction.
+    """
+
+    if trimming == 0:
+        if np.isnan(X).any():
+            m = np.nanmean(X, axis=0)
+        else:
+            m = np.mean(X, axis=0)
+    else:
+        # Returns all NaN if missings in X
+        m = sps.trim_mean(X, trimming, 0)
+
+    return m
+
+
+def std(X, trimming=0):
+    """
+    Column-wise standard devaition or trimmed std.
+    Trimming to be entered as fraction.
+    """
+
+    if trimming == 0:
+        if np.isnan(X).any():
+            s = np.power(np.nanvar(X, axis=0), 0.5)
+        else:
+            s = np.power(np.var(X, axis=0), 0.5)
+        s = np.array(s).reshape(-1)
+    else:
+        var = sps.trim_mean(
+            np.square(X - sps.trim_mean(X, trimming, 0)), trimming, 0
+        )
+        s = np.sqrt(var)
+    return s
+
+
+def _euclidnorm(x):
+    """
+    Euclidean norm of a vector
+    """
+
+    if np.isnan(x).any():
+        return np.sqrt(np.nansum(np.square(x)))
+    else:
+        return np.sqrt(np.sum(np.square(x)))
+
+
+def _diffmat_objective(a, X):
+    """
+    Utility to l1median, matrix of differences
+    """
+
+    (n, p) = X.shape
+    return X - np.tile(a, (n, 1))
+
+
+def _l1m_objective(a, X, *args):
+    """
+    Optimization objective for l1median
+    """
+
+    if np.isnan(X).any():
+        return np.nansum(
+            np.apply_along_axis(_euclidnorm, 1, _diffmat_objective(a, X))
+        )
+    else:
+        return np.sum(
+            np.apply_along_axis(_euclidnorm, 1, _diffmat_objective(a, X))
+        )
+
+
+def _l1m_jacobian(a, X):
+    """
+    Jacobian for l1median
+    """
+
+    (n, p) = X.shape
+    dX = _diffmat_objective(a, X)
+    dists = np.apply_along_axis(_euclidnorm, 1, dX)
+    dists = _handle_zeros_in_scale(dists)
+    dX /= np.tile(np.array(dists).reshape(n, 1), (1, p))
+    if np.isnan(X).any():
+        return -np.nansum(dX, axis=0)
+    else:
+        return -np.sum(dX, axis=0)
+
+
+def _l1median(
+    X, x0, method="SLSQP", tol=1e-8, options={"maxiter": 2000}, **kwargs
+):
+    """
+    Optimization for l1median
+    """
+
+    mu = spo.minimize(
+        _l1m_objective,
+        x0,
+        args=(X),
+        jac=_l1m_jacobian,
+        tol=tol,
+        options=options,
+        method=method,
+    )
+    return mu
+
+
+def l1median(X, **kwargs):
+    """
+    l1median wrapper to generically convert matrices as some of the scipy
+    optimization options will crash when provided matrix input.
+    """
+
+    if "x0" not in kwargs:
+        x0 = median(X)
+
+    if type(X) == np.matrix:
+        X = np.array(X)
+
+    if len(X.shape) == 2:
+        (n, p) = X.shape
+    else:
+        p = 1
+
+    if p < 2:
+        return median(X)
+    else:
+        return _l1median(X, x0, **kwargs).x
+
+
+def kstepLTS(X, maxit=5, tol=1e-10, **kwargs):
+    """
+    Computes the K-step LTS estimator of location
+    It uses the spatial median as a starting value, and yields an
+    estimator with improved statistical efficiency, but at a higher
+    computational cost.
+    Inputs:
+        X: data matrix
+        maxit: maximum number of iterations
+        tol: convergence tolerance
+    Outputs:
+        m2: location estimate
+    """
+    n, p = X.shape
+    m1 = l1median(X)  # initial estimate
+    m2 = copy.deepcopy(m1)
+    iteration = 0
+    unconverged = True
+    while unconverged and (iteration < maxit):
+        if np.isnan(X).any():
+            dists = np.nansum(np.square(X - m1), axis=1)
+        else:
+            dists = np.sum(np.square(X - m1), axis=1)
+        cutdist = np.sort(dists, axis=0)[int(np.floor((n + 1) / 2)) - 1]
+        hsubset = np.where(dists <= cutdist)[0]
+        m2 = np.array(mean(X[hsubset, :])).reshape((p,))
+        unconverged = max(abs(m1 - m2)) > tol
+        iteration += 1
+        m1 = copy.deepcopy(m2)
+
+    return m2
+
+
+def scaleTau2(x0, c1=4.5, c2=3, consistency=True, **kwargs):
+    """
+    Tau estimator of scale
+    Inputs:
+        x0: array or matrix, data
+        c1: consistency factor for initial estimate
+        c2: consistency factor for final estimate
+        consistency: str or bool,
+            False, True, or "finiteSample"
+    Output:
+        the scale estimate
+    """
+
+    x = copy.deepcopy(x0)
+    n, p = x.shape
+    if np.isnan(x).any():
+        summ = np.nansum
+    else:
+        summ = np.sum
+    medx = median(x)
+    xc = abs(x - medx)
+    sigma0 = median(xc)
+    if c1 > 0:
+        xc /= sigma0 * c1
+        w = 1 - np.square(xc)
+        w = np.square((abs(w) + w) / 2)
+        mu = summ(np.multiply(x, w)) / summ(w)
+    else:
+        mu = medx
+    x -= mu
+    x /= sigma0
+    rho = np.square(x)
+    rho[np.where(rho > c2**2)[0]] = c2**2
+    if consistency:
+
+        def Erho(b):
+            return (
+                2 * ((1 - b**2) * sps.norm.cdf(b) - b * sps.norm.pdf(b) + b**2)
+                - 1
+            )
+
+        def Es2(c2):
+            return Erho(c2 * sps.norm.ppf(3 / 4))
+
+        if consistency == "finiteSample":
+            nEs2 = (n - 2) * Es2(c2)
+        else:
+            nEs2 = n * Es2(c2)
+    else:
+        nEs2 = n
+    return np.array(sigma0 * np.sqrt(summ(rho) / nEs2)).reshape((p,))
+
+
+def scale_data(X, m, s):
+    """
+    Column-wise data scaling on location and scale estimates.
+
+    """
+
+    n = X.shape
+    if len(n) > 1:
+        p = n[1]
+    else:
+        p = 1
+    n = n[0]
+
+    s = _handle_zeros_in_scale(s)
+
+    if p == 1:
+        Xm = X - float(m)
+        Xs = Xm / s
+    else:
+        Xm = X - np.array([m for i in range(1, n + 1)])
+        Xs = Xm / np.array([s for i in range(1, n + 1)])
+    return Xs

twoblock-0.0.1/src/twoblock/robcent.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @author: Sven Serneels, Ponalytics
+# Created on Sun Feb 4 2018
+# Updated on Sun Dec 16 2018
+# Refactored on Sat Dec 21 2019
+# Refactored on Sat Mar 28 2020
+
+
+# Class for classical and robust centering and scaling of input data for
+# regression and machine learning
+
+# Version 2.0: Code entirely restructured compared to version 1.0.
+# Code made consistent with sklearn logic: fit(data,params) yields results.
+# Code makes more effciient use of numpy builtin estimators.
+# Version 3.0:
+# Code now takes strings or functions as input to centring and scaling.
+# Utility functions have been moved to _preproc_utilities.py
+# Code now supplied for l1median cetring, with options to use different
+# scipy.optimize optimization algorithms
+# Version 4.0:
+# Made the API compatible for ScikitLearn pipelines. However, some nonstandard
+# functions and output remain for backwards compatibility. Functionality for
+# sparse matrices still has to be implemented.
+
+
+# Ancillary functions in _preproc_utilities.py:
+
+#         -   `scale_data(X,m,s)`: centers and scales X on center m (as vector) and scale s (as vector).
+#         -   `mean(X,trimming)`: Column-wise mean.
+#         -   `median(X)`: Column-wise median.
+#         -   `l1median(X)`: L1 or spatial median. Optional arguments:
+#         -   `x0`: starting point for optimization, defaults to column wise median
+#         -   `method`: optimization algorithm, defaults to 'SLSQP'
+#         -   `tol`: tolerance, defaults to 1e-8
+#         -   `options`: list of options for `scipy.optimize.minimize`
+#         -   `kstepLTS(X): k-step LTS estimator of location.
+#         -   `maxit`: int, number of iterations to compute maximally
+#         -   `tol`: float, tolerance for convergence
+#         -   `std(X,trimming)`: Column-wise std.
+#         -   `mad(X,c)`: Column-wise median absolute deviation, with consistency factor c.
+#         -   `scaleTau2(x0, c1 = 4.5, c2 = 3, consistency = True)`: Tau estimator of scale
+#             with consistency parameters c1 and c2 and option for consistency correction
+#             (True, False or 'finiteSample')
+
+
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.metaestimators import _BaseComposition
+from sklearn.utils.validation import check_is_fitted
+import numpy as np
+from .utils import (
+    convert_X_input,
+    convert_y_input,
+    _check_input,
+)
+from ._preproc_utilities import *
+from ._preproc_utilities import _check_trimming
+
+__all__ = ["VersatileScaler", "robcent", "versatile_scale", "Wrapper", "wrap"]
+
+
+class VersatileScaler(_BaseComposition, TransformerMixin, BaseEstimator):
+    """
+    VersatileScaler Center and Scale data about classical or robust location and scale estimates
+
+    Parameters
+    ----------
+        `center`: str or callable, location estimator. String has to be name of the
+                function to be used, or 'None'.
+        `scale`: str or callable, scale estimator
+        `trimming`: trimming percentage to be used in location and scale estimation.
+
+
+    Attributes
+    ----------
+    Arguments for methods:
+        -   `X`: array-like, n x p, the data.
+        -   `trimming`: float, fraction to be trimmed (must be in (0,1)).
+
+
+
+
+    Remarks
+    -------
+    Options for classical estimators 'mean' and 'std' also give access to robust
+    trimmed versions.
+
+    """
+
+    def __init__(self, center="mean", scale="std", trimming=0):
+        """
+        Initialize values. Check if correct options provided.
+        """
+
+        self.center = center
+        self.scale = scale
+        self.trimming = trimming
+
+    def fit(self, X):
+        """
+        Estimate location and scale, store these in the class object.
+        Trimming fraction can be provided as keyword argument.
+        """
+
+        X = _check_input(X)
+
+        _check_trimming(self.trimming)
+
+        if type(self.center) is str:
+            center = eval(self.center)
+        else:
+            center = self.center
+
+        if type(self.scale) is str:
+            scale = eval(self.scale)
+        else:
+            scale = self.scale
+
+        n = X.shape
+        if len(n) > 1:
+            p = n[1]
+        else:
+            p = 1
+        n = n[0]
+
+        if self.center == "None":
+            m = np.repeat(0, p)
+        else:
+            m = center(X, trimming=self.trimming)
+
+        # Keeping col_loc_ for older version compatibility
+        setattr(self, "col_loc_", m)
+        # sklearn standard
+        setattr(self, "center_", m)
+
+        if self.scale == "None":
+            s = np.repeat(1, p)
+        else:
+            s = scale(X, trimming=self.trimming)
+
+        # Keeping col_sca_ for older version compatibility
+        setattr(self, "col_sca_", s)
+        # sklearn standard
+        setattr(self, "scale_", s)
+
+    def transform(self, X):
+        """
+        Center and/or scale training data to pre-estimated location and scale
+        """
+
+        X = _check_input(X)
+        check_is_fitted(self, ["center_", "scale_"])
+
+        Xs = scale_data(X, self.center_, self.scale_)
+        setattr(self, "datas_", Xs)
+
+        return Xs
+
+    def predict(self, Xn):
+        """
+        Standardize new data on previously estimated location and scale.
+        Number of columns needs to match.
+        """
+
+        Xn = _check_input(Xn)
+        Xns = scale_data(Xn, self.col_loc_, self.col_sca_)
+        setattr(self, "datans_", Xns)
+
+        return Xns
+
+    def fit_transform(self, X):
+        """
+        Estimate center and scale for training data and scale these data
+        """
+
+        self.fit(X)
+        self.transform(X)
+
+        return self.datas_
+
+    def inverse_transform(self, Xs=None):
+        """
+        Transform scaled data back to their original scale
+        """
+
+        check_is_fitted(self, ["center_", "scale_"])
+        if Xs is not None:
+            Xs = _check_input(Xs)
+        else:
+            Xs = self.datas_
+
+        return np.multiply(Xs, self.scale_) + self.center_
+
+
+# For backwards compatibility
+robcent = VersatileScaler
+
+
+def versatile_scale(X, center="l1median", scale="mad", trimming=0):
+    """
+    Wrapper to scale based on present robcent implementation that uses
+    `fit` instead of `transform`
+    """
+
+    rc = VersatileScaler(center=center, scale=scale, trimming=trimming)
+    return rc.fit_transform(X)
+
+
+class Wrapper(_BaseComposition, TransformerMixin, BaseEstimator):
+    """
+    Wrapper Perform robustness inducing 'wrapping' transformation using
+    optimal plugins and parameters from the literature
+
+    Parameters
+    ----------
+
+
+    Attributes
+    ----------
+    Arguments for methods:
+        -   `X`: array-like, n x p, the data.
+
+    Reference
+    ---------
+    Jakob Raymaekers & Peter J. Rousseeuw (2021), Fast Robust Correlation for
+    High-Dimensional Data, Technometrics, 63:2, 184-198.
+
+    """
+
+    def __init__(self):
+        """
+        Initialize values. Check if correct options provided.
+        """
+
+        self.center = "median"
+        self.scale = "mad"
+        self.trimming = 0
+
+    def fit(self, X):
+        """
+        Estimate location and scale, store these in the class object.
+        Trimming fraction can be provided as keyword argument.
+        """
+
+        X = _check_input(X)
+
+        _check_trimming(self.trimming)
+
+        if type(self.center) is str:
+            center = eval(self.center)
+        else:
+            center = self.center
+
+        if type(self.scale) is str:
+            scale = eval(self.scale)
+        else:
+            scale = self.scale
+
+        n = X.shape
+        if len(n) > 1:
+            p = n[1]
+        else:
+            p = 1
+        n = n[0]
+
+        if self.center == "None":
+            m = np.repeat(0, p)
+        else:
+            m = center(X, trimming=self.trimming)
+
+        # Keeping col_loc_ for older version compatibility
+        setattr(self, "col_loc_", m)
+        # sklearn standard
+        setattr(self, "center_", m)
+
+        if self.scale == "None":
+            s = np.repeat(1, p)
+        else:
+            s = scale(X, trimming=self.trimming)
+
+        # Keeping col_sca_ for older version compatibility
+        setattr(self, "col_sca_", s)
+        # sklearn standard
+        setattr(self, "scale_", s)
+
+    def transform(self, X):
+        """
+        Project data points to their wrapped counterparts
+        """
+
+        X = _check_input(X)
+        check_is_fitted(self, ["center_", "scale_"])
+
+        Xw = wrap(X, self.center_, self.scale_)
+        setattr(self, "dataw_", Xw)
+
+        return Xw
+
+    def predict(self, Xn):
+        """
+        Wrap new data using previously estimated location and scale.
+        Number of columns needs to match.
+        """
+
+        Xn = _check_input(Xn)
+        Xnw = wrap(Xn, self.col_loc_, self.col_sca_)
+        setattr(self, "datanw_", Xnw)
+
+        return Xnw
+
+    def fit_transform(self, X):
+        """
+        Estimate center and scale for training data wrap these data
+        """
+
+        self.fit(X)
+        self.transform(X)
+
+        return self.dataw_

twoblock-0.0.1/src/twoblock/test_twoblock.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Aug 7 18:17:46 2020
+
+@author: Sven Serneels
+"""
+
+import unittest
+from .twoblock import twoblock
+import pandas as ps
+import numpy as np
+from sklearn.metrics import r2_score
+
+
+class TestTwoBlock(unittest.TestCase):
+    """Test  methods in the twoblock class"""
+
+    @classmethod
+    def setUpClass(cls):
+        print("...setupClass")
+
+    @classmethod
+    def tearDownClass(cls):
+        print("...teardownClass")
+
+    @classmethod
+    def setUp(self):
+        self.Yt = ps.read_csv("./data/cookie_lab_train.csv", index_col=0).T
+        self.Xt = ps.read_csv("./data/cookie_nir_train.csv", index_col=0).T
+        self.Yv = ps.read_csv("./data/cookie_lab_test.csv", index_col=0).T
+        self.Xv = ps.read_csv("./data/cookie_nir_test.csv", index_col=0).T
+        self.p = self.Xt.shape[1]
+        self.q = self.Yt.shape[1]
+
+    @classmethod
+    def tearDown(self):
+        del self.Xt
+        del self.Yt
+        del self.Xv
+        del self.Yv
+        del self.p
+        del self.q
+
+    def test_assert(self):
+
+        tb = twoblock(n_components_x=7, n_components_y=200, scale="None")
+        self.assertRaises(AssertionError, tb.fit, self.Xt, self.Yt)
+
+        tb = twoblock(n_components_x=700, n_components_y=2, scale="None")
+        self.assertRaises(AssertionError, tb.fit, self.Xt, self.Yt)
+
+    def test_fit(self):
+        """Tests fit function"""
+
+        tb = twoblock(n_components_x=7, n_components_y=2, scale="None")
+        tb.fit(self.Xt, self.Yt)
+
+        self.assertEqual(tb.coef_.shape, (self.p, self.q))  # coefficients
+
+        ypttb = tb.predict(self.Xv)
+
+        self.assertEqual(
+            ypttb.shape,
+            self.Yv.shape,
+        )  # predictions
+
+        r2tbt = [
+            r2_score(self.Yv.iloc[:, i], ypttb[:, i]) for i in range(self.q)
+        ]
+
+        self.assertGreaterEqual(r2tbt, [0.8 for i in range(self.q)])
+
+
+if __name__ == "__main__":
+    unittest.main()

twoblock-0.0.1/src/twoblock/twoblock.py

@@ -0,0 +1,262 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug 6 16:39:57 2024
+
+@author: SERNEELS
+"""
+
+import numpy as np
+from sklearn.base import (
+    RegressorMixin,
+    BaseEstimator,
+    TransformerMixin,
+    MultiOutputMixin,
+)
+from sklearn.utils.metaestimators import _BaseComposition
+import copy
+import pandas as ps
+from .utils import _check_input, _predict_check_input
+from .robcent import VersatileScaler
+
+# Draft version
+
+
+class twoblock(
+    _BaseComposition,
+    BaseEstimator,
+    TransformerMixin,
+    RegressorMixin,
+    MultiOutputMixin,
+):
+    """
+    TWOBLOCK Two-Block Simultaneous Dimension Reduction of Multivariate X and Y
+    data blocks
+
+    Parameters
+    -----------
+
+    n_components_x : int, min 1. Note that if applied on data,
+        n_components_x shall take a value <= min(x_data.shape)
+
+    n_components_y : int, min 1. Note that if applied on data,
+        n_components_x shall take a value <= min(x_data.shape)
+        If unspecified, set to equal n_components_x
+
+    verbose: Boolean (def true)
+                to print intermediate set of columns retained
+
+    centre : str,
+                type of centring (`'mean'` [recommended], `'median'` or `'l1median'`),
+
+    scale : str,
+             type of scaling ('std','mad' or 'None')
+
+    copy : (def True): boolean,
+             whether to copy data into twoblock object.
+
+
+    Attributes
+    ------------
+    Attributes always provided:
+
+        -  `x_weights_`: X block PLS weighting vectors (usually denoted W)
+        -  `y_weights_`: Y block PLS weighting vectors (usually denoted V)
+        -  `x_loadings_`: X block PLS loading vectors (usually denoted P)
+        -  `y_loadings_`: Y block PLS loading vectors (usually denoted Q)
+        -  `x_scores_`: X block PLS score vectors (usually denoted T)
+        -  `y_scores_`: Y block PLS score vectors (usually denoted U)
+        -  `coef_`: vector of regression coefficients
+        -  `intercept_`: intercept
+        -  `coef_scaled_`: vector of scaled regression coeeficients (when scaling option used)
+        -  `intercept_scaled_`: scaled intercept
+        -  `residuals_`: vector of regression residuals
+        -  `fitted_`: fitted response
+        -  `x_loc_`: X block location estimate
+        -  `y_loc_`: y location estimate
+        -  `x_sca_`: X block scale estimate
+        -  `y_sca_`: y scale estimate
+        -  `centring_`: scaling object used internally (type: `VersatileScaler`)
+
+
+    Reference
+    ---------
+    Cook, R. Dennis, Liliana Forzani, and Lan Liu.
+    "Partial least squares for simultaneous reduction of response and predictor
+    vectors in regression." Journal of Multivariate Analysis 196 (2023): 105163.
+
+    """
+
+    def __init__(
+        self,
+        n_components_x=1,
+        n_components_y=None,
+        verbose=True,
+        centre="mean",
+        scale="None",
+        copy=True,
+    ):
+        self.n_components_x = n_components_x
+        self.n_components_y = n_components_y
+        self.verbose = verbose
+        self.centre = centre
+        self.scale = scale
+        self.copy = copy
+
+    def fit(self, X, Y):
+        """
+        Fit a Twoblock model.
+
+        Parameters
+        ------------
+
+            X : numpy array or Pandas data frame
+                Predictor data.
+
+            Y : numpy array or Pandas data frame
+                Response data
+
+        Returns
+        -------
+        twoblock class object containing the estimated parameters.
+
+        """
+
+        if type(X) == ps.core.frame.DataFrame:
+            X = X.to_numpy()
+        (n, p) = X.shape
+        if type(Y) in [ps.core.frame.DataFrame, ps.core.series.Series]:
+            Y = Y.to_numpy()
+        X = _check_input(X)
+        Y = _check_input(Y)
+        ny, q = Y.shape
+        if ny != n:
+            raise (ValueError("Number of cases in X and Y needs to agree"))
+
+        Y = Y.astype("float64")
+
+        if self.n_components_y is None:
+            self.n_components_y = self.n_components_x
+
+        assert self.n_components_x <= min(
+            np.linalg.matrix_rank(np.matmul(X.T, X)), n - 1
+        ), "Number of components cannot exceed covariance rank or number of cases"
+
+        assert self.n_components_y <= min(
+            np.linalg.matrix_rank(np.matmul(Y.T, Y)), n - 1
+        ), "Number of components cannot exceed covariance rank or number of cases"
+
+        if self.copy:
+            X0 = copy.deepcopy(X)
+            Y0 = copy.deepcopy(Y)
+        else:
+            X0 = X
+            Y0 = Y
+        if self.copy:
+            self.X = X0
+            self.Y = Y0
+        X0 = X0.astype("float64")
+        centring = VersatileScaler(
+            center=self.centre, scale=self.scale, trimming=0
+        )
+        X0 = centring.fit_transform(X0).astype("float64")
+        mX = centring.col_loc_
+        sX = centring.col_sca_
+        Y0 = centring.fit_transform(Y0).astype("float64")
+        my = centring.col_loc_
+        sy = centring.col_sca_
+
+        self.x_scores_ = np.empty((n, self.n_components_x), float)
+        self.y_scores_ = np.empty((n, self.n_components_y), float)
+        self.x_weights_ = np.empty((p, self.n_components_x), float)
+        self.y_weights_ = np.empty((q, self.n_components_y), float)
+        self.x_loadings_ = np.empty((p, self.n_components_x), float)
+        self.y_loadings_ = np.empty((q, self.n_components_y), float)
+
+        Xh = copy.deepcopy(X0)
+        Yh = copy.deepcopy(Y0)
+
+        for i in range(self.n_components_x):
+
+            sXY = np.dot(Xh.T, Y0) / n
+            u, _, _ = np.linalg.svd(sXY)
+            x_weights = u[:, 0].reshape((p,))
+            x_scores = np.dot(Xh, x_weights)
+            x_loadings = np.dot(Xh.T, x_scores) / np.dot(x_scores, x_scores)
+
+            Xh -= np.outer(x_scores, x_loadings)
+
+            self.x_weights_[:, i] = x_weights
+            self.x_scores_[:, i] = x_scores
+            self.x_loadings_[:, i] = x_loadings
+
+        for i in range(self.n_components_y):
+
+            sYX = np.dot(Yh.T, X0) / n
+
+            v, _, _ = np.linalg.svd(sYX)
+            y_weights = v[:, 0].reshape((q,))
+            y_scores = np.dot(Yh, y_weights)
+            y_loadings = np.dot(Yh.T, y_scores) / np.dot(y_scores, y_scores)
+
+            Yh -= np.outer(y_scores, y_loadings)
+
+            self.y_weights_[:, i] = y_weights
+            self.y_scores_[:, i] = y_scores
+            self.y_loadings_[:, i] = y_loadings
+
+        wtx = np.dot(X0, self.x_weights_)
+        wti = np.linalg.inv(np.dot(wtx.T, wtx))
+        swg = np.dot(wtx.T, np.dot(Y0, self.y_weights_))
+        self.coef_scaled_ = np.matmul(
+            np.matmul(self.x_weights_, wti), np.dot(swg, self.y_weights_.T)
+        )
+
+        if self.centre == "None" and self.scale == "None":
+            B_rescaled = self.coef_scaled_
+        else:
+            # sklearn has this line wrong
+            B_rescaled = np.multiply(
+                np.outer(sy, np.divide(1, sX)).T, self.coef_scaled_
+            )
+
+        Yp_rescaled = np.matmul(X, B_rescaled)
+        if self.centre == "None":
+            intercept = 0
+        elif self.centre == "mean":
+            intercept = np.mean(Y - Yp_rescaled, axis=0)
+        else:
+            intercept = np.median(Y - Yp_rescaled, axis=0)
+
+        Yfit = Yp_rescaled + intercept
+        R = Y - Yfit
+
+        setattr(self, "coef_", B_rescaled)
+        setattr(self, "intercept_", intercept)
+        setattr(self, "fitted_", Yfit)
+        setattr(self, "residuals_", R)
+        setattr(self, "x_loc_", mX)
+        setattr(self, "y_loc_", my)
+        setattr(self, "x_sca_", sX)
+        setattr(self, "y_sca_", sy)
+        setattr(self, "centring_", centring)
+        return self
+
+    def predict(self, Xn):
+        """
+        Predict cases.
+
+        Parameters
+        ------------
+
+            Xn : numpy array or data frame
+                Input data.
+
+        """
+        n, p, Xn = _predict_check_input(Xn)
+        if p != self.X.shape[1]:
+            raise (
+                ValueError(
+                    "New data must have same number of columns as the ones the model has been trained with"
+                )
+            )
+        return np.matmul(Xn, self.coef_) + self.intercept_

twoblock-0.0.1/src/twoblock/utils.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 13 16:08:22 2020
+
+@author: sven
+"""
+
+import pandas as ps
+import numpy as np
+
+
+def convert_X_input(X):
+
+    if type(X) == ps.core.frame.DataFrame:
+        X = X.to_numpy().astype("float64")
+    return X
+
+
+def convert_y_input(y):
+
+    if type(y) in [ps.core.frame.DataFrame, ps.core.series.Series]:
+        y = y.to_numpy().T.astype("float64")
+    return y
+
+
+def const_xscale(beta, *args):
+    X = args[0]
+    h = args[1]
+    i = args[2]
+    j = args[3]
+    beta = np.reshape(beta, (-1, h), order="F")
+    covx = np.cov(X, rowvar=False)
+    ans = np.matmul(np.matmul(beta.T, covx), beta) - np.identity(h)
+    return ans[i, j]
+
+
+def const_zscale(beta, *args):
+    X = args[0]
+    h = args[1]
+    i = args[2]
+    j = args[3]
+    beta = np.reshape(beta, (-1, h), order="F")
+    covx = np.identity(X.shape[1])
+    ans = np.matmul(np.matmul(beta.T, covx), beta) - np.identity(h)
+    return ans[i, j]
+
+
+def _predict_check_input(Xn):
+    if type(Xn) == ps.core.series.Series:
+        Xn = Xn.to_numpy()
+    if Xn.ndim == 1:
+        Xn = Xn.reshape((1, -1))
+    if type(Xn) == ps.core.frame.DataFrame:
+        Xn = Xn.to_numpy()
+    n, p = Xn.shape
+    return (n, p, Xn)
+
+
+def _check_input(X):
+
+    if type(X) in (np.matrix, ps.core.frame.DataFrame, ps.core.series.Series):
+        X = np.array(X)
+
+    if X.dtype == np.dtype("O"):
+        X = X.astype("float64")
+
+    if X.ndim == 1:
+        X = X.reshape((1, -1))
+
+    n, p = X.shape
+
+    if n == 1:
+        if p >= 2:
+            X = X.reshape((-1, 1))
+    return X

twoblock-0.0.1/src/twoblock.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: twoblock
+Version: 0.0.1
+Summary: A Scikit-Learn Compatible Library for Simultaneous Two-Block Sufficient Dimension Reduction Methods
+Home-page: https://github.com/SvenSerneels/twoblock
+Author: Sven Serneels
+Author-email: svenserneels@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: scipy>=1.8.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: pandas>=1.4.0
+
+# twoblock
+Two-block simultaneous dimension reduction 
+
+A scikitlearn compatible implementation of simultaneous two-block dimension reduction as proposed in [1]. 
+
+References
+----------
+[1] Cook, R. Dennis, Liliana Forzani, and Lan Liu.
+    "Partial least squares for simultaneous reduction of response and predictor
+    vectors in regression." Journal of Multivariate Analysis 196 (2023): 105163.

twoblock-0.0.1/src/twoblock.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+src/twoblock/__init__.py
+src/twoblock/_preproc_utilities.py
+src/twoblock/robcent.py
+src/twoblock/test_twoblock.py
+src/twoblock/twoblock.py
+src/twoblock/utils.py
+src/twoblock.egg-info/PKG-INFO
+src/twoblock.egg-info/SOURCES.txt
+src/twoblock.egg-info/dependency_links.txt
+src/twoblock.egg-info/requires.txt
+src/twoblock.egg-info/top_level.txt

twoblock-0.0.1/src/twoblock.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

twoblock-0.0.1/src/twoblock.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.22.0
+scipy>=1.8.0
+scikit-learn>=1.3.0
+pandas>=1.4.0

twoblock-0.0.1/src/twoblock.egg-info/top_level.txt

@@ -0,0 +1 @@
+twoblock