Merge pull request #163 from lucasimi/feature/add-standard-cover

Feature/add standard cover

Author: lucasimi

src/tdamapper/_common.py

@@ -21,12 +21,12 @@ def warn_user(msg):
 
 class EstimatorMixin:
 
-    def _is_sparse(self, X):
+    def __is_sparse(self, X):
         # simple alternative use scipy.sparse.issparse
         return hasattr(X, 'toarray')
 
     def _validate_X_y(self, X, y):
-        if self._is_sparse(X):
+        if self.__is_sparse(X):
             raise ValueError('Sparse data not supported.')
 
         X = np.asarray(X)
@@ -58,11 +58,8 @@ def _validate_X_y(self, X, y):
 
         return X, y
 
-    def fit(self, X, y=None):
-        X, y = self._validate_X_y(X, y)
-        res = super().fit(X, y)
+    def _set_n_features_in(self, X):
         self.n_features_in_ = X.shape[1]
-        return res
 
 
 class ParamsMixin:
@@ -71,7 +68,7 @@ class ParamsMixin:
     scikit-learn `get_params` and `set_params`.
     """
 
-    def _is_param_internal(self, k):
+    def __is_param_internal(self, k):
         return k.startswith('_') or k.endswith('_')
 
     def get_params(self, deep=True):
@@ -82,14 +79,14 @@ def get_params(self, deep=True):
         :type deep: bool, optional.
         """
         params = self.__dict__.items()
-        return {k: v for k, v in params if not self._is_param_internal(k)}
+        return {k: v for k, v in params if not self.__is_param_internal(k)}
 
     def set_params(self, **params):
         """
         Set public parameters. Only updates attributes that already exist.
         """
         for k, v in params.items():
-            if hasattr(self, k) and not self._is_param_internal(k):
+            if hasattr(self, k) and not self.__is_param_internal(k):
                 setattr(self, k, v)
         return self
 

src/tdamapper/clustering.py

@@ -38,34 +38,7 @@ def __init__(self, clustering=None, verbose=True):
         super().__init__(clustering, verbose)
 
 
-class _MapperClustering:
-
-    def __init__(self, cover=None, clustering=None, n_jobs=1):
-        self.cover = cover
-        self.clustering = clustering
-        self.n_jobs = n_jobs
-
-    def fit(self, X, y=None):
-        cover = TrivialCover() if self.cover is None \
-            else self.cover
-        cover = clone(cover)
-        clustering = TrivialClustering() if self.clustering is None \
-            else self.clustering
-        clustering = clone(clustering)
-        n_jobs = self.n_jobs
-        y = X if y is None else y
-        itm_lbls = mapper_connected_components(
-            X,
-            y,
-            cover,
-            clustering,
-            n_jobs=n_jobs,
-        )
-        self.labels_ = [itm_lbls[i] for i, _ in enumerate(X)]
-        return self
-
-
-class MapperClustering(EstimatorMixin, _MapperClustering, ParamsMixin):
+class MapperClustering(EstimatorMixin, ParamsMixin):
     """
     A clustering algorithm based on the Mapper graph.
 
@@ -92,4 +65,27 @@ class MapperClustering(EstimatorMixin, _MapperClustering, ParamsMixin):
     """
 
     def __init__(self, cover=None, clustering=None, n_jobs=1):
-        super().__init__(cover=cover, clustering=clustering, n_jobs=n_jobs)
+        self.cover = cover
+        self.clustering = clustering
+        self.n_jobs = n_jobs
+
+    def fit(self, X, y=None):
+        X, y = self._validate_X_y(X, y)
+        cover = TrivialCover() if self.cover is None \
+            else self.cover
+        cover = clone(cover)
+        clustering = TrivialClustering() if self.clustering is None \
+            else self.clustering
+        clustering = clone(clustering)
+        n_jobs = self.n_jobs
+        y = X if y is None else y
+        itm_lbls = mapper_connected_components(
+            X,
+            y,
+            cover,
+            clustering,
+            n_jobs=n_jobs,
+        )
+        self.labels_ = [itm_lbls[i] for i, _ in enumerate(X)]
+        self._set_n_features_in(X)
+        return self

src/tdamapper/core.py

@@ -364,53 +364,7 @@ def apply(self, X):
         yield list(range(0, len(X)))
 
 
-class _MapperAlgorithm:
-
-    def __init__(
-        self,
-        cover=None,
-        clustering=None,
-        failsafe=True,
-        verbose=True,
-        n_jobs=1,
-    ):
-        self.cover = cover
-        self.clustering = clustering
-        self.failsafe = failsafe
-        self.verbose = verbose
-        self.n_jobs = n_jobs
-
-    def fit(self, X, y=None):
-        self.__cover = TrivialCover() if self.cover is None \
-            else self.cover
-        self.__clustering = TrivialClustering() if self.clustering is None \
-            else self.clustering
-        self.__verbose = self.verbose
-        self.__failsafe = self.failsafe
-        if self.__failsafe:
-            self.__clustering = FailSafeClustering(
-                clustering=self.__clustering,
-                verbose=self.__verbose,
-            )
-        self.__cover = clone(self.__cover)
-        self.__clustering = clone(self.__clustering)
-        self.__n_jobs = self.n_jobs
-        y = X if y is None else y
-        self.graph_ = mapper_graph(
-            X,
-            y,
-            self.__cover,
-            self.__clustering,
-            n_jobs=self.__n_jobs,
-        )
-        return self
-
-    def fit_transform(self, X, y):
-        self.fit(X, y)
-        return self.graph_
-
-
-class MapperAlgorithm(EstimatorMixin, _MapperAlgorithm, ParamsMixin):
+class MapperAlgorithm(EstimatorMixin, ParamsMixin):
     """
     A class for creating and analyzing Mapper graphs.
 
@@ -458,13 +412,11 @@ def __init__(
         verbose=True,
         n_jobs=1,
     ):
-        super().__init__(
-            cover=cover,
-            clustering=clustering,
-            failsafe=failsafe,
-            verbose=verbose,
-            n_jobs=n_jobs,
-        )
+        self.cover = cover
+        self.clustering = clustering
+        self.failsafe = failsafe
+        self.verbose = verbose
+        self.n_jobs = n_jobs
 
     def fit(self, X, y=None):
         """
@@ -479,7 +431,31 @@ def fit(self, X, y=None):
         :type y: array-like of shape (n, k) or list-like of length n
         :return: The object itself.
         """
-        return super().fit(X, y)
+        X, y = self._validate_X_y(X, y)
+        self.__cover = TrivialCover() if self.cover is None \
+            else self.cover
+        self.__clustering = TrivialClustering() if self.clustering is None \
+            else self.clustering
+        self.__verbose = self.verbose
+        self.__failsafe = self.failsafe
+        if self.__failsafe:
+            self.__clustering = FailSafeClustering(
+                clustering=self.__clustering,
+                verbose=self.__verbose,
+            )
+        self.__cover = clone(self.__cover)
+        self.__clustering = clone(self.__clustering)
+        self.__n_jobs = self.n_jobs
+        y = X if y is None else y
+        self.graph_ = mapper_graph(
+            X,
+            y,
+            self.__cover,
+            self.__clustering,
+            n_jobs=self.__n_jobs,
+        )
+        self._set_n_features_in(X)
+        return self
 
     def fit_transform(self, X, y):
         """
@@ -495,7 +471,8 @@ def fit_transform(self, X, y):
         :return: The Mapper graph.
         :rtype: :class:`networkx.Graph`
         """
-        return super().fit_transform(X, y)
+        self.fit(X, y)
+        return self.graph_
 
 
 class FailSafeClustering(ParamsMixin):