abd-clam 0.16.1

Clustered Learning of Approximate Manifolds
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

import unittest

from abd_clam import Edge
from abd_clam import Graph
from abd_clam import cluster
from abd_clam import cluster_criteria
from abd_clam import dataset
from abd_clam import graph
from abd_clam import graph_criteria
from abd_clam import metric
from abd_clam import space
from abd_clam.utils import synthetic_data


class TestGraph(unittest.TestCase):
    def setUp(self) -> None:
        self.data = dataset.TabularDataset(
            synthetic_data.bullseye(n=1000, num_rings=2)[0],
            name=f"{__name__}.bullseye",
        )
        self.distance_metric = metric.ScipyMetric("euclidean")
        self.metric_space = space.TabularSpace(self.data, self.distance_metric, False)

        partition_criteria = [cluster_criteria.MaxDepth(15)]
        self.root = (
            cluster.Cluster.new_root(self.metric_space)
            .build()
            .partition(partition_criteria)
        )

        self.clusters2 = graph_criteria.Layer(2)(self.root)
        pdist2 = self.metric_space.distance_pairwise(
            [c.arg_center for c in self.clusters2],
        )
        self.edges2: set[Edge] = {
            Edge(left, right, pdist2[i, j])
            for i, left in enumerate(self.clusters2)
            for j, right in enumerate(self.clusters2)
            if (i != j) and (pdist2[i, j] <= left.radius + right.radius)
        }
        self.graph2 = Graph(self.clusters2, self.edges2).build()
        self.graph2b = Graph(self.clusters2).build()

        self.clusters5 = graph_criteria.Layer(5)(self.root)
        self.graph5 = Graph(self.clusters5).build()

    def test_init(self):
        self.assertTrue(isinstance(self.graph2, graph.Graph))
        self.assertEqual(self.graph2.population, self.data.cardinality)
        self.assertEqual(self.graph2.min_depth, min(c.depth for c in self.clusters2))
        self.assertEqual(self.graph2.max_depth, max(c.depth for c in self.clusters2))
        self.assertFalse(any(e.to_self for e in self.edges2))

        self.assertSetEqual(self.graph2.edges, self.graph2b.edges)

    def test_contains(self):
        self.assertNotIn(self.root, self.graph2.clusters)

    def test_components(self):
        components = self.graph2.components
        [self.assertIsInstance(component, Graph) for component in components]
        self.assertEqual(
            self.graph2.vertex_cardinality,
            sum(component.vertex_cardinality for component in components),
        )

    def test_jaccard(self):
        self.assertEqual(self.graph2.jaccard(self.graph2), 1.0)
        self.assertEqual(self.graph2.jaccard(self.graph2b), 1.0)
        self.assertEqual(self.graph2.jaccard(self.graph5), 1.0)