Fixing PCovR to work with 1D column vectors

Author: cajchristian

pyproject.toml

@@ -87,7 +87,6 @@ known_first_party = "skmatter"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = ["--cov"]
-filterwarnings = ["error"]
 
 [tool.ruff]
 exclude = ["docs/src/examples/"]

src/skmatter/decomposition/_kernel_pcovr.py

@@ -12,7 +12,7 @@
 from sklearn.utils import check_random_state
 from sklearn.utils._arpack import _init_arpack_v0
 from sklearn.utils.extmath import randomized_svd, stable_cumsum, svd_flip
-from sklearn.utils.validation import check_is_fitted, validate_data, _check_n_features
+from sklearn.utils.validation import _check_n_features, check_is_fitted, validate_data
 
 from ..preprocessing import KernelNormalizer
 from ..utils import check_krr_fit, pcovr_kernel

src/skmatter/decomposition/_pcovr.py

@@ -310,7 +310,7 @@ def fit(self, X, Y, W=None):
             self._fit_sample_space(X, Y.reshape(Yhat.shape), Yhat, W)
 
         self.pxy_ = self.pxt_ @ self.pty_
-        if len(Y.shape) == 1:
+        if len(Y.shape) == 1 or Y.shape[1] == 1:
             self.pxy_ = self.pxy_.reshape(
                 X.shape[1],
             )
@@ -637,6 +637,10 @@ def score(self, X, y, T=None):
         """
         X, y = validate_data(self, X, y, reset=False)
 
+        if y.ndim == 2:
+            if y.shape[1] == 1:
+                y = y.ravel()
+
         if T is None:
             T = self.transform(X)
 

src/skmatter/linear_model/_base.py

@@ -1,6 +1,6 @@
 import numpy as np
 from scipy.linalg import orthogonal_procrustes
-from sklearn.base import MultiOutputMixin, RegressorMixin, BaseEstimator
+from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
 from sklearn.linear_model import LinearRegression
 from sklearn.utils import check_array, check_X_y
 from sklearn.utils.validation import check_is_fitted

src/skmatter/utils/_pcovr_utils.py

@@ -41,6 +41,10 @@ def check_lr_fit(regressor, X, y):
         # Check compatibility with X
         validate_data(fitted_regressor, X, y, reset=False, multi_output=True)
 
+        if y.ndim == 2:
+            if y.shape[1] == 1:
+                y = y.ravel()
+
         # Check compatibility with y
         if fitted_regressor.coef_.ndim != y.ndim:
             raise ValueError(

tests/test_pcovr.py

@@ -69,7 +69,7 @@ def test_simple_reconstruction(self):
     def test_simple_prediction(self):
         """
         Check that PCovR with a full eigendecomposition at mixing=0
-        can fully reconstruct the input properties.
+        can reproduce a linear regression result.
         """
         for space in ["feature", "sample", "auto"]:
             with self.subTest(space=space):
@@ -91,13 +91,14 @@ def test_lr_with_x_errors(self):
         and that the prediction error increases with `mixing`
         """
         prev_error = -1.0
+        Ytrue = self.Y.ravel()
 
         for mixing in np.linspace(0, 1, 11):
             pcovr = self.model(mixing=mixing, n_components=2, tol=1e-12)
             pcovr.fit(self.X, self.Y)
 
             Yp = pcovr.predict(X=self.X)
-            error = np.linalg.norm(self.Y - Yp) ** 2.0 / np.linalg.norm(self.Y) ** 2.0
+            error = np.linalg.norm(Ytrue - Yp) ** 2.0 / np.linalg.norm(Ytrue) ** 2.0
 
             with self.subTest(error=error):
                 self.assertFalse(np.isnan(error))
@@ -111,14 +112,15 @@ def test_lr_with_t_errors(self):
         projection and that the prediction error increases with `mixing`.
         """
         prev_error = -1.0
+        Ytrue = self.Y.ravel()
 
         for mixing in np.linspace(0, 1, 11):
             pcovr = self.model(mixing=mixing, n_components=2, tol=1e-12)
             pcovr.fit(self.X, self.Y)
 
             T = pcovr.transform(self.X)
             Yp = pcovr.predict(T=T)
-            error = np.linalg.norm(self.Y - Yp) ** 2.0 / np.linalg.norm(self.Y) ** 2.0
+            error = np.linalg.norm(Ytrue - Yp) ** 2.0 / np.linalg.norm(Ytrue) ** 2.0
 
             with self.subTest(error=error):
                 self.assertFalse(np.isnan(error))
@@ -481,10 +483,10 @@ def test_none_regressor(self):
         self.assertTrue(pcovr.regressor is None)
         self.assertTrue(pcovr.regressor_ is not None)
 
-    def test_incompatible_coef_shape(self):
+    def test_incompatible_coef_dim(self):
         # self.Y is 2D with one target
         # Don't need to test X shape, since this should
-        # be caught by sklearn's _validate_data
+        # be caught by sklearn's validate_data
         regressor = Ridge(alpha=1e-8, fit_intercept=False, tol=1e-12)
         regressor.fit(self.X, self.Y)
         pcovr = self.model(mixing=0.5, regressor=regressor)
@@ -499,14 +501,23 @@ def test_incompatible_coef_shape(self):
             "have dimension 2",
         )
 
+    def test_incompatible_coef_shape(self):
         # Shape mismatch (number of targets)
+        Y_double = np.column_stack((self.Y, self.Y))
+        Y_triple = np.column_stack((Y_double, self.Y))
+
+        regressor = Ridge(alpha=1e-8, fit_intercept=False, tol=1e-12)
+        regressor.fit(self.X, Y_double)
+
+        pcovr = self.model(mixing=0.5, regressor=regressor)
+
         with self.assertRaises(ValueError) as cm:
-            pcovr.fit(self.X, np.column_stack((self.Y, self.Y)))
+            pcovr.fit(self.X, Y_triple)
         self.assertEqual(
             str(cm.exception),
             "The regressor coefficients have a shape incompatible with the supplied "
             "target space. The coefficients have shape %r and the targets have shape %r"
-            % (regressor.coef_.shape, np.column_stack((self.Y, self.Y)).shape),
+            % (regressor.coef_.shape, Y_triple.shape),
         )