cvmatrix 2.0.2__tar.gz → 2.1.0__tar.gz

{cvmatrix-2.0.2 → cvmatrix-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cvmatrix
-Version: 2.0.2
+Version: 2.1.0
 Summary: Fast computation of possibly weighted and possibly centered/scaled training set kernel matrices in a cross-validation setting.
 License: Apache-2.0
 Author: Sm00thix

cvmatrix-2.1.0/cvmatrix/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.0"

{cvmatrix-2.0.2 → cvmatrix-2.1.0}/cvmatrix/cvmatrix.py

@@ -11,7 +11,7 @@ E-mail: ole.e@di.ku.dk
 
 from collections import defaultdict
 from collections.abc import Hashable
-from typing import Iterable, Union
+from typing import Iterable, Tuple, Union
 
 import numpy as np
 from numpy import typing as npt
@@ -93,7 +93,7 @@ class CVMatrix:
         self.ddof = ddof
         self.dtype = dtype
         self.copy = copy
-        self.eps = np.finfo(dtype).eps * 100
+        self.resolution = np.finfo(dtype).resolution * 10
         self.X_total = None
         self.Y_total = None
         self.N = None
@@ -149,10 +149,16 @@ class CVMatrix:
         self._init_matrix_products()
         self._init_total_stats()
 
-    def training_XTX(self, fold: Hashable) -> np.ndarray:
+    def training_XTX(
+        self, fold: Hashable
+    ) -> Tuple[
+        np.ndarray, Tuple[Union[None, np.ndarray], Union[None, np.ndarray], None, None]
+    ]:
         """
-        Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
-        corresponding to every sample except those belonging to the given fold.
+        Computes the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
+        corresponding to every sample except those belonging to the given fold. Also
+        computes the row of column-wise weighted means for `X` and the row of
+        column-wise weighted standard deviations for `X`.
 
         Parameters
         ----------
@@ -162,8 +168,13 @@ class CVMatrix:
 
         Returns
         -------
-        Array of shape (K, K)
-            The training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`.
+        Tuple of two elements. The first element is an array of shape (K, K)
+            corresponding to the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`. The second element is
+            a tuple containing the row of column-wise weighted means for `X`, the row
+            of column-wise weighted standard deviations for `X`, and two `None`
+            corresponding to the non-computed rows of column-wise weighted means and
+            standard deviations for `Y`. If a statistic is not computed, it is `None`.
 
         Raises
         ------
@@ -174,20 +185,34 @@ class CVMatrix:
         See Also
         --------
         training_XTY :
-            Returns the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` and weighted
+            statistics.
         training_XTX_XTY :
-            Returns the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` for a given fold. This
-            method is faster than calling `training_XTX` and `training_XTY` separately.
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`,
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`, and weighted
+            statistics for a given fold. This method is faster than calling
+            `training_XTX` and `training_XTY` separately.
         """
         return self._training_matrices(True, False, fold)
 
-    def training_XTY(self, fold: Hashable) -> np.ndarray:
+    def training_XTY(self, fold: Hashable) -> Tuple[
+        np.ndarray,
+        Tuple[
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+        ],
+    ]:
         """
-        Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{Y}`
-        corresponding to every sample except those belonging to the given fold.
+        Computes the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
+        corresponding to every sample except those belonging to the given fold. Also
+        computes the row of column-wise weighted means for `X`, the row of column-wise
+        weighted standard deviations for `X`, the row of column-wise weighted means for
+        `Y`, and the row of column-wise weighted standard deviations for `Y`. If a
+        statistic is not computed, it is `None`.
 
         Parameters
         ----------
@@ -197,8 +222,13 @@ class CVMatrix:
 
         Returns
         -------
-        Array of shape (K, M)
-            The training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
+        Tuple of two elements. The first element is an array of shape (K, M)
+            corresponding to the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`. The second element
+            is a tuple containing the row of column-wise weighted means for `X`, the
+            row of column-wise weighted standard deviations for `X`, the row of
+            column-wise weighted means for `Y`, and the row of column-wise weighted
+            standard deviations for `Y`. If a statistic is not computed, it is `None`.
 
         Raises
         ------
@@ -212,20 +242,36 @@ class CVMatrix:
         See Also
         --------
         training_XTX :
-            Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{X}`
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and weighted statistics
+            for a given fold.
         training_XTX_XTY :
-            Returns the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` for a given fold. This
-            method is faster than calling `training_XTX` and `training_XTY` separately.
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`,
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`, and weighted
+            statistics for a given fold. This method is faster than calling
+            `training_XTX` and `training_XTY` separately.
         """
         return self._training_matrices(False, True, fold)
 
-    def training_XTX_XTY(self, fold: Hashable) -> tuple[np.ndarray, np.ndarray]:
+    def training_XTX_XTY(self, fold: Hashable) -> Tuple[
+        Tuple[np.ndarray, np.ndarray],
+        Tuple[
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+        ],
+    ]:
         """
-        Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
+        Computes the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
         and :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` corresponding to every
-        sample except those belonging to the given fold.
+        sample except those belonging to the given fold. Also computes the row of
+        column-wise weighted means for `X`, the row of column-wise weighted standard
+        deviations for `X`, the row of column-wise weighted means for `Y`, and the row
+        of column-wise weighted standard deviations for `Y`. If a statistic is not
+        computed, it is `None`.
+
 
         Parameters
         ----------
@@ -236,9 +282,14 @@ class CVMatrix:
 
         Returns
         -------
-        tuple of arrays of shapes (K, K) and (K, M)
-            The training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
+        Tuple of two tuples. The first tuple contains arrays of shapes (K, K) and
+            (K, M). These are the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`. The second tuple
+            contains the row of column-wise weighted means for `X`, the row of
+            column-wise weighted standard deviations for `X`, the row of column-wise
+            weighted means for `Y`, and the row of column-wise weighted standard
+            deviations for `Y`. If a statistic is not computed, it is `None`.
 
         Raises
         ------
@@ -252,121 +303,204 @@ class CVMatrix:
         See Also
         --------
         training_XTX :
-            Returns the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and weighted
+            statistics.
         training_XTY :
-            Returns the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
+            Computes the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` and weighted
+            statistics.
         """
         return self._training_matrices(True, True, fold)
 
-    def _training_matrices(
-        self, return_XTX: bool, return_XTY: bool, fold: Hashable
-    ) -> Union[np.ndarray, tuple[np.ndarray, np.ndarray]]:
+    def training_statistics(self, fold: Hashable) -> Tuple[
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+    ]:
         """
-        Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
-        and/or :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` corresponding to
-        every sample except those belonging to the given fold.
+        Computes the row of column-wise weighted means and standard deviations for `X`
+        and `Y` corresponding to every sample except those belonging to the given fold.
+        The statistics that can be computed depend on the arguments provided in the
+        constructor: `X` mean can be computed if `center_X` or `scale_X`, or `center_Y`
+        is `True`. `X` standard deviation can be computed if `scale_X` is True. `Y`
+        mean can be computed if `center_X ,`center_Y` or `scale_Y` is `True`, and `Y`
+        is provided. `Y` standard deviation can be computed if `scale_Y` is `True` and
+        `Y` is provided.
 
         Parameters
         ----------
-        return_XTX : bool
-            Whether to return the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`.
-
         fold : Hashable
-            The fold for which to return the corresponding training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
-
-        return_XTY : bool, optional, default=False
-            Whether to return the training set
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
+            The fold for which to return the corresponding training statistics.
 
         Returns
         -------
-        Array of shape (K, K) or (K, M) or tuple of arrays of shapes (K, K) and (K, M)
-            The training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and/or
-            training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
+        Tuple of four elements of Union[None, np.ndarray]
+            A tuple containing the row of column-wise weighted means for `X`, the row
+            of column-wise weighted standard deviations for `X`, the row of column-wise
+            weighted means for `Y`, and the row of column-wise weighted standard
+            deviations for `Y`. If a statistic is not computed, it is `None`.
 
         Raises
         ------
-        ValueError
-            If both `return_XTX` and `return_XTY` are `False` or if `return_XTY` is
-            `True` and `Y` is `None`.
-
         ValueError
             If `fold` was not provided as a cross-validation split in the
             `folds` parameter of the constructor.
         """
-        if not return_XTX and not return_XTY:
+        val_indices = self._get_val_indices(fold)
+        X_val, X_val_unweighted, Y_val, Y_val_unweighted = self._get_val_matrices(
+            val_indices=val_indices, return_XTY=self.Y_total is not None
+        )
+        return self._compute_training_stats(
+            val_indices=val_indices,
+            X_val=X_val,
+            X_val_unweighted=X_val_unweighted,
+            Y_val=Y_val,
+            Y_val_unweighted=Y_val_unweighted,
+            return_X_mean=self.center_X or self.scale_X,
+            return_X_std=self.scale_X,
+            return_Y_mean=(self.center_Y or self.scale_Y) and self.Y_total is not None,
+            return_Y_std=self.scale_Y and self.Y_total is not None,
+        )[
+            :-1
+        ]  # Exclude the sum of training weights from the return tuple
+
+    def _get_sum_w_train_and_num_nonzero_w_train(
+        self, val_indices: npt.NDArray[np.int_]
+    ) -> Tuple[float, float]:
+        """
+        Returns a tuple containing the sum of weights in the training set and the number
+        of non-zero weights in the training set. If `w_total` is `None`, it returns the
+        size of the training set as both the sum of weights and the number of
+        non-zero weights.
+
+        Returns
+        -------
+        Tuple of floats
+            The sum of weights in the training set and the number of non-zero weights in
+            the training set.
+
+        Raises
+        ------
+        ValueError
+            If the number of non-zero weights in the training set is zero, which would
+            make it impossible to compute either of training set means or standard
+            deviations.
+        """
+        if self.w_total is None:
+            sum_w_val = np.asarray(val_indices.size, dtype=self.dtype)
+            sum_w_train = self.sum_w_total - sum_w_val
+            return (sum_w_train, sum_w_train)
+        w_val = self.w_total[val_indices]
+        sum_w_val = np.sum(w_val)
+        sum_w_train = self.sum_w_total - sum_w_val
+        num_nonzero_w_val = np.count_nonzero(w_val)
+        num_nonzero_w_train = np.asarray(
+            self.num_nonzero_w_total - num_nonzero_w_val, dtype=self.dtype
+        )
+        if num_nonzero_w_train == 0:
             raise ValueError(
-                "At least one of `return_XTX` and `return_XTY` must be True."
+                "The number of non-zero weights in the training set must be "
+                "greater than zero."
             )
-        if return_XTY and self.Y_total is None:
-            raise ValueError("Response variables `Y` are not provided.")
-        X_train_mean = None
-        Y_train_mean = None
-        X_train_std = None
-        Y_train_std = None
-        sum_w_train = None
-        try:
-            val_indices = self.folds_dict[fold]
-        except KeyError as e:
-            raise ValueError(f"Fold {fold} not found.") from e
-        X_val = self.Xw_total[val_indices]
-        if self.w_total is None:
-            X_val_unweighted = X_val
-        else:
-            X_val_unweighted = self.X_total[val_indices]
-        if return_XTY:
-            if self.w_total is None or not (
-                self.center_X or self.center_Y or self.scale_Y
-            ):
-                Y_val = self.Y_total[val_indices]
-                Y_val_unweighted = Y_val
-            else:
-                Y_val = self.Yw_total[val_indices]
-                Y_val_unweighted = self.Y_total[val_indices]
+        return sum_w_train, num_nonzero_w_train
+
+    def _compute_training_stats(
+        self,
+        val_indices: npt.NDArray[np.int_],
+        X_val: Union[None, np.ndarray],
+        X_val_unweighted: Union[None, np.ndarray],
+        Y_val: Union[None, np.ndarray],
+        Y_val_unweighted: Union[None, np.ndarray],
+        return_X_mean: bool,
+        return_X_std: bool,
+        return_Y_mean: bool,
+        return_Y_std: bool,
+    ) -> Tuple[
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+        Union[None, float],
+    ]:
+        """
+        Computes the training set statistics for the given fold. The statistics include
+        the row of column-wise weighted means and standard deviations for `X` and `Y`.
+
+        Parameters
+        ----------
+        val_indices : Array of shape (N_val,)
+            The indices of the validation set samples for the given fold.
+
+        X_val : None or Array of shape (N_val, K)
+            The validation set of weighted predictor variables. If `None`, no
+            statistics for `X` are computed. Required if `return_X_mean` or
+            `return_X_std` is `True`.
+
+        X_val_unweighted : None or Array of shape (N_val, K)
+            The validation set of unweighted predictor variables. Required if
+            `return_X_std` is `True`.
+
+        Y_val : None or Array of shape (N_val, M)
+            The validation set of weighted response variables. If `None`, no statistics
+            for `Y` are computed. Required if `return_Y_mean` or `return_Y_std` is
+            `True`.
+
+        Y_val_unweighted : None or Array of shape (N_val, M)
+            The validation set of unweighted response variables. Required if
+            `return_Y_std` is `True`.
+
+        return_X_mean : bool
+            Whether to compute the row of column-wise weighted means for `X`.
+
+        return_X_std : bool
+            Whether to compute the row of column-wise weighted standard deviations for
+            `X`.
+
+        return_Y_mean : bool
+            Whether to compute the row of column-wise weighted means for `Y`.
+
+        return_Y_std : bool
+            Whether to compute the row of column-wise weighted standard deviations for
+            `Y`.
+
+        Returns
+        -------
+        Tuple of Union[None, np.ndarray]
+            A tuple containing the row of column-wise weighted means for `X`, the row
+            of column-wise weighted standard deviations for `X`, the row of column-wise
+            weighted means for `Y`, the row of column-wise weighted standard deviations
+            for `Y`, and the sum of training weights. If a statistic is not computed,
+            it is `None`.
+        """
         if (
-            self.center_X
-            or self.scale_X
-            or (return_XTY and (self.center_Y or self.scale_Y))
+            not return_X_mean
+            and not return_X_std
+            and not return_Y_mean
+            and not return_Y_std
         ):
-            if self.w_total is None:
-                sum_w_val = np.asarray(val_indices.size, dtype=self.dtype)
-                sum_w_train = self.sum_w_total - sum_w_val
-                num_nonzero_w_train = sum_w_train
-            else:
-                w_val = self.w_total[val_indices]
-                sum_w_val = np.sum(w_val)
-                sum_w_train = self.sum_w_total - sum_w_val
-                num_nonzero_w_val = np.count_nonzero(w_val)
-                num_nonzero_w_train = np.asarray(
-                    self.num_nonzero_w_total - num_nonzero_w_val, dtype=self.dtype
-                )
-                if num_nonzero_w_train == 0:
-                    raise ValueError(
-                        "The number of non-zero weights in the training set must be "
-                        "greater than zero."
-                    )
-        if self.center_X or self.scale_X or (return_XTY and self.center_Y):
+            return None, None, None, None, None
+        sum_w_train, num_nonzero_w_train = (
+            self._get_sum_w_train_and_num_nonzero_w_train(val_indices)
+        )
+        if return_X_mean or return_X_std:
             sum_X_val = np.sum(X_val, axis=0, keepdims=True)
             X_train_mean = self._compute_training_mat_mean(
                 sum_X_val,
                 self.sum_X_total,
                 sum_w_train,
             )
-        if return_XTY and (self.center_X or self.center_Y or self.scale_Y):
+        if return_Y_mean or return_Y_std:
             sum_Y_val = np.sum(Y_val, axis=0, keepdims=True)
             Y_train_mean = self._compute_training_mat_mean(
                 sum_Y_val,
                 self.sum_Y_total,
                 sum_w_train,
             )
-        if self.scale_X or (self.scale_Y and return_XTY):
+        if return_X_std or return_Y_std:
             divisor = self._compute_std_divisor(sum_w_train, num_nonzero_w_train)
-        if self.scale_X:
+        if return_X_std:
             X_train_std = self._compute_training_mat_std(
                 sum_X_val,
                 X_val,
@@ -377,7 +511,7 @@ class CVMatrix:
                 sum_w_train,
                 divisor,
             )
-        if self.scale_Y and return_XTY:
+        if return_Y_std:
             Y_train_std = self._compute_training_mat_std(
                 sum_Y_val,
                 Y_val,
@@ -388,7 +522,135 @@ class CVMatrix:
                 sum_w_train,
                 divisor,
             )
+        return (
+            X_train_mean if return_X_mean else None,
+            X_train_std if return_X_std else None,
+            Y_train_mean if return_Y_mean else None,
+            Y_train_std if return_Y_std else None,
+            sum_w_train,
+        )
+
+    def _training_matrices(
+        self, return_XTX: bool, return_XTY: bool, fold: Hashable
+    ) -> Tuple[
+        Union[np.ndarray, Tuple[np.ndarray, np.ndarray]],
+        Tuple[
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+            Union[None, np.ndarray],
+        ],
+    ]:
+        """
+        Returns the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
+        and/or :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` corresponding to
+        every sample except those belonging to the given fold.
+
+        Parameters
+        ----------
+        return_XTX : bool
+            Whether to return the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`.
+
+        fold : Hashable
+            The fold for which to return the corresponding training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
+
+        return_XTY : bool, optional, default=False
+            Whether to return the training set
+            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
+
+        Returns
+        -------
+        Tuple of two elements. The first element is an array of shape (K, K) or (K, M)
+            or a tuple of arrays of shapes (K, K) and (K, M). These are the training
+            set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and/or
+            training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`. The
+            second element is a tuple containing the row of column-wise weighted means
+            for `X`, the row of column-wise weighted standard deviations for `X`, the
+            row of column-wise weighted means for `Y`, and the row of column-wise
+            weighted standard deviations for `Y`. If a statistic is not computed, it is
+            `None`.
+
+        Raises
+        ------
+        ValueError
+            If both `return_XTX` and `return_XTY` are `False` or if `return_XTY` is
+            `True` and `Y` is `None`.
+
+        ValueError
+            If `fold` was not provided as a cross-validation split in the
+            `folds` parameter of the constructor.
+        """
+        if not return_XTX and not return_XTY:
+            raise ValueError(
+                "At least one of `return_XTX` and `return_XTY` must be True."
+            )
+        if return_XTY and self.Y_total is None:
+            raise ValueError("Response variables `Y` are not provided.")
+        val_indices = self._get_val_indices(fold)
+        X_val, X_val_unweighted, Y_val, Y_val_unweighted = self._get_val_matrices(
+            val_indices=val_indices, return_XTY=return_XTY
+        )
+        X_train_mean, X_train_std, Y_train_mean, Y_train_std, sum_w_train = (
+            self._compute_training_stats(
+                val_indices=val_indices,
+                X_val=(
+                    X_val
+                    if self.center_X or self.scale_X or (return_XTY and self.center_Y)
+                    else None
+                ),
+                X_val_unweighted=X_val_unweighted if self.scale_X else None,
+                Y_val=(
+                    Y_val
+                    if return_XTY and (self.center_X or self.center_Y or self.scale_Y)
+                    else None
+                ),
+                Y_val_unweighted=(
+                    Y_val_unweighted if return_XTY and self.scale_Y else None
+                ),
+                return_X_mean=self.center_X or (return_XTY and self.center_Y),
+                return_Y_mean=return_XTY and (self.center_X or self.center_Y),
+                return_X_std=self.scale_X,
+                return_Y_std=return_XTY and self.scale_Y,
+            )
+        )
+        stats_tuple = (
+            X_train_mean,
+            X_train_std,
+            Y_train_mean,
+            Y_train_std,
+        )
         if return_XTX and return_XTY:
+            return (
+                (
+                    self._training_kernel_matrix(
+                        self.XTX_total,
+                        X_val,
+                        X_val_unweighted,
+                        X_train_mean,
+                        X_train_mean,
+                        X_train_std,
+                        X_train_std,
+                        sum_w_train,
+                        center=self.center_X,
+                    ),
+                    self._training_kernel_matrix(
+                        self.XTY_total,
+                        X_val,
+                        Y_val_unweighted,
+                        X_train_mean,
+                        Y_train_mean,
+                        X_train_std,
+                        Y_train_std,
+                        sum_w_train,
+                        center=self.center_X or self.center_Y,
+                    ),
+                ),
+                stats_tuple,
+            )
+        if return_XTX:
             return (
                 self._training_kernel_matrix(
                     self.XTX_total,
@@ -401,42 +663,87 @@ class CVMatrix:
                     sum_w_train,
                     center=self.center_X,
                 ),
-                self._training_kernel_matrix(
-                    self.XTY_total,
-                    X_val,
-                    Y_val_unweighted,
-                    X_train_mean,
-                    Y_train_mean,
-                    X_train_std,
-                    Y_train_std,
-                    sum_w_train,
-                    center=self.center_X or self.center_Y,
-                ),
+                stats_tuple,
             )
-        if return_XTX:
-            return self._training_kernel_matrix(
-                self.XTX_total,
+        return (
+            self._training_kernel_matrix(
+                self.XTY_total,
                 X_val,
-                X_val_unweighted,
-                X_train_mean,
+                Y_val_unweighted,
                 X_train_mean,
+                Y_train_mean,
                 X_train_std,
-                X_train_std,
+                Y_train_std,
                 sum_w_train,
-                center=self.center_X,
-            )
-        return self._training_kernel_matrix(
-            self.XTY_total,
-            X_val,
-            Y_val_unweighted,
-            X_train_mean,
-            Y_train_mean,
-            X_train_std,
-            Y_train_std,
-            sum_w_train,
-            center=self.center_X or self.center_Y,
+                center=self.center_X or self.center_Y,
+            ),
+            stats_tuple,
         )
 
+    def _get_val_indices(self, fold: Hashable) -> npt.NDArray[np.int_]:
+        """
+        Returns the indices of the validation set samples for a given fold.
+        Parameters
+        ----------
+        fold : Hashable
+            The fold for which to return the validation set indices.
+        Returns
+        -------
+        Array of shape (N_val,)
+            The indices of the validation set samples for the given fold.
+        """
+        try:
+            val_indices = self.folds_dict[fold]
+        except KeyError as e:
+            raise ValueError(f"Fold {fold} not found.") from e
+        return val_indices
+
+    def _get_val_matrices(
+        self, val_indices: npt.NDArray[np.int_], return_XTY: bool
+    ) -> Tuple[
+        np.ndarray,
+        np.ndarray,
+        np.ndarray,
+        Union[None, np.ndarray],
+        Union[None, np.ndarray],
+    ]:
+        """
+        Returns the validation set matrices for a given fold.
+        Parameters
+        ----------
+        val_indices : Array of shape (N_val,)
+            The indices of the validation set samples for the given fold.
+        return_XTY : bool
+            Whether to return the validation set of response variables `Y`. If `False`,
+            the returned `Y_val` and `Y_val_unweighted` will be `None`.
+        Returns
+        -------
+        Tuple of arrays of shapes (N_val, K), (N_val, K), (N_val, M), and (N_val, M)
+            The validation set of predictor variables `X`, the validation set of
+            unweighted predictor variables `X_unweighted`, the validation set of
+            response variables `Y`, and the validation set of unweighted response
+            variables `Y_unweighted`. If `return_XTY` is `False`, `Y` and
+            `Y_unweighted` will be `None`.
+        """
+        X_val = self.Xw_total[val_indices]
+        if self.w_total is None:
+            X_val_unweighted = X_val
+        else:
+            X_val_unweighted = self.X_total[val_indices]
+        if return_XTY:
+            if self.w_total is None or not (
+                self.center_X or self.center_Y or self.scale_Y
+            ):
+                Y_val = self.Y_total[val_indices]
+                Y_val_unweighted = Y_val
+            else:
+                Y_val = self.Yw_total[val_indices]
+                Y_val_unweighted = self.Y_total[val_indices]
+        else:
+            Y_val = None
+            Y_val_unweighted = None
+        return X_val, X_val_unweighted, Y_val, Y_val_unweighted
+
     def _training_kernel_matrix(
         self,
         total_kernel_mat: np.ndarray,
@@ -455,8 +762,8 @@ class CVMatrix:
         Parameters
         ----------
         total_kernel_mat : Array of shape (N, K) or (N, M)
-            The total kernel matrix :math:`\mathbf{X}^{\mathbf{T}}\mathbf{X}` or
-            :math:`\mathbf{X}^{\mathbf{T}}\mathbf{Y}`.
+            The total kernel matrix :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
+            or :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
 
         X_val : Array of shape (N_val, K)
             The validation set of predictor variables.
@@ -619,7 +926,7 @@ class CVMatrix:
         ) / divisor
         mat_train_var[mat_train_var < 0] = 0
         mat_train_std = np.sqrt(mat_train_var)
-        mat_train_std[np.abs(mat_train_std) <= self.eps] = 1
+        mat_train_std[np.abs(mat_train_std) <= self.resolution] = 1
         return mat_train_std
 
     def _init_mat(self, mat: np.ndarray) -> np.ndarray:

{cvmatrix-2.0.2 → cvmatrix-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cvmatrix"
-version = "2.0.2"
+version = "2.1.0"
 description = "Fast computation of possibly weighted and possibly centered/scaled training set kernel matrices in a cross-validation setting."
 authors = ["Sm00thix <oleemail@icloud.com>"]
 maintainers = ["Sm00thix <oleemail@icloud.com>"]

cvmatrix-2.0.2/cvmatrix/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.0.2"