scikit-network 0.33.0__cp312-cp312-win_amd64.whl

sknetwork/classification/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for classification"""

sknetwork/classification/tests/test_API.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for classification API"""
+
+import unittest
+
+from sknetwork.classification import *
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import LouvainEmbedding
+
+
+class TestClassificationAPI(unittest.TestCase):
+
+    def test_undirected(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+            seeds_array = -np.ones(n)
+            seeds_array[:2] = np.arange(2)
+            seeds_dict = {0: 0, 1: 1}
+
+            classifiers = [PageRankClassifier(), DiffusionClassifier(),
+                           NNClassifier(embedding_method=LouvainEmbedding(), n_neighbors=1), Propagation()]
+
+            for algo in classifiers:
+                labels1 = algo.fit_predict(adjacency, seeds_array)
+                labels2 = algo.fit_predict(adjacency, seeds_dict)
+                self.assertTrue((labels1 == labels2).all())
+                self.assertEqual(labels2.shape, (n,))
+                membership = algo.fit_transform(adjacency, seeds_array)
+                self.assertTupleEqual(membership.shape, (n, 2))

sknetwork/classification/tests/test_diffusion.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for DiffusionClassifier"""
+
+import unittest
+
+from sknetwork.classification import DiffusionClassifier
+from sknetwork.data.test_graphs import *
+
+
+class TestDiffusionClassifier(unittest.TestCase):
+
+    def test_graph(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        algo.fit(adjacency, labels=labels)
+        self.assertTrue(len(algo.labels_) == n_nodes)
+        adjacency = test_digraph()
+        algo = DiffusionClassifier(centering=False)
+        algo.fit(adjacency, labels=labels)
+        self.assertTrue(len(algo.labels_) == n_nodes)
+        with self.assertRaises(ValueError):
+            DiffusionClassifier(n_iter=0)
+        algo = DiffusionClassifier(centering=True, scale=10)
+        probs = algo.fit_predict_proba(adjacency, labels=labels)[:, 1]
+        self.assertTrue(max(probs) > 0.99)
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        labels_row = {0: 0, 1: 1}
+        labels_col = {5: 1}
+        algo = DiffusionClassifier()
+        algo.fit(biadjacency, labels_row=labels_row, labels_col=labels_col)
+        self.assertTrue(len(algo.labels_row_) == n_row)
+        self.assertTrue(len(algo.labels_col_) == n_col)
+        self.assertTrue(all(algo.labels_col_ == algo.predict(columns=True)))
+
+    def test_predict(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(adjacency, labels=labels)
+        self.assertTrue(len(labels_pred) == n_nodes)
+        probs_pred = algo.fit_predict_proba(adjacency, labels=labels)
+        self.assertTrue(probs_pred.shape == (n_nodes, 2))
+        membership = algo.fit_transform(adjacency, labels=labels)
+        self.assertTrue(membership.shape == (n_nodes, 2))
+
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        labels_row = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(biadjacency, labels_row=labels_row)
+        self.assertTrue(len(labels_pred) == n_row)
+        labels_pred = algo.predict(columns=True)
+        self.assertTrue(len(labels_pred) == n_col)
+        probs_pred = algo.fit_predict_proba(biadjacency, labels_row=labels_row)
+        self.assertTrue(probs_pred.shape == (n_row, 2))
+        probs_pred = algo.predict_proba(columns=True)
+        self.assertTrue(probs_pred.shape == (n_col, 2))
+        membership = algo.fit_transform(biadjacency, labels_row=labels_row)
+        self.assertTrue(membership.shape == (n_row, 2))
+        membership = algo.transform(columns=True)
+        self.assertTrue(membership.shape == (n_col, 2))
+
+    def test_reindex_label(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 2, 2: 3}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(adjacency, labels=labels)
+        self.assertTrue(len(labels_pred) == n_nodes)
+        self.assertTrue(set(list(labels_pred)) == {0, 2, 3})

sknetwork/classification/tests/test_knn.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for KNN"""
+import unittest
+
+from sknetwork.classification import NNClassifier
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral
+
+
+class TestKNNClassifier(unittest.TestCase):
+
+    def test_classification(self):
+        for adjacency in [test_graph(), test_digraph(), test_bigraph()]:
+            labels = {0: 0, 1: 1}
+
+            algo = NNClassifier(n_neighbors=1)
+            labels_pred = algo.fit_predict(adjacency, labels)
+            self.assertTrue(len(set(labels_pred)) == 2)
+
+            algo = NNClassifier(n_neighbors=1, embedding_method=Spectral(2), normalize=False)
+            labels_pred = algo.fit_predict(adjacency, labels)
+            self.assertTrue(len(set(labels_pred)) == 2)

sknetwork/classification/tests/test_metrics.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for classification metrics"""
+
+import unittest
+
+from sknetwork.classification.metrics import *
+
+
+class TestMetrics(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.labels_true = np.array([0, 1, 1, 2, 2, -1])
+        self.labels_pred1 = np.array([0, -1, 1, 2, 0, 0])
+        self.labels_pred2 = np.array([-1, -1, -1, -1, -1, 0])
+
+    def test_accuracy(self):
+        self.assertEqual(get_accuracy_score(self.labels_true, self.labels_pred1), 0.75)
+        with self.assertRaises(ValueError):
+            get_accuracy_score(self.labels_true, self.labels_pred2)
+
+    def test_confusion(self):
+        confusion = get_confusion_matrix(self.labels_true, self.labels_pred1)
+        self.assertEqual(confusion.data.sum(), 4)
+        self.assertEqual(confusion.diagonal().sum(), 3)
+        with self.assertRaises(ValueError):
+            get_accuracy_score(self.labels_true, self.labels_pred2)
+
+    def test_f1_score(self):
+        f1_score = get_f1_score(np.array([0, 0, 1]), np.array([0, 1, 1]))
+        self.assertAlmostEqual(f1_score, 0.67, 2)
+        with self.assertRaises(ValueError):
+            get_f1_score(self.labels_true, self.labels_pred1)
+
+    def test_f1_scores(self):
+        f1_scores = get_f1_scores(self.labels_true, self.labels_pred1)
+        self.assertAlmostEqual(min(f1_scores), 0.67, 2)
+        f1_scores, precisions, recalls = get_f1_scores(self.labels_true, self.labels_pred1, True)
+        self.assertAlmostEqual(min(f1_scores), 0.67, 2)
+        self.assertAlmostEqual(min(precisions), 0.5, 2)
+        self.assertAlmostEqual(min(recalls), 0.5, 2)
+        with self.assertRaises(ValueError):
+            get_f1_scores(self.labels_true, self.labels_pred2)
+
+    def test_average_f1_score(self):
+        f1_score = get_average_f1_score(self.labels_true, self.labels_pred1)
+        self.assertAlmostEqual(f1_score, 0.78, 2)
+        f1_score = get_average_f1_score(self.labels_true, self.labels_pred1, average='micro')
+        self.assertEqual(f1_score, 0.75)
+        f1_score = get_average_f1_score(self.labels_true, self.labels_pred1, average='weighted')
+        self.assertEqual(f1_score, 0.80)
+        with self.assertRaises(ValueError):
+            get_average_f1_score(self.labels_true, self.labels_pred2, 'toto')

sknetwork/classification/tests/test_pagerank.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for PageRankClassifier"""
+
+import unittest
+
+from sknetwork.classification import PageRankClassifier
+from sknetwork.data.test_graphs import *
+
+
+class TestPageRankClassifier(unittest.TestCase):
+
+    def test_solvers(self):
+        adjacency = test_graph()
+        labels = {0: 0, 1: 1}
+
+        ref = PageRankClassifier(solver='piteration').fit_predict(adjacency, labels)
+        for solver in ['lanczos', 'bicgstab']:
+            labels_pred = PageRankClassifier(solver=solver).fit_predict(adjacency, labels)
+            self.assertTrue((ref == labels_pred).all())

sknetwork/classification/tests/test_propagation.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for label propagation"""
+
+import unittest
+
+from sknetwork.classification import Propagation
+from sknetwork.data.test_graphs import *
+
+
+class TestLabelPropagation(unittest.TestCase):
+
+    def test_algo(self):
+        for adjacency in [test_graph(), test_digraph(), test_bigraph()]:
+            n = adjacency.shape[0]
+            labels = {0: 0, 1: 1}
+            propagation = Propagation(n_iter=3, weighted=False)
+            labels_pred = propagation.fit_predict(adjacency, labels)
+            self.assertEqual(labels_pred.shape, (n,))
+
+            for order in ['random', 'decreasing', 'increasing']:
+                propagation = Propagation(node_order=order)
+                labels_pred = propagation.fit_predict(adjacency, labels)
+                self.assertEqual(labels_pred.shape, (n,))