Minor reorganizing and typos

Author: rvasav26

examples/pcovc/KPCovC_Comparison.py

@@ -105,7 +105,7 @@
     t_train = model.fit_transform(X_train_scaled, y_train)
     t_test = model.transform(X_test_scaled)
 
-    ax.scatter(t_test[:, 0], t_test[:, 1], alpha=alpha_d, cmap=cm_bright, c=y_test)
+    ax.scatter(t_test[:, 0], t_test[:, 1], alpha=alpha_p, cmap=cm_bright, c=y_test)
     ax.scatter(t_train[:, 0], t_train[:, 1], cmap=cm_bright, c=y_train)
 
     ax.set_title(models[model])
@@ -197,20 +197,16 @@
 models = {
     LogisticRegressionCV(random_state=random_state): {
         "kernel_params": {"kernel": "rbf", "gamma": 12},
-        "title": "Logistic Regression",
     },
     RidgeClassifierCV(): {
         "kernel_params": {"kernel": "rbf", "gamma": 1},
-        "title": "Ridge Classifier",
         "eps": 0.40,
     },
     LinearSVC(random_state=random_state): {
         "kernel_params": {"kernel": "rbf", "gamma": 15},
-        "title": "Support Vector Classification",
     },
     SGDClassifier(random_state=random_state): {
         "kernel_params": {"kernel": "rbf", "gamma": 15},
-        "title": "SGD Classifier",
         "eps": 10,
     },
 }

src/skmatter/decomposition/_kernel_pcovc.py

@@ -272,7 +272,7 @@ def fit(self, X, Y, W=None):
         check_classification_targets(Y)
         self.classes_ = np.unique(Y)
 
-        super().fit(X)
+        super()._set_fit_params(X)
 
         K = self._get_kernel(X)
 
@@ -314,14 +314,13 @@ def fit(self, X, Y, W=None):
 
             # Check if classifier is fitted; if not, fit with precomputed K
             self.z_classifier_ = check_cl_fit(classifier, K, Y)
-            W = self.z_classifier_.coef_.T.reshape(K.shape[1], -1)
+            W = self.z_classifier_.coef_.T
 
         else:
             # If precomputed, use default classifier to predict Y from T
             classifier = LogisticRegression(max_iter=500)
             if W is None:
                 W = LogisticRegression().fit(K, Y).coef_.T
-                W = W.reshape(K.shape[1], -1)
 
         Z = K @ W
 
@@ -440,7 +439,7 @@ def decision_function(self, X=None, T=None):
             if self.center:
                 K = self.centerer_.transform(K)
 
-            # Or self.classifier_.decision_function(K @ self.pxt_)
+            # Or self.classifier_.decision_function(K @ self.pkt_)
             return K @ self.pkz_ + self.classifier_.intercept_
 
         else:

src/skmatter/decomposition/_kernel_pcovr.py

@@ -242,7 +242,7 @@ def fit(self, X, Y, W=None):
         """
         X, Y = validate_data(self, X, Y, y_numeric=True, multi_output=True)
 
-        super().fit(X)
+        super()._set_fit_params(X)
 
         K = self._get_kernel(X)
 

src/skmatter/decomposition/_kpcov.py

@@ -74,10 +74,13 @@ def _get_kernel(self, X, Y=None):
             X, Y, metric=self.kernel, filter_params=True, n_jobs=self.n_jobs, **params
         )
 
-    def fit(self, X):
-        """Contains the common functionality for the KPCovR and KPCovC fit methods,
-        but leaves the rest of the functionality to the subclass.
-        """
+    @abstractmethod
+    def fit(self, X, Y):
+        """Fit the model with X and Y. Subclasses should implement this method."""
+        pass
+
+    def _set_fit_params(self, X):
+        """Initializes common fit parameters for PCovR and PCovC."""
         self.X_fit_ = X.copy()
 
         if self.n_components is None:

src/skmatter/decomposition/_pcov.py

@@ -48,10 +48,13 @@ def __init__(
         self.random_state = random_state
         self.whiten = whiten
 
-    def fit(self, X):
-        """Contains the common functionality for the PCovR and PCovC fit methods,
-        but leaves the rest of the functionality to the subclass.
-        """
+    @abstractmethod
+    def fit(self, X, Y):
+        """Fit the model with X and Y. Subclasses should implement this method."""
+        pass
+
+    def _set_fit_params(self, X):
+        """Initializes common fit parameters for PCovR and PCovC."""
         # saved for inverse transformations from the latent space,
         # should be zero in the case that the features have been properly centered
         self.mean_ = np.mean(X, axis=0)

src/skmatter/decomposition/_pcovc.py

@@ -97,11 +97,11 @@ class PCovC(LinearClassifierMixin, _BasePCov):
         Must be of range [0.0, infinity).
 
     space: {'feature', 'sample', 'auto'}, default='auto'
-        whether to compute the PCovC in `sample` or `feature` space
-        default=`sample` when :math:`{n_{samples} < n_{features}}` and
+        whether to compute the PCovC in `sample` or `feature` space.
+        Default = `sample` when :math:`{n_{samples} < n_{features}}` and
         `feature` when :math:`{n_{features} < n_{samples}}`
 
-     classifier: `estimator object` or `precomputed`, default=None
+    classifier: `estimator object` or `precomputed`, default=None
         classifier for computing :math:`{\mathbf{Z}}`. The classifier should be
         one of the following:
 
@@ -144,8 +144,8 @@ class PCovC(LinearClassifierMixin, _BasePCov):
         Must be of range [0.0, infinity).
 
     space: {'feature', 'sample', 'auto'}, default='auto'
-        whether to compute the PCovC in `sample` or `feature` space
-        default=`sample` when :math:`{n_{samples} < n_{features}}` and
+        whether to compute the PCovC in `sample` or `feature` space.
+        Default = `sample` when :math:`{n_{samples} < n_{features}}` and
         `feature` when :math:`{n_{features} < n_{samples}}`
 
     n_components_ : int
@@ -262,7 +262,7 @@ def fit(self, X, Y, W=None):
         check_classification_targets(Y)
         self.classes_ = np.unique(Y)
 
-        super().fit(X)
+        super()._set_fit_params(X)
 
         compatible_classifiers = (
             LogisticRegression,
@@ -291,14 +291,13 @@ def fit(self, X, Y, W=None):
                 classifier = self.classifier
 
             self.z_classifier_ = check_cl_fit(classifier, X, Y)
-            W = self.z_classifier_.coef_.T.reshape(X.shape[1], -1)
+            W = self.z_classifier_.coef_.T
 
         else:
             # If precomputed, use default classifier to predict Y from T
             classifier = LogisticRegression()
             if W is None:
                 W = LogisticRegression().fit(X, Y).coef_.T
-                W = W.reshape(X.shape[1], -1)
 
         Z = X @ W
 

src/skmatter/decomposition/_pcovr.py

@@ -88,7 +88,7 @@ class PCovR(RegressorMixin, MultiOutputMixin, _BasePCov):
         range [0.0, infinity).
 
     space: {'feature', 'sample', 'auto'}, default='auto'
-        whether to compute the PCovR in `sample` or `feature` space default=`sample`
+        whether to compute the PCovR in `sample` or `feature` space. Default = `sample`
         when :math:`{n_{samples} < n_{features}}` and `feature` when
         :math:`{n_{features} < n_{samples}}`
 
@@ -126,7 +126,7 @@ class PCovR(RegressorMixin, MultiOutputMixin, _BasePCov):
         Must be of range [0.0, infinity).
 
     space: {'feature', 'sample', 'auto'}, default='auto'
-        whether to compute the PCovR in `sample` or `feature` space default=`sample`
+        whether to compute the PCovR in `sample` or `feature` space. Default = `sample`
         when :math:`{n_{samples} < n_{features}}` and `feature` when
         :math:`{n_{features} < n_{samples}}`
 
@@ -227,11 +227,12 @@ def fit(self, X, Y, W=None):
             regressed form of the properties, :math:`{\mathbf{\hat{Y}}}`.
 
         W : numpy.ndarray, shape (n_features, n_properties)
-            Regression weights, optional when regressor= `precomputed`. If not
+            Regression weights, optional when regressor = `precomputed`. If not
             passed, it is assumed that `W = np.linalg.lstsq(X, Y, self.tol)[0]`
         """
         X, Y = validate_data(self, X, Y, y_numeric=True, multi_output=True)
-        super().fit(X)
+
+        super()._set_fit_params(X)
 
         compatible_regressors = (LinearRegression, Ridge, RidgeCV)
 
@@ -414,7 +415,7 @@ def score(self, X, y, T=None):
             Negative sum of the loss in reconstructing X from the latent-space
             projection T and the loss in predicting Y from the latent-space projection T
         """
-        X, y = validate_data(self, X, y, reset=False)
+        X, y = validate_data(self, X, y, multi_output=True, reset=False)
 
         if T is None:
             T = self.transform(X)

tests/test_kernel_pcovc.py

@@ -30,12 +30,17 @@ def __init__(self, *args, **kwargs):
         scaler = StandardScaler()
         self.X = scaler.fit_transform(self.X)
 
-        self.model = lambda mixing=0.5, classifier=LogisticRegression(), n_components=4, **kwargs: KernelPCovC(
-            mixing=mixing,
-            classifier=classifier,
-            n_components=n_components,
-            svd_solver=kwargs.pop("svd_solver", "full"),
-            **kwargs,
+        self.model = (
+            lambda mixing=0.5,
+            classifier=LogisticRegression(),
+            n_components=4,
+            **kwargs: KernelPCovC(
+                mixing=mixing,
+                classifier=classifier,
+                n_components=n_components,
+                svd_solver=kwargs.pop("svd_solver", "full"),
+                **kwargs,
+            )
         )
 
     def setUp(self):

tests/test_pcovr.py

@@ -401,7 +401,7 @@ def test_default_ncomponents(self):
 
         self.assertEqual(pcovr.n_components_, min(self.X.shape))
 
-    def test_Y_Shape(self):
+    def test_Y_shape(self):
         pcovr = self.model()
         self.Y = np.vstack(self.Y)
         pcovr.fit(self.X, self.Y)