How to use kmapper - 10 common examples

def test_radius_dist(self):

        test_cases = [
            {"cubes": 1, "range": [0, 4], "overlap": 0.4, "radius": 10.0 / 3},
            {"cubes": 1, "range": [0, 4], "overlap": 0.9, "radius": 20.0},
            {"cubes": 2, "range": [-4, 4], "overlap": 0.5, "radius": 4.0},
            {"cubes": 3, "range": [-4, 4], "overlap": 0.5, "radius": 2.666666666},
            {"cubes": 10, "range": [-4, 4], "overlap": 0.5, "radius": 0.8},
            {"cubes": 10, "range": [-4, 4], "overlap": 1.0, "radius": np.inf},
        ]

        for test_case in test_cases:
            scaler = preprocessing.MinMaxScaler(feature_range=test_case["range"])
            data = scaler.fit_transform(np.arange(20).reshape(10, 2))

            cover = Cover(n_cubes=test_case["cubes"], perc_overlap=test_case["overlap"])
            _ = cover.fit(data)
            assert cover.radius_[0] == pytest.approx(test_case["radius"])

def test_125_replication(self):
        # uniform data:
        data = np.arange(0, 100)
        data = data[:, np.newaxis]
        lens = data

        cov = Cover(10, 0.5)

        # Prefix'ing the data with an ID column
        ids = np.array([x for x in range(lens.shape[0])])
        lens = np.c_[ids, lens]

        bins = cov.fit(lens)

        cube_entries = [cov.transform_single(lens, cube) for cube in bins]

        overlaps = [
            len(set(list(c1[:, 0])).intersection(set(list(c2[:, 0]))))
            for c1, c2 in zip(cube_entries, cube_entries[1:])
        ]
        assert (
            len(set(overlaps)) == 1
        ), "Each overlap should have the same number of entries. "

def test_diff_overlap_per_dim(self):
        data = np.random.rand(100, 3)
        c = Cover(perc_overlap=[0.4, 0.2])
        c.fit(data)

import numpy as np
from kmapper.cover import Cover

# uniform data:
data = np.arange(0, 1000).reshape((1000, 1))
lens = data
cov = Cover(10, 0.5, verbose=0)


def overlap(c1, c2):
    ints = set(c1).intersection(set(c2))
    return len(ints) / max(len(c1), len(c2))


# Prefix'ing the data with an ID column
ids = np.array([x for x in range(lens.shape[0])])
lens = np.c_[ids, lens]


bins = cov.fit(lens)
cube_entries = cov.transform(lens, bins)

for i, hypercube in enumerate(cube_entries):

def test_perc_overlap(self, CoverClass):
        """
        2 cubes with 50% overlap and a range of [0,1] should lead to two cubes with intervals:
            [0, .75]
            [.25, 1]
        """

        data = np.array([[0, 0], [1, 0.25], [2, 0.5], [3, 0.75], [4, 1]])

        cover = Cover(n_cubes=2, perc_overlap=0.5)
        cubes = cover.fit(data)
        cubes = list(cubes)
        entries = [cover.transform_single(data, cube) for cube in cubes]

        for i in (0, 1, 2, 3):
            assert data[i] in entries[0]
        for i in (1, 2, 3, 4):
            assert data[i] in entries[1]

def test_projection_without_pipeline(self):
        # accomodate scaling, values are in (0,1), but will be scaled slightly
        atol = 0.1

        mapper = KeplerMapper(verbose=1)
        data = np.random.rand(100, 5)
        lens = mapper.project(data, projection=[0, 1])
        np.testing.assert_allclose(lens, data[:, :2], atol=atol)

        lens = mapper.project(data, projection=[0])
        np.testing.assert_allclose(lens, data[:, :1], atol=atol)

def test_lens_size(self):
        mapper = KeplerMapper()

        data = np.random.rand(100, 10)
        lens = mapper.fit_transform(data)

        assert lens.shape[0] == data.shape[0]

def test_project_sklearn_class(self):
        mapper = KeplerMapper()
        data = np.random.rand(100, 5)
        lens = mapper.project(data, projection=PCA(n_components=1), scaler=None)

        pca = PCA(n_components=1)
        lens_confirm = pca.fit_transform(data)
        assert lens.shape == (100, 1)
        np.testing.assert_array_equal(lens, lens_confirm)

def mapper():
    mapper = km.KeplerMapper(verbose=0)
    data = np.random.rand(100, 2)
    graph = mapper.map(data)
    return graph

def test_members_from_id(self):
        mapper = KeplerMapper(verbose=1)
        data = np.random.rand(100, 2)

        ids = np.random.choice(10, 100)
        data[ids] = 2

        graph = mapper.map(data)
        graph["nodes"]["new node"] = ids
        mems = mapper.data_from_cluster_id("new node", graph, data)
        np.testing.assert_array_equal(data[ids], mems)