Detached Partitioner from CVMatrix and updated documentation. (#9)

Detached the Partitioner from CVMatrix so that the dictionary of integer arrays with validation indices does not need to be pickled when using multiprocessing together with CVMatrix such as in https://github.com/sm00thix/ikpls

Author: sm00thix

README.md

@@ -40,6 +40,7 @@ The `cvmatrix` software package now also features **weigthed matrix produts** $\
 > ```python
 > import numpy as np
 > from cvmatrix.cvmatrix import CVMatrix
+> from cvmatrix.partitioner import Partitioner
 >
 > N = 100  # Number of samples.
 > K = 50  # Number of features.
@@ -55,30 +56,34 @@ The `cvmatrix` software package now also features **weigthed matrix produts** $\
 >
 > # Instantiate CVMatrix
 > cvm = CVMatrix(
->     folds=folds,
 >     center_X=True, # Cemter around the weighted mean of X.
 >     center_Y=True, # Cemter around the weighted mean of Y.
 >     scale_X=True, # Scale by the weighted standard deviation of X.
 >     scale_Y=True, # Scale by the weighted standard deviation of Y.
 > )
-> # Fit on X and Y
+> # Fit on X, Y, and weights
 > cvm.fit(X=X, Y=Y, weights=weights)
+>
+> # Instantiate Partitioner
+> p = Partitioner(folds=folds)
+>
 > # Compute training set XTWX and/or XTWY for each fold
-> for fold in cvm.folds_dict:
+> for fold in p.folds_dict:
+>     val_indices = p.get_validation_indices(fold)
 >     # Get both XTWX, XTWY, and weighted statistics
->     result = cvm.training_XTX_XTY(fold)
+>     result = cvm.training_XTX_XTY(val_indices)
 >     (training_XTWX, training_XTWY) = result[0]
 >     (training_X_mean, training_X_std, training_Y_mean, training_Y_std) = result[1]
 >     
 >     # Get only XTWX and weighted statistics for X.
 >     # Weighted statistics for Y are returned as None as they are not computed when
 >     # only XTWX is requested.
->     result = cvm.training_XTX(fold)
+>     result = cvm.training_XTX(val_indices)
 >     training_XTWX = result[0]
 >     (training_X_mean, training_X_std, training_Y_mean, training_Y_std) = result[1]
 >     
 >     # Get only XTWY and weighted statistics
->     result = cvm.training_XTY(fold)
+>     result = cvm.training_XTY(val_indices)
 >     training_XTWY = result[0]
 >     (training_X_mean, training_X_std, training_Y_mean, training_Y_std) = result[1]
 

benchmarks/benchmark.py

@@ -4,11 +4,11 @@
 compared for different values of P, center_X, center_Y, scale_X, and scale_Y. The
 results are saved to a CSV file for further analysis.
 
-Engstrøm, O.-C. G. (2024):
-https://arxiv.org/abs/2401.13185
+O.-C. G. Engstrøm and M. H. Jensen (2025):
+https://analyticalsciencejournals.onlinelibrary.wiley.com/doi/full/10.1002/cem.70008
 
 Author: Ole-Christian Galbo Engstrøm
-E-mail: ole.e@di.ku.dk
+E-mail: ocge@foss.dk
 """
 
 import os
@@ -28,20 +28,24 @@
 
 from cvmatrix.__init__ import __version__
 from cvmatrix.cvmatrix import CVMatrix
+from cvmatrix.partitioner import Partitioner
 from tests.naive_cvmatrix import NaiveCVMatrix
 
 
 def save_result_to_csv(
-    model, P, N, K, M, center_X, center_Y, scale_X, scale_Y, time, version
+    model, use_weights, P, N, K, M, center_X, center_Y, scale_X, scale_Y, time, version
 ):
     try:
         with open("benchmark_results.csv", "x") as f:
-            f.write("model,P,N,K,M," "center_X,center_Y,scale_X,scale_Y,time,version\n")
+            f.write(
+                "model,weights,P,N,K,M,"
+                "center_X,center_Y,scale_X,scale_Y,time,version\n"
+            )
     except FileExistsError:
         pass
     with open("benchmark_results.csv", "a") as f:
         f.write(
-            f"{model},{P},{N},{K},{M},"
+            f"{model},{use_weights},{P},{N},{K},{M},"
             f"{center_X},{center_Y},{scale_X},{scale_Y},"
             f"{time},{version}\n"
         )
@@ -96,7 +100,6 @@ def execute_algorithm(
 
     # Create the model
     model = model_class(
-        folds=cv_splits,
         center_X=center_X,
         center_Y=center_Y,
         scale_X=scale_X,
@@ -105,12 +108,26 @@ def execute_algorithm(
         copy=True,
     )
 
+    # Create the validation partitioner
+    p = Partitioner(folds=cv_splits)
+
     # Fit the model
     model.fit(X, Y, weights)
 
-    # Compute the training set matrices
-    for fold in model.folds_dict.keys():
-        model.training_XTX_XTY(fold)
+    if isinstance(model, NaiveCVMatrix):
+        # Compute the training set matrices
+        for fold in p.folds_dict:
+            # Get the training indices for the current fold
+            training_indices = np.concatenate(
+                [p.get_validation_indices(f) for f in p.folds_dict if f != fold]
+            )
+            model.training_XTX_XTY(training_indices)
+    else:
+        # Compute the training set matrices
+        for fold in p.folds_dict:
+            # Get the validation indices for the current fold
+            validation_indices = p.get_validation_indices(fold)
+            model.training_XTX_XTY(validation_indices)
 
 
 if __name__ == "__main__":
@@ -122,19 +139,20 @@ def execute_algorithm(
     dtype = np.float64  # Data type
     X = rng.random((N, K), dtype=dtype)  # Random X matrix
     Y = rng.random((N, M), dtype=dtype)  # Random Y matrix
-    # weights = rng.random((N,), dtype=dtype)  # Random weights
-    weights = None
+    weights = rng.random((N,), dtype=dtype)  # Random weights
     cv_splits = np.arange(N)  # We can use mod P for P-fold cross-validation
+    use_weights = [True, False]  # Whether to use weights or not
     center_Xs = [True, False]
     center_Ys = [True, False]
     scale_Xs = [True, False]
     scale_Ys = [True, False]
     Ps = [3, 5, 10, 100, 1000, 10000, 100000]
 
-    for center_X, center_Y, scale_X, scale_Y, P in product(
-        center_Xs, center_Ys, scale_Xs, scale_Ys, Ps
+    for use_w, center_X, center_Y, scale_X, scale_Y, P in product(
+        use_weights, center_Xs, center_Ys, scale_Xs, scale_Ys, Ps
     ):
         print(
+            f"weights={use_w}, "
             f"P={P}, "
             f"center_X={center_X}, center_Y={center_Y}, "
             f"scale_X={scale_X}, scale_Y={scale_Y}, "
@@ -149,13 +167,14 @@ def execute_algorithm(
                 scale_Y=scale_Y,
                 X=X,
                 Y=Y,
-                weights=weights,
+                weights=weights if use_weights else None,
             ),
             number=1,
         )
         print(f"CVMatrix, Time: {time:.2f} seconds")
         save_result_to_csv(
             "CVMatrix",
+            use_w,
             P,
             N,
             K,
@@ -191,6 +210,7 @@ def execute_algorithm(
             print()
             save_result_to_csv(
                 "NaiveCVMatrix",
+                use_w,
                 P,
                 N,
                 K,

cvmatrix/__init__.py

@@ -1 +1 @@
-__version__ = "2.1.1"
+__version__ = "3.0.0"