Added profiling decorator. Improved tests

Author: lucasimi

benchmarks/benchmark.py

@@ -12,6 +12,10 @@
 from tdamapper.core import TrivialClustering
 
 
+def _identity(x):
+    return x
+
+
 def _segment(cardinality, dimension, noise=0.1, start=None, end=None):
     if start is None:
         start = np.zeros(dimension)
@@ -70,7 +74,7 @@ def fit(self, X, y=None):
 def run_gm(X, n, p):
     t0 = time.time()
     pipe = gm.make_mapper_pipeline(
-        filter_func=lambda x: x,
+        filter_func=_identity,
         cover=gm.CubicalCover(n_intervals=n, overlap_frac=p),
         clusterer=TrivialEstimator(),
     )

src/tdamapper/_common.py

@@ -2,6 +2,9 @@
 This module provides common functionalities for internal use.
 """
 
+import cProfile
+import io
+import pstats
 import warnings
 
 import numpy as np
@@ -147,3 +150,22 @@ def clone(obj):
     obj_noargs = type(obj)()
     obj_noargs.set_params(**params)
     return obj_noargs
+
+
+def profile(n_lines=10):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            profiler = cProfile.Profile()
+            profiler.enable()
+            result = func(*args, **kwargs)
+            profiler.disable()
+
+            s = io.StringIO()
+            ps = pstats.Stats(profiler, stream=s).sort_stats("cumulative")
+            ps.print_stats(n_lines)
+            print(s.getvalue())
+            return result
+
+        return wrapper
+
+    return decorator

src/tdamapper/utils/metrics.py

@@ -114,7 +114,11 @@ def minkowski(p):
         return euclidean()
     elif np.isinf(p):
         return chebyshev()
-    return lambda x, y: _metrics.minkowski(p, x, y)
+
+    def dist(x, y):
+        return _metrics.minkowski(p, x, y)
+
+    return dist
 
 
 def cosine():

tests/test_bench_cover.py

@@ -5,6 +5,7 @@
 import numpy as np
 from sklearn.datasets import load_digits
 
+from tdamapper._common import profile
 from tdamapper.utils.metrics import euclidean
 from tdamapper.utils.vptree_flat import VPTree as FVPT
 from tdamapper.utils.vptree_hier import VPTree as HVPT
@@ -21,6 +22,10 @@ def dataset(dim=10, num=1000):
     return [np.random.rand(dim) for _ in range(num)]
 
 
+def dist_proj(x, y):
+    return dist(x[1:], x[1:])
+
+
 class TestVpSettings(unittest.TestCase):
 
     setup_logging()
@@ -39,11 +44,12 @@ def cover(self, vpt, X, r):
     def run_bench(self, X, r, dist, vp, **kwargs):
         XX = np.array([[i] + [xi for xi in x] for i, x in enumerate(X)])
         t0 = time.time()
-        vpt = vp(XX, metric=lambda x, y: dist(x[1:], y[1:]), **kwargs)
+        vpt = vp(XX, metric=dist_proj, **kwargs)
         list(self.cover(vpt, XX, r))
         t1 = time.time()
         self.logger.info(f"time: {t1 - t0}")
 
+    @profile(n_lines=20)
     def test_cover_random(self):
         for r in [1.0, 10.0, 100.0]:
             for n in [100, 1000, 10000]:
@@ -61,6 +67,7 @@ def test_cover_random(self):
                 self.run_bench(X, r, dist, SkBallTree, leaf_radius=r)
                 self.logger.info("")
 
+    @profile(n_lines=20)
     def test_cover_digits(self):
         X, _ = load_digits(return_X_y=True)
         # X = PCA(n_components=3).fit_transform(X)

tests/test_bench_vptree.py

@@ -93,7 +93,11 @@ def _test_knn_search_naive(self, data, name):
         d(np.array([0.0]), np.array([0.0]))  # jit-compile numba
         t0 = time()
         for val in data:
-            data.sort(key=lambda x: d(x, val))
+
+            def _dist_key(x):
+                return d(x, val)
+
+            data.sort(key=_dist_key)
             [x for x in data[: self.k]]
         t1 = time()
         self.logger.info(f"{name}: {t1 - t0}")

tests/test_unit_proximity.py

@@ -10,11 +10,15 @@ def dataset(dim=1, num=10000):
     return [np.random.rand(dim) for _ in range(num)]
 
 
+def absdist(x, y):
+    return abs(x - y)
+
+
 class TestProximity(unittest.TestCase):
 
     def test_ball_proximity(self):
         data = list(range(100))
-        cover = BallCover(radius=10, metric=lambda x, y: abs(x - y))
+        cover = BallCover(radius=10, metric=absdist)
         cover.fit(data)
         for x in data:
             result = cover.search(x)
@@ -23,7 +27,7 @@ def test_ball_proximity(self):
 
     def test_knn_proximity(self):
         data = list(range(100))
-        cover = KNNCover(neighbors=11, metric=lambda x, y: abs(x - y))
+        cover = KNNCover(neighbors=11, metric=absdist)
         cover.fit(data)
         for x in range(5, 94):
             result = cover.search(x)