abd-clam 0.14.0

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

import tempfile
import unittest

import numpy
from abd_clam import dataset
from abd_clam import metric
from abd_clam import space
from abd_clam.classification import Classifier
from abd_clam.utils import helpers
from abd_clam.utils import synthetic_data
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split


class TestSearch(unittest.TestCase):
    @staticmethod
    def get_score(train_x, test_x, train_y, test_y):
        data = dataset.TabularDataset(train_x, name="temp_train")
        labels = numpy.asarray(train_y).astype(numpy.uint)

        metric_spaces = [
            space.TabularSpace(data, metric.ScipyMetric("euclidean"), False),
            space.TabularSpace(data, metric.ScipyMetric("cityblock"), False),
        ]
        classifier = Classifier(labels, metric_spaces).build()

        test_labels = list(map(int, test_y))
        predicted_labels, scores = classifier.predict(
            dataset.TabularDataset(test_x, name="temp_test"),
        )
        score = accuracy_score(test_labels, predicted_labels)

        return score

    def test_digits(self):
        digits = load_digits()

        full_x = numpy.asarray(digits["data"]).astype(numpy.float32)
        full_x = helpers.normalize(full_x, mode="gaussian")
        full_y = digits["target"]

        score = self.get_score(
            *train_test_split(full_x, full_y, test_size=100, random_state=42),
        )
        self.assertGreaterEqual(score, 0.75, "score on digits dataset was too low.")

    def test_bullseye(self):
        full_x, full_y = synthetic_data.bullseye(n=256, num_rings=3)
        full_x = helpers.normalize(full_x, mode="gaussian")
        full_y = numpy.asarray(full_y).astype(numpy.uint)

        score = self.get_score(
            *train_test_split(full_x, full_y, test_size=100, random_state=42),
        )
        self.assertGreaterEqual(score, 0.75, "score on bullseye dataset was too low.")

    def test_cached(self):
        full_x, full_y = synthetic_data.bullseye(n=200, num_rings=3)
        full_x = helpers.normalize(full_x, mode="gaussian")
        full_y = numpy.asarray(full_y).astype(numpy.uint)

        train_x_, test_x_, train_y, test_y = train_test_split(
            full_x,
            full_y,
            test_size=100,
            random_state=42,
        )

        with tempfile.NamedTemporaryFile(
            suffix=".npy",
        ) as train_file, tempfile.NamedTemporaryFile(suffix=".npy") as test_file:
            numpy.save(train_file.name, train_x_, allow_pickle=False, fix_imports=False)
            numpy.save(test_file.name, test_x_, allow_pickle=False, fix_imports=False)

            train_data = dataset.TabularMMap(
                train_file.name,
                name="mmap_bullseye_train",
            )
            train_labels = numpy.asarray(train_y).astype(numpy.uint)

            metric_spaces = [
                space.TabularSpace(train_data, metric.ScipyMetric("euclidean"), True),
                space.TabularSpace(train_data, metric.ScipyMetric("cityblock"), True),
            ]
            classifier = Classifier(train_labels, metric_spaces).build()

            test_data = dataset.TabularMMap(test_file.name, name="mmap_bullseye_test")
            predicted_labels, scores = classifier.predict(test_data)

        test_labels = list(map(int, test_y))
        score = accuracy_score(test_labels, predicted_labels)

        self.assertGreaterEqual(
            score,
            0.75,
            "score on cached bullseye dataset was too low.",
        )