Merge pull request #145 from lucasimi/develop

Develop

Author: lucasimi

.github/workflows/bench.yml

@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out repository code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10' 
       - name: Install dependencies

.github/workflows/publish.yml

@@ -17,7 +17,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10' 
 

.github/workflows/test.yml

@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out repository code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10' 
       - name: Install dependencies
@@ -24,6 +24,6 @@ jobs:
           coverage run --source=src -m unittest discover -s tests -p 'test_unit_*.py'
           coverage report -m
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2020 Luca Simi
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -32,7 +32,7 @@ read
 This library contains an implementation of Mapper, where the construction 
 of open covers is based on *vp-trees* for improved performance and scalability.
 The details about this methodology are contained in
-[our preprint](https://doi.org/10.5281/zenodo.10659652).
+[our preprint](https://doi.org/10.5281/zenodo.10659651).
 
 | Step 1 | Step 2 | Step 3 | Step 4 |
 | ------ | ------ | ------ | ------ |

benchmarks/benchmark.py

@@ -0,0 +1,180 @@
+import time
+
+import pandas as pd
+import numpy as np
+
+from sklearn.decomposition import PCA
+from sklearn.datasets import fetch_openml, load_digits
+from sklearn.base import ClusterMixin
+
+from tdamapper.clustering import TrivialClustering
+
+import tdamapper as tm
+import gtda.mapper as gm
+import kmapper as km
+
+
+def _segment(cardinality, dimension, noise=0.1, start=None, end=None):
+    if start is None:
+        start = np.zeros(dimension)
+    if end is None:
+        end = np.ones(dimension)
+    coefficients = np.random.rand(cardinality, 1)
+    points = start + coefficients * (end - start)
+    noise = np.random.normal(0, noise, size=(cardinality, dimension))
+    return points + noise
+
+
+def _load_openml(name):
+    XX, _ = fetch_openml(name=name, return_X_y=True)
+    return XX.to_numpy()
+
+
+def line(k):
+    return _segment(100000, k, 0.01)
+
+
+def digits(k):
+    X_digits, _ = load_digits(return_X_y=True)
+    return PCA(k).fit_transform(X_digits)
+
+
+def mnist(k):
+    X = _load_openml('mnist_784')
+    return PCA(k).fit_transform(X)
+
+
+def cifar10(k):
+    X = _load_openml('CIFAR_10')
+    return PCA(k).fit_transform(X)
+
+
+def fashion_mnist(k):
+    X = _load_openml('Fashion-MNIST')
+    return PCA(k).fit_transform(X)
+
+
+# wrapper class to supply trivial clustering to giotto-tda
+class TrivialEstimator(ClusterMixin):
+
+    def get_params(self, deep=True):
+        return {}
+
+    def set_params(self, **parmeters):
+        return self
+
+    def fit(self, X, y=None):
+        clust = TrivialClustering()
+        self.labels_ = clust.fit(X, y).labels_
+        return self
+
+
+def run_gm(X, n, p):
+    t0 = time.time()
+    pipe = gm.make_mapper_pipeline(
+        filter_func=lambda x: x,
+        cover=gm.CubicalCover(
+            n_intervals=n,
+            overlap_frac=p),
+        clusterer=TrivialEstimator(),
+    )
+    mapper_graph = pipe.fit_transform(X)
+    t1 = time.time()
+    return t1 - t0
+
+
+def run_tm(X, n, p):
+    t0 = time.time()
+    mapper_graph = tm.core.MapperAlgorithm(
+        cover=tm.cover.CubicalCover(
+            n_intervals=n,
+            overlap_frac=p,
+            #leaf_capacity=1000,
+            #leaf_radius=1.0 / (2.0 - 2.0 * p),
+            #kind='hierarchical',
+            #pivoting='random',
+        ),
+        clustering=TrivialEstimator(),
+    ).fit_transform(X, X)
+    t1 = time.time()
+    return t1 - t0
+
+
+def run_km(X, n, p):
+    t0 = time.time()
+    mapper = km.KeplerMapper(verbose=0)
+    graph = mapper.map(
+        lens=X,
+        X=X,
+        cover=km.Cover(
+            n_cubes=n,
+            perc_overlap=p
+        ),
+        clusterer=TrivialEstimator(),
+    )
+    t1 = time.time()
+    return t1 - t0
+
+
+def run_bench(benches, datasets, dimensions, overlaps, intervals):
+    df_bench = pd.DataFrame({
+        'bench': [],
+        'dataset': [],
+        'p': [],
+        'n': [],
+        'k': [],
+        'time': [],
+    })
+    launch_time = int(time.time())
+    for bench_name, bench in benches:
+        for dataset_name, dataset in datasets:
+            for k in dimensions:
+                X = dataset(k)
+                for p in overlaps:
+                    for n in intervals:
+                        t = bench(X, n, p)
+                        df_delta = pd.DataFrame({
+                            'bench': bench_name,
+                            'dataset': dataset_name,
+                            'p': p,
+                            'n': n,
+                            'k': k,
+                            'time': t,
+                          }, index=[0])
+                        print(df_delta)
+                        df_bench = pd.concat([df_bench, df_delta], ignore_index=True)
+                        df_bench.to_csv(f'./benchmark_{launch_time}.csv', index=False)
+
+
+if __name__ == '__main__':
+    run_tm(line(1), 1, 0.5) # fist run to jit-compile numba decorated functions
+
+    run_bench(
+        overlaps=[
+            0.125,
+            0.25,
+            0.5
+        ],
+        datasets=[
+            ('line', line),
+            ('digits', digits),
+            ('mnist', mnist),
+            ('cifar10', cifar10),
+            ('fashion_mnist', fashion_mnist),
+        ],
+        intervals=[
+            10,
+        ],
+        dimensions=[
+            1,
+            2,
+            3,
+            4,
+            5,
+        ],
+        benches = [
+            ('tda-mapper', run_tm),
+            ('kepler-mapper', run_km),
+            ('giotto-tda', run_gm),
+        ],
+    )