More formatting and cleaning

Author: rvasav26

examples/pcovc/KPCovC_Moons.py renamed to examples/pcovc/KPCovC_Comparison.py

@@ -297,10 +297,11 @@ def fit(self, X, Y, W=None):
             else:
                 classifier = self.classifier
 
+            # for convergence warnings
             if hasattr(classifier, "max_iter") and (
                 classifier.max_iter is None or classifier.max_iter < 500
             ):
-                classifier.max_iter = 500  # for convergence warnings
+                classifier.max_iter = 500
 
             # Check if classifier is fitted; if not, fit with precomputed K
             self.z_classifier_ = check_cl_fit(classifier, K, Y)
@@ -318,7 +319,7 @@ def fit(self, X, Y, W=None):
         self._fit(K, Z, W)
 
         self.ptk_ = self.pt__ @ K
-        # ("KPCovc"+str(self.ptk_[:10][1]))
+
         if self.fit_inverse_transform:
             self.ptx_ = self.pt__ @ X
 

src/skmatter/decomposition/_kernel_pcovc.py

@@ -106,10 +106,6 @@ def _fit(self, K, Yhat, W):
         """Fit the model with the computed kernel and approximated properties."""
         K_tilde = pcovr_kernel(mixing=self.mixing, X=K, Y=Yhat, kernel="precomputed")
 
-        # print("KPCovC K: " + str(K[:5, 0]))
-        # print("KPCovC Yhat: " + str(Yhat[:5, 0]))
-        # print("KPCovC K_tilde: " + str(K_tilde[:5, 0]))
-
         if self.fit_svd_solver_ == "full":
             _, S, Vt = self._decompose_full(K_tilde)
         elif self.fit_svd_solver_ in ["arpack", "randomized"]:

src/skmatter/decomposition/_kpcov.py

@@ -133,11 +133,7 @@ def _fit_feature_space(self, X, Y, Yhat, compute_pty_=True):
             self.pty_ = np.linalg.multi_dot([S_sqrt_inv, Vt, iCsqrt, X.T, Y])
 
     def _fit_sample_space(self, X, Y, Yhat, W, compute_pty_=True):
-        # Kt = pcovr_kernel(mixing=self.mixing, X=X, Y=Yhat)
         Kt = pcovr_kernel(mixing=self.mixing, X=X, Y=Yhat)
-        # print("PCovC X: " + str(X[:5, 0]))
-        # print("PCovC Yhat: " + str(Yhat[:5, 0]))
-        # print("PcovC Kt: " + str(Kt[:5, 0]))
 
         if self.fit_svd_solver_ == "full":
             U, S, Vt = self._decompose_full(Kt)
@@ -155,15 +151,13 @@ def _fit_sample_space(self, X, Y, Yhat, W, compute_pty_=True):
         )
 
         P = (self.mixing * X.T) + (1.0 - self.mixing) * W @ Yhat.T
-        # print("PCovC P: " + str(P[:5, 0]))
+
         S_sqrt_inv = np.diagflat([1.0 / np.sqrt(s) if s > self.tol else 0.0 for s in S])
         T = Vt.T @ S_sqrt_inv
 
         self.pxt_ = P @ T
         self.ptx_ = T.T @ X
 
-        # print("PcovC pxt: " + str(self.pxt_[:5, 0]))
-
         if compute_pty_:
             self.pty_ = T.T @ Y
 

src/skmatter/decomposition/_pcov.py

@@ -292,7 +292,6 @@ def fit(self, X, Y, W=None):
 
         Z = X @ W
 
-        # print(f"PCovC Z {Z[:5, 0]}")
         if self.space_ == "feature":
             self._fit_feature_space(X, Y, Z)
         else:
@@ -305,18 +304,13 @@ def fit(self, X, Y, W=None):
         self.ptz_ = self.classifier_.coef_.T
         self.pxz_ = self.pxt_ @ self.ptz_
 
-        # print(f"PCovC ptz: {self.ptz_.shape}")
-        # print(f"PCovC classifier_ coef n_classes: {len(self.classifier_.classes_)}")
-
-        # print(f"PCovC pxz: {self.pxz_.shape}")
         if len(Y.shape) == 1 and type_of_target(Y) == "binary":
             self.pxz_ = self.pxz_.reshape(
                 X.shape[1],
             )
             self.ptz_ = self.ptz_.reshape(
                 self.n_components_,
             )
-        # print(f"PCovC pxz: {self.pxz_.shape}")
 
         self.components_ = self.pxt_.T  # for sklearn compatibility
         return self

src/skmatter/decomposition/_pcovc.py

@@ -111,7 +111,6 @@ def test_reconstruction_errors(self):
             Xr = kpcovc.inverse_transform(kpcovc.transform(self.X))
             error = np.linalg.norm(self.X - Xr) ** 2.0 / np.linalg.norm(self.X) ** 2.0
 
-            print(error)
             with self.subTest(error=error):
                 self.assertFalse(np.isnan(error))
             with self.subTest(error=error, alpha=round(mixing, 4)):
@@ -198,10 +197,10 @@ def test_centerer(self):
 
     def test_prefit_classifier(self):
         # in KPCovC, our classifiers don't compute the kernel for us, hence we only
-        # allow prefit classifiers on K, y
+        # allow prefit classifiers on K and y
         kernel_params = {"kernel": "rbf", "gamma": 0.1, "degree": 3, "coef0": 0}
-
         K = pairwise_kernels(self.X, metric="rbf", filter_params=True, **kernel_params)
+
         classifier = LinearSVC()
         classifier.fit(K, self.Y)
 

tests/test_kernel_pcovc.py

@@ -90,7 +90,6 @@ def test_reconstruction_errors(self):
 
             error = np.linalg.norm(K - t @ t.T) ** 2.0 / np.linalg.norm(K) ** 2.0
             x_error = np.linalg.norm(self.X - x) ** 2.0 / np.linalg.norm(self.X) ** 2.0
-            print(np.linalg.norm(K - t @ t.T) ** 2.0 / np.linalg.norm(K) ** 2.0)
 
             with self.subTest(error=error):
                 self.assertFalse(np.isnan(error))
@@ -254,7 +253,6 @@ def test_incompatible_coef_shape(self):
         kpcovr = self.model(mixing=0.5, regressor=regressor)
 
         # Dimension mismatch
-        print(self.Y.shape, np.zeros(self.Y.shape + (2,)).shape)
         with self.assertRaises(ValueError) as cm:
             kpcovr.fit(self.X, self.Y)
         self.assertEqual(
@@ -366,7 +364,6 @@ def test_linear_matches_pcovr(self):
         t_ref = ref_pcovr.transform(self.X)
         t = kpcovr.transform(self.X)
 
-        print(np.linalg.norm(t_ref - t))
         K = kpcovr._get_kernel(self.X)
 
         k_ref = t_ref @ t_ref.T
@@ -381,8 +378,6 @@ def test_linear_matches_pcovr(self):
             round(ly_ref, rounding),
         )
 
-        print(lk, lk_ref)
-
         self.assertEqual(
             round(lk, rounding),
             round(lk_ref, rounding),

tests/test_kernel_pcovr.py

@@ -479,7 +479,6 @@ def test_precomputed_classification(self):
         pcovc3.fit(self.X, self.Y)
         t3 = pcovc3.transform(self.X)
 
-        print(np.linalg.norm(t1), np.linalg.norm(t2), np.linalg.norm(t3))
         self.assertTrue(np.linalg.norm(t3 - t2) < self.error_tol)
         self.assertTrue(np.linalg.norm(t3 - t1) < self.error_tol)