Investigating PCovCSPaceTest errors

Author: rvasav26

examples/pcovc/PCovC-BreastCancerDataset.ipynb

@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -190,7 +190,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -210,16 +210,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x11a62f610>"
+       "<matplotlib.legend.Legend at 0x110136e40>"
       ]
      },
-     "execution_count": 46,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -258,16 +258,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x11a6d3390>"
+       "<matplotlib.collections.PathCollection at 0x1103cead0>"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -302,7 +302,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {

examples/pcovc/test_notebook.ipynb

@@ -16,9 +16,59 @@
 from sklearn.preprocessing import LabelBinarizer
 from sklearn.utils._array_api import get_namespace, indexing_dtype
 from sklearn.svm import SVC
+from sklearn.base import clone
+from copy import deepcopy
 
-from ..preprocessing import KernelNormalizer
-from ..utils import check_krr_fit, pcovr_kernel
+from skmatter.preprocessing import KernelNormalizer
+from skmatter.utils import check_krr_fit, pcovr_kernel
+
+def check_cl_fit(classifier, X, y):
+    r"""
+    Checks that a (linear) classifier is fitted, and if not,
+    fits it with the provided data
+    :param regressor: sklearn-style classifier
+    :type classifier: object
+    :param X: feature matrix with which to fit the classifier
+        if it is not already fitted
+    :type X: array
+    :param y: target values with which to fit the classifier
+        if it is not already fitted
+    :type y: array
+    """
+    try:
+        check_is_fitted(classifier)
+        fitted_classifier = deepcopy(classifier)
+
+        # Check compatibility with X
+        fitted_classifier._validate_data(X, y, reset=False, multi_output=True)
+
+        # Check compatibility with y
+
+        # changed from if fitted_classifier.coef_.ndim != y.ndim:
+        # dimension of classifier coefficients is always 2, hence we don't need to check 
+        # for match with Y
+        if fitted_classifier.coef_.shape[1] != X.shape[1]:
+            raise ValueError(
+                "The classifier coefficients have a shape incompatible "
+                "with the supplied feature space. "
+                "The coefficients have shape %d and the features "
+                "have shape %d" % (fitted_classifier.coef_.shape, X.shape)
+            )
+        # LogisticRegression does not support multioutput, but RidgeClassifier does
+        elif y.ndim == 2:
+            if fitted_classifier.coef_.shape[0] != y.shape[1]:
+                raise ValueError(
+                    "The classifier coefficients have a shape incompatible "
+                    "with the supplied target space. "
+                    "The coefficients have shape %r and the targets "
+                    "have shape %r" % (fitted_classifier.coef_.shape, y.shape)
+                )
+
+    except NotFittedError:
+        fitted_classifier = clone(classifier)
+        fitted_classifier.fit(X, y)
+
+    return fitted_classifier
 
 
 class KernelPCovC(_BasePCA, LinearModel):
@@ -432,7 +482,8 @@ def fit(self, X, y, W=None):
 
         self._fit(K, Z, W) #gives us T, Pkt, self.pt__
 
-        
+        self.classifier_ = check_cl_fit(classifier, K @ self.pkt, y) #Ptz as weights
+
         '''
         we now need Z = TPtz
 
@@ -477,6 +528,7 @@ def decision_function(self, X=None, T=None):
             return T @ self.ptz_
 
     #is there a reason why this predict function is different than the one in PCovc?
+    #it can be the same
     def predict(self, X=None, T=None):
         """Predicts class values from X or T."""
 

src/skmatter/decomposition/_kernel_pcovc.py

@@ -14,8 +14,8 @@
 from sklearn.utils.extmath import randomized_svd, stable_cumsum, svd_flip
 from sklearn.utils.validation import check_is_fitted, check_X_y
 
-from ..preprocessing import KernelNormalizer
-from ..utils import check_krr_fit, pcovr_kernel
+from skmatter.preprocessing import KernelNormalizer
+from skmatter.utils import check_krr_fit, pcovr_kernel
 
 
 class KernelPCovR(_BasePCA, LinearModel):

src/skmatter/decomposition/_kernel_pcovr.py

@@ -422,13 +422,24 @@ def fit(self, X, y, W=None):
 
         # instead of using linear regression solution, refit with the classifier
         # and steal weights to get ptz
-        #this is failing because self.classifier is never changed from None if None is passed as classifier
-        #change self.classifier to classifier and see what happens. if classifier is precomputed, there might be more errors so be careful.
+        # this is failing because self.classifier is never changed from None if None is passed as classifier
+        # change self.classifier to classifier and see what happens. if classifier is precomputed, there might be more errors so be careful.
         # if classifier is precomputed, I don't think we need to check if the classifier is fit or not?
 
         #most tests are passing if we change self.classifier to classifier (just like how PCovR has it for self.regressor = ...)
-        self.classifier_ = check_cl_fit(self.classifier, X @ self.pxt_, y=y) #Has Ptz as weights 
-        #(self.classifier_.)
+        #print(self.pxt_.shape)
+        #print((X @ self.pxt_).shape)
+        
+        
+
+        #cases:
+        #1. if classifier has been fit with X and Y already, we dont need to perform a check_cl_fit
+        #2. if classifier has not been fit with X or Y, we can perform check_cl_fit but don't need to
+        #3. if classifier has been fit with T and Y, we need to perform check_cl_fit (doesn't make sense actually, why would we fit with T and y)
+
+        # old: self.classifier_ = check_cl_fit(self.classifier, X @ self.pxt_, y=y) #Has Ptz as weights 
+        self.classifier_ = check_cl_fit(classifier, X @ self.pxt_, y=y) #Has Ptz as weights 
+
         if isinstance(self.classifier_, MultiOutputClassifier):
             self.ptz_ = np.hstack(
                 [est_.coef_.T for est_ in self.classifier_.estimators_]

src/skmatter/decomposition/_pcovc.py

@@ -15,7 +15,7 @@
 from sklearn.utils.extmath import randomized_svd, stable_cumsum, svd_flip
 from sklearn.utils.validation import check_is_fitted, check_X_y
 
-from ..utils import check_lr_fit, pcovr_covariance, pcovr_kernel
+from skmatter.utils import check_lr_fit, pcovr_covariance, pcovr_kernel
 
 
 class PCovR(_BasePCA, LinearModel):

src/skmatter/decomposition/_pcovr.py

@@ -18,6 +18,26 @@
 print(X.shape)
 print(Y.shape)
 
+pcovc = PCovC(mixing=0.0, classifier=LogisticRegression(), n_components=2, space="feature")
+
+#pcovc.classifier.fit(X, Y)
+#print(pcovc.classifier.coef_.shape)
+pcovc.fit(X, Y)
+T = pcovc.transform(X)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 # classifier = LogisticRegression()
 # classifier.fit(X, Y)
 
@@ -27,59 +47,39 @@
 # print(pcovc.classifier.coef_.ndim)
 
 # pcovc.fit(X, Y)
-X = [[1, 2, 3, 4, 5],
-     [2, 3, 4, 5, 6]]
-Y = [[0, 1, 0, 1, 0],
-     [0, 1, 0, 1, 0]]
+# X = [[1, 2, 3, 4, 5],
+#      [2, 3, 4, 5, 6]]
+# Y = [[0, 1, 0, 1, 0],
+#      [0, 1, 0, 1, 0]]
 
-classifier = LogisticRegression()
-classifier.fit(X, Y)
-model = PCovC(classifier=classifier)
+# classifier = LogisticRegression()
+# classifier.fit(X, Y)
+# model = PCovC(classifier=classifier)
 
 #model2 = PCovC(classifier=LogisticRegression())
 #model2.fit(X, Y)
 
 #problem is that coef_.shape (1, n_features=30) is not the same as 
-print(model.classifier.coef_.shape)
-#print(model2.classifier.coef_.ndim)
+# print(model.classifier.coef_.shape)
+# #print(model2.classifier.coef_.ndim)
 
-model.fit(X, Y)
-y_pred = model.predict(X)
-print(accuracy_score(y_pred, Y))
+# model.fit(X, Y)
+# y_pred = model.predict(X)
+# print(accuracy_score(y_pred, Y))
 
-X_new, Y_new = get_dataset2(return_X_y=True)
-print(X_new.shape)
-print(Y_new.shape)
+# X_new, Y_new = get_dataset2(return_X_y=True)
+# print(X_new.shape)
+# print(Y_new.shape)
 
 
 '''
 Problem is this: check_lr_fit and check_cl_fit do different things because the coefficients for Logistic/Linear regression are different.
 So we need to change check_cl_fit
-'''
+
 scaler = StandardScaler()
 X_new = scaler.fit_transform(X_new)
 regressor = LinearRegression()
 
 regressor.fit(X_new, Y_new)
 model2 = PCovR(regressor = regressor)
-print(model2.regressor.coef_)
-
-
-
-
-# model = KernelPCovC(
-#             mixing=0.5,
-#             classifier=SVC(),
-#             n_components=4
-# )
-
-# model2 = KernelPCovR(
-#             mixing=0.5,
-#             regressor=KernelRidge(gamma="scale"),
-#             n_components=4
-# )
-# model3 = SVC()
-# model3.fit(X, Y)
-# print(model3.dual_coef_.shape)
-# # print(model2.gamma, model2.regressor.gamma)
-# # model2.fit(X, Y)
+print(model2.regressor.coef_)'''

src/skmatter/decomposition/playground.py

@@ -40,7 +40,7 @@ def test_against_pca(self):
         pcovc = PCovC(
             mixing=1.0, n_components=2, space="feature", svd_solver="full"
         ).fit(self.X, self.Y)
-        print(pcovc.score(self.X, self.Y))
+        
         pca = PCA(n_components=2, svd_solver="full").fit(self.X)
 
         # tests that the SVD is equivalent
@@ -78,7 +78,7 @@ def test_simple_prediction(self):
         """
         for space in ["feature", "sample", "auto"]:
             with self.subTest(space=space):
-                # failing because check_lr_fit wei
+                print(self.X.shape)
                 pcovc = self.model(mixing=0.0, n_components=2, space=space)
 
                 pcovc.classifier.fit(self.X, self.Y)
@@ -240,6 +240,10 @@ def test_spaces_equivalent(self):
                 #         ))
 
                 #failing for all alpha values
+                # so these are similar (within approximately 0.001), but not exactly the same. 
+                # I think this is because transform and inverse_transform depend on Pxt and Ptx,
+                # which in turn depend on Z, which is a matrix of class likelihoods (so maybe there is some rounding problems)
+
                 self.assertTrue(
                     np.allclose(
                         pcovc_ss.inverse_transform(pcovc_ss.transform(self.X)),
@@ -476,9 +480,9 @@ def test_classifier_modifications(self):
 
         # PCovC classifier doesn't change after fitting
         pcovc.fit(self.X, self.Y)
-        classifier.set_params(alpha=1e-4)
-        self.assertTrue(hasattr(pcovc.classifier, "coef_"))
-        self.assertTrue(classifier.get_params() != pcovc.classifier.get_params())
+        classifier.set_params(random_state=3)
+        self.assertTrue(hasattr(pcovc.classifier_, "coef_"))
+        self.assertTrue(classifier.get_params() != pcovc.classifier_.get_params())
 
     def test_incompatible_classifier(self):
         classifier = GaussianNB()

tests/test_pcovc.py

@@ -231,7 +231,8 @@ def test_spaces_equivalent(self):
                 #             pcovr_ss.pxt_, pcovr_fs.pxt_,
                 #             self.error_tol
                 #         ))
-                # print(" ")        
+                # print(" ")   
+
                 self.assertTrue(
                     np.allclose(
                         pcovr_ss.inverse_transform(pcovr_ss.transform(self.X)),