Merge pull request #181 from lucasimi/develop

Develop

Author: lucasimi

src/tdamapper/_common.py

@@ -81,8 +81,14 @@ class ParamsMixin:
     scikit-learn `get_params` and `set_params`.
     """
 
-    def __is_param_internal(self, k):
-        return k.startswith('_') or k.endswith('_')
+    def __is_param_public(self, k):
+        return (not k.startswith('_')) and (not k.endswith('_'))
+
+    def __split_param(self, k):
+        k_split = k.split('__')
+        outer = k_split[0]
+        inner = '__'.join(k_split[1:])
+        return outer, inner
 
     def get_params(self, deep=True):
         """
@@ -91,20 +97,47 @@ def get_params(self, deep=True):
         :param deep: A flag for returning also nested parameters.
         :type deep: bool, optional.
         """
-        params = self.__dict__.items()
-        return {k: v for k, v in params if not self.__is_param_internal(k)}
+        params = {}
+        for k, v in self.__dict__.items():
+            if self.__is_param_public(k):
+                params[k] = v
+                if hasattr(v, 'get_params') and deep:
+                    for _k, _v in v.get_params().items():
+                        params[f'{k}__{_k}'] = _v
+        return params
 
     def set_params(self, **params):
         """
         Set public parameters. Only updates attributes that already exist.
         """
+        nested_params = []
         for k, v in params.items():
-            if hasattr(self, k) and not self.__is_param_internal(k):
-                setattr(self, k, v)
+            if self.__is_param_public(k):
+                k_outer, k_inner = self.__split_param(k)
+                if not k_inner:
+                    if hasattr(self, k_outer):
+                        setattr(self, k_outer, v)
+                else:
+                    nested_params.append((k_outer, k_inner, v))
+        for k_outer, k_inner, v in nested_params:
+            if hasattr(self, k_outer):
+                k_attr = getattr(self, k_outer)
+                k_attr.set_params(**{k_inner: v})
         return self
 
+    def __repr__(self):
+        obj_noargs = type(self)()
+        args_repr = []
+        for k, v in self.__dict__.items():
+            v_default = getattr(obj_noargs, k)
+            v_default_repr = repr(v_default)
+            v_repr = repr(v)
+            if self.__is_param_public(k) and not v_repr == v_default_repr:
+                args_repr.append(f'{k}={v_repr}')
+        return f"{self.__class__.__name__}({', '.join(args_repr)})"
+
 
-def clone(estimator):
+def clone(obj):
     """
     Clone an estimator, returning a new one, unfitted, having the same public
     parameters.
@@ -114,5 +147,7 @@ def clone(estimator):
     :return: A new estimator with the same parameters.
     :rtype: A scikit-learn compatible estimator
     """
-    params = estimator.get_params(deep=True)
-    return type(estimator)(**params)
+    params = obj.get_params(deep=True)
+    obj_noargs = type(obj)()
+    obj_noargs.set_params(**params)
+    return obj_noargs

src/tdamapper/cover.py

@@ -303,10 +303,14 @@ def fit(self, X):
         else:
             self.__overlap_frac = self.overlap_frac
         self.__n_intervals = self.n_intervals
-        if (self.__overlap_frac <= 0.0) or (self.__overlap_frac > 0.5):
+        if self.__overlap_frac <= 0.0:
+            raise ValueError(
+                'The parameter overlap_frac is expected to be '
+                '> 0.0'
+            )
+        if self.__overlap_frac > 0.5:
             warn_user(
-                'The parameter overlap_frac is expected within range '
-                '(0.0, 0.5]'
+                'The parameter overlap_frac is expected to be <= 0.5'
             )
         self.__min, self.__max, self.__delta = self._get_bounds(X)
         radius = 1.0 / (2.0 - 2.0 * self.__overlap_frac)
@@ -337,16 +341,20 @@ def search(self, x):
         return self.__cover.search(center)
 
     def _get_center(self, x):
-        cell = self.__n_intervals * (x - self.__min) // self.__delta
+        offset = self._offset(x)
         center = self._phi(x)
-        return tuple(cell), center
+        return tuple(offset), center
 
     def _get_overlap_frac(self, dim, overlap_vol_frac):
         beta = math.pow(1.0 - overlap_vol_frac, 1.0 / dim)
         return 1.0 - 1.0 / (2.0 - beta)
 
+    def _offset(self, x):
+        return np.minimum(self.__n_intervals - 1, np.floor(self._gamma_n(x)))
+
     def _phi(self, x):
-        return self._gamma_n_inv(0.5 + np.floor(self._gamma_n(x)))
+        offset = self._offset(x)
+        return self._gamma_n_inv(0.5 + offset)
 
     def _gamma_n(self, x):
         return self.__n_intervals * (x - self.__min) / self.__delta
@@ -512,24 +520,20 @@ def __init__(
         self.leaf_capacity = leaf_capacity
         self.leaf_radius = leaf_radius
         self.pivoting = pivoting
-        if algorithm == 'proximity':
-            self.__cubical_cover = ProximityCubicalCover(
-                n_intervals=n_intervals,
-                overlap_frac=overlap_frac,
-                kind=kind,
-                leaf_capacity=leaf_capacity,
-                leaf_radius=leaf_radius,
-                pivoting=pivoting,
-            )
-        elif algorithm == 'standard':
-            self.__cubical_cover = StandardCubicalCover(
-                n_intervals=n_intervals,
-                overlap_frac=overlap_frac,
-                kind=kind,
-                leaf_capacity=leaf_capacity,
-                leaf_radius=leaf_radius,
-                pivoting=pivoting,
-            )
+
+    def __get_cubical_cover(self):
+        params = dict(
+            n_intervals=self.n_intervals,
+            overlap_frac=self.overlap_frac,
+            kind=self.kind,
+            leaf_capacity=self.leaf_capacity,
+            leaf_radius=self.leaf_radius,
+            pivoting=self.pivoting,
+        )
+        if self.algorithm == 'proximity':
+            return ProximityCubicalCover(**params)
+        elif self.algorithm == 'standard':
+            return StandardCubicalCover(**params)
         else:
             raise ValueError(
                 "The only possible values for algorithm are 'standard' and "
@@ -548,7 +552,9 @@ def fit(self, X):
         :return: The object itself.
         :rtype: self
         """
-        return self.__cubical_cover.fit(X)
+        self.__cubical_cover = self.__get_cubical_cover()
+        self.__cubical_cover.fit(X)
+        return self
 
     def search(self, x):
         """
@@ -576,4 +582,5 @@ def apply(self, X):
         :return: A generator of lists of ids.
         :rtype: generator of lists of ints
         """
+        self.__cubical_cover = self.__get_cubical_cover()
         return self.__cubical_cover.apply(X)

tests/test_unit_core.py

@@ -10,7 +10,7 @@
     mapper_labels,
     TrivialCover,
 )
-from tdamapper.cover import BallCover
+from tdamapper.cover import BallCover, CubicalCover, ProximityCubicalCover, StandardCubicalCover
 from tdamapper.clustering import TrivialClustering
 
 
@@ -80,7 +80,7 @@ def test_ball_large_radius(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def test_two_disconnected_clusters(self):
+    def test_ball_two_disconnected_clusters(self):
         data = [np.array([float(i), 0.0]) for i in range(100)]
         data.extend([np.array([float(i), 500.0]) for i in range(100)])
         data = np.array(data)
@@ -98,7 +98,7 @@ def test_two_disconnected_clusters(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def test_two_connected_clusters(self):
+    def test_ball_two_connected_clusters(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.0, 0.0]),
             np.array([0.0, 0.0]), np.array([1.0, 1.0])]
@@ -116,7 +116,7 @@ def test_two_connected_clusters(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def test_two_connected_clusters_parallel(self):
+    def test_ball_two_connected_clusters_parallel(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.0, 0.0]),
             np.array([0.0, 0.0]), np.array([1.0, 1.0])]
@@ -136,7 +136,39 @@ def test_two_connected_clusters_parallel(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def test_connected_components(self):
+    def test_proximity_cubical_line(self):
+        data = np.array([[float(i)] for i in range(1000)])
+        cover = ProximityCubicalCover(n_intervals=4, overlap_frac=0.5)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        g = mp.fit_transform(data, data)
+        self.assertEqual(4, len(g.nodes))
+
+    def test_standard_cubical_line(self):
+        data = np.array([[float(i)] for i in range(1000)])
+        cover = StandardCubicalCover(n_intervals=4, overlap_frac=0.5)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        g = mp.fit_transform(data, data)
+        self.assertEqual(4, len(g.nodes))
+
+    def test_cubical_line(self):
+        data = np.array([[float(i)] for i in range(1000)])
+        cover = CubicalCover(n_intervals=4, overlap_frac=0.5)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        g = mp.fit_transform(data, data)
+        self.assertEqual(4, len(g.nodes))
+
+    def test_cubical_no_overlap(self):
+        data = np.array([[0.0], [1.0], [2.0]])
+        cover = StandardCubicalCover(n_intervals=2, overlap_frac=0)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        with self.assertRaises(ValueError):
+            mp.fit_transform(data, data)
+
+    def test_mock_connected_components(self):
         data = [0, 1, 2, 3]
 
         class MockCover:
@@ -156,7 +188,7 @@ def apply(self, X):
         self.assertEqual(cc0, ccs[2])
         self.assertEqual(cc0, ccs[3])
 
-    def test_labels(self):
+    def test_mock_labels(self):
         data = [0, 1, 2, 3]
 
         class MockCover:

tests/test_unit_params.py

@@ -0,0 +1,123 @@
+import unittest
+
+from sklearn.cluster import DBSCAN
+
+from tdamapper._common import clone
+from tdamapper.core import MapperAlgorithm
+from tdamapper.cover import (
+    BallCover,
+    KNNCover,
+    CubicalCover
+)
+from tdamapper.clustering import MapperClustering
+
+
+class TestParams(unittest.TestCase):
+
+    def __test_clone(self, obj):
+        obj_repr = repr(obj)
+        obj_cln = clone(obj)
+        cln_repr = repr(obj_cln)
+        self.assertEqual(obj_repr, cln_repr)
+
+    def __test_repr(self, obj):
+        obj_repr = repr(obj)
+        _obj = eval(obj_repr)
+        _obj_repr = repr(_obj)
+        self.assertEqual(obj_repr, _obj_repr)
+
+    def __test_clone_and_repr(self, obj):
+        self.__test_clone(obj)
+        self.__test_repr(obj)
+
+    def test_params_mapper_algorithm(self):
+        est = MapperAlgorithm(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+        )
+        params = est.get_params(deep=False)
+        self.assertEqual(5, len(params))
+        params = est.get_params()
+        self.assertEqual(12, len(params))
+        self.assertEqual(3, params['cover__n_intervals'])
+        self.assertEqual(0.3, params['cover__overlap_frac'])
+        est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
+        params = est.get_params()
+        self.assertEqual(12, len(params))
+        self.assertEqual(2, params['cover__n_intervals'])
+        self.assertEqual(0.2, params['cover__overlap_frac'])
+
+    def test_params_mapper_clustering(self):
+        est = MapperClustering(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+        )
+        params = est.get_params(deep=False)
+        self.assertEqual(3, len(params))
+        params = est.get_params()
+        self.assertEqual(10, len(params))
+        self.assertEqual(3, params['cover__n_intervals'])
+        self.assertEqual(0.3, params['cover__overlap_frac'])
+        est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
+        params = est.get_params()
+        self.assertEqual(10, len(params))
+        self.assertEqual(2, params['cover__n_intervals'])
+        self.assertEqual(0.2, params['cover__overlap_frac'])
+
+    def test_clone_and_repr_ball_cover(self):
+        self.__test_clone_and_repr(BallCover())
+        self.__test_clone_and_repr(BallCover(
+            radius=2.0,
+            metric='test',
+            metric_params={'f': 4},
+            kind='kind_test',
+            leaf_capacity=3.0,
+            leaf_radius=-2.0,
+            pivoting=7,
+        ))
+
+    def test_clone_and_repr_cubical_cover(self):
+        self.__test_clone_and_repr(CubicalCover())
+        self.__test_clone_and_repr(CubicalCover(
+            n_intervals=4,
+            overlap_frac=5,
+            algorithm='algo_test',
+            kind='simple',
+            leaf_radius=5,
+            leaf_capacity=6,
+            pivoting='no'
+        ))
+
+    def test_clone_repr_mapper_algorithm(self):
+        self.__test_clone_and_repr(MapperAlgorithm())
+        self.__test_clone_and_repr(MapperAlgorithm(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+            clustering=DBSCAN(
+                eps='none',
+                min_samples=5.4,
+            ),
+            failsafe=4,
+            n_jobs='foo',
+            verbose=4,
+        ))
+
+    def test_clone_repr_mapper_clustering(self):
+        self.__test_clone_and_repr(MapperClustering())
+        self.__test_clone_and_repr(MapperClustering(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+            clustering=DBSCAN(
+                eps='none',
+                min_samples=5.4,
+            ),
+            n_jobs='foo',
+        ))