scikit-network 0.33.0__cp312-cp312-macosx_10_9_x86_64.whl

sknetwork/clustering/tests/test_API.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for clustering API"""
+import unittest
+
+from sknetwork.clustering import *
+from sknetwork.data.test_graphs import *
+
+
+class TestClusteringAPI(unittest.TestCase):
+
+    def setUp(self):
+        self.algos = [Louvain(return_aggregate=True), Leiden(return_aggregate=True),
+                      PropagationClustering(return_aggregate=True)]
+
+    def test_regular(self):
+        for algo in self.algos:
+            for adjacency in [test_graph(), test_digraph(), test_disconnected_graph()]:
+                n = adjacency.shape[0]
+                labels = algo.fit_predict(adjacency)
+                n_labels = len(set(labels))
+                self.assertEqual(labels.shape, (n,))
+                self.assertEqual(algo.aggregate_.shape, (n_labels, n_labels))
+                adjacency_bool = adjacency.astype(bool)
+                labels = algo.fit_predict(adjacency_bool)
+                n_labels = len(set(labels))
+                self.assertEqual(labels.shape, (n,))
+                self.assertEqual(algo.aggregate_.shape, (n_labels, n_labels))
+                membership = algo.fit_transform(adjacency_bool)
+                self.assertEqual(membership.shape, (n, n_labels))
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        for algo in self.algos:
+            algo.fit(biadjacency)
+            self.assertEqual(algo.labels_row_.shape, (n_row,))
+            self.assertEqual(algo.labels_col_.shape, (n_col,))

sknetwork/clustering/tests/test_kcenters.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for KCenters"""
+import unittest
+
+from sknetwork.clustering import KCenters
+from sknetwork.data.test_graphs import *
+
+
+class TestKCentersClustering(unittest.TestCase):
+
+    def test_kcenters(self):
+        # Test undirected graph
+        n_clusters = 2
+        adjacency = test_graph()
+        n_row = adjacency.shape[0]
+        kcenters = KCenters(n_clusters=n_clusters)
+        labels = kcenters.fit_predict(adjacency)
+        self.assertEqual(len(labels), n_row)
+        self.assertEqual(len(set(labels)), n_clusters)
+
+        # Test directed graph
+        n_clusters = 3
+        adjacency = test_digraph()
+        n_row = adjacency.shape[0]
+        kcenters = KCenters(n_clusters=n_clusters, directed=True)
+        labels = kcenters.fit_predict(adjacency)
+        self.assertEqual(len(labels), n_row)
+        self.assertEqual(len(set(labels)), n_clusters)
+
+        # Test bipartite graph
+        n_clusters = 2
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        kcenters = KCenters(n_clusters=n_clusters)
+        kcenters.fit(biadjacency)
+        labels = kcenters.labels_
+        self.assertEqual(len(kcenters.labels_row_), n_row)
+        self.assertEqual(len(kcenters.labels_col_), n_col)
+        self.assertEqual(len(set(labels)), n_clusters)
+
+    def test_kcenters_error(self):
+        # Test value errors
+        adjacency = test_graph()
+        biadjacency = test_bigraph()
+
+        # test n_clusters error
+        kcenters = KCenters(n_clusters=1)
+        with self.assertRaises(ValueError):
+            kcenters.fit(adjacency)
+
+        # test n_init error
+        kcenters = KCenters(n_clusters=2, n_init=0)
+        with self.assertRaises(ValueError):
+            kcenters.fit(adjacency)
+
+        # test center_position error
+        kcenters = KCenters(n_clusters=2, center_position="other")
+        with self.assertRaises(ValueError):
+            kcenters.fit(biadjacency)

sknetwork/clustering/tests/test_leiden.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Leiden"""
+import unittest
+
+from sknetwork.clustering import Leiden
+from sknetwork.data.test_graphs import *
+from sknetwork.utils import bipartite2undirected
+
+
+class TestLeidenClustering(unittest.TestCase):
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        n = adjacency.shape[0]
+        labels = Leiden().fit_predict(adjacency)
+        self.assertEqual(len(labels), n)
+
+    def test_modularity(self):
+        adjacency = test_graph()
+        leiden_d = Leiden(modularity='dugue')
+        leiden_n = Leiden(modularity='newman')
+        labels_d = leiden_d.fit_predict(adjacency)
+        labels_n = leiden_n.fit_predict(adjacency)
+        self.assertTrue((labels_d == labels_n).all())
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        adjacency = bipartite2undirected(biadjacency)
+        leiden = Leiden(modularity='newman')
+        labels1 = leiden.fit_predict(adjacency)
+        leiden.fit(biadjacency)
+        labels2 = np.concatenate((leiden.labels_row_, leiden.labels_col_))
+        self.assertTrue((labels1 == labels2).all())

sknetwork/clustering/tests/test_louvain.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Louvain"""
+import unittest
+
+from sknetwork.clustering import Louvain
+from sknetwork.data import karate_club, star_wars
+from sknetwork.data.test_graphs import *
+from sknetwork.utils import bipartite2undirected
+
+
+class TestLouvainClustering(unittest.TestCase):
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        n = adjacency.shape[0]
+        labels = Louvain().fit_predict(adjacency)
+        self.assertEqual(len(labels), n)
+
+    def test_modularity(self):
+        adjacency = karate_club()
+        louvain_d = Louvain(modularity='dugue')
+        louvain_n = Louvain(modularity='newman')
+        labels_d = louvain_d.fit_predict(adjacency)
+        labels_n = louvain_n.fit_predict(adjacency)
+        self.assertTrue((labels_d == labels_n).all())
+        louvain_p = Louvain(modularity='potts')
+        louvain_p.fit_predict(adjacency)
+
+    def test_bilouvain(self):
+        biadjacency = star_wars()
+        adjacency = bipartite2undirected(biadjacency)
+        louvain = Louvain(modularity='newman')
+        labels1 = louvain.fit_predict(adjacency)
+        louvain.fit(biadjacency)
+        labels2 = np.concatenate((louvain.labels_row_, louvain.labels_col_))
+        self.assertTrue((labels1 == labels2).all())
+
+    def test_options(self):
+        adjacency = karate_club()
+
+        # resolution
+        louvain = Louvain(resolution=2)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # tolerance
+        louvain = Louvain(resolution=2, tol_aggregation=0.1)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # shuffling
+        louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # aggregate graph
+        louvain = Louvain(return_aggregate=True)
+        labels = louvain.fit_predict(adjacency)
+        n_labels = len(set(labels))
+        self.assertEqual(louvain.aggregate_.shape, (n_labels, n_labels))
+
+        # aggregate graph
+        Louvain(n_aggregations=1, sort_clusters=False).fit(adjacency)
+
+    def test_options_with_64_bit(self):
+        adjacency = karate_club()
+        # force 64-bit index
+        adjacency.indices = adjacency.indices.astype(np.int64)
+        adjacency.indptr = adjacency.indptr.astype(np.int64)
+
+        # resolution
+        louvain = Louvain(resolution=2)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # tolerance
+        louvain = Louvain(resolution=2, tol_aggregation=0.1)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # shuffling
+        louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(set(labels)), 7)
+
+        # aggregate graph
+        louvain = Louvain(return_aggregate=True)
+        labels = louvain.fit_predict(adjacency)
+        n_labels = len(set(labels))
+        self.assertEqual(louvain.aggregate_.shape, (n_labels, n_labels))
+
+        # aggregate graph
+        Louvain(n_aggregations=1, sort_clusters=False).fit(adjacency)
+
+        # check if labels are 64-bit
+        self.assertEqual(labels.dtype, np.int64)
+
+    def test_predict(self):
+        adjacency = karate_club()
+        n_nodes = adjacency.shape[0]
+        louvain = Louvain()
+        labels = louvain.fit_predict(adjacency)
+        self.assertEqual(len(labels), n_nodes)
+        probs = louvain.fit_predict_proba(adjacency)
+        self.assertEqual(probs.shape[0], n_nodes)
+        membership = louvain.fit_transform(adjacency)
+        self.assertEqual(membership.shape[0], n_nodes)
+        biadjacency = star_wars()
+        n_row, n_col = biadjacency.shape
+        louvain.fit(biadjacency)
+        labels = louvain.predict()
+        self.assertEqual(len(labels), n_row)
+        labels = louvain.predict(columns=True)
+        self.assertEqual(len(labels), n_col)
+        probs = louvain.predict_proba()
+        self.assertEqual(probs.shape[0], n_row)
+        probs = louvain.predict(columns=True)
+        self.assertEqual(probs.shape[0], n_col)
+        membership = louvain.transform()
+        self.assertEqual(membership.shape[0], n_row)
+        membership = louvain.transform(columns=True)
+        self.assertEqual(membership.shape[0], n_col)
+
+    def test_invalid(self):
+        adjacency = karate_club()
+        louvain = Louvain(modularity='toto')
+        with self.assertRaises(ValueError):
+            louvain.fit(adjacency)

sknetwork/clustering/tests/test_metrics.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# tests for metrics.py
+""""tests for clustering metrics"""
+import unittest
+
+import numpy as np
+
+from sknetwork.clustering import get_modularity, Louvain
+from sknetwork.data import star_wars, karate_club
+from sknetwork.data.test_graphs import test_graph
+
+
+class TestClusteringMetrics(unittest.TestCase):
+
+    def setUp(self):
+        """Basic graph for tests"""
+        self.adjacency = test_graph()
+        n = self.adjacency.shape[0]
+        labels = np.zeros(n)
+        labels[0] = 1
+        self.labels = labels.astype(int)
+        self.unique_cluster = np.zeros(n, dtype=int)
+
+    def test_api(self):
+        for metric in [get_modularity]:
+            _, fit, div = metric(self.adjacency, self.labels, return_all=True)
+            mod = metric(self.adjacency, self.labels, return_all=False)
+            self.assertAlmostEqual(fit - div, mod)
+            self.assertAlmostEqual(metric(self.adjacency, self.unique_cluster), 0.)
+
+            with self.assertRaises(ValueError):
+                metric(self.adjacency, self.labels[:3])
+
+    def test_modularity(self):
+        adjacency = karate_club()
+        labels = Louvain().fit_predict(adjacency)
+        self.assertAlmostEqual(get_modularity(adjacency, labels), 0.42, 2)
+
+    def test_bimodularity(self):
+        biadjacency = star_wars()
+        labels_row = np.array([0, 0, 1, 1])
+        labels_col = np.array([0, 1, 0])
+        self.assertAlmostEqual(get_modularity(biadjacency, labels_row, labels_col), 0.12, 2)
+
+        with self.assertRaises(ValueError):
+            get_modularity(biadjacency, labels_row)
+        with self.assertRaises(ValueError):
+            get_modularity(biadjacency, labels_row[:2], labels_col)
+        with self.assertRaises(ValueError):
+            get_modularity(biadjacency, labels_row, labels_col[:2])

sknetwork/clustering/tests/test_postprocess.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for clustering post-processing"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, star_wars
+from sknetwork.clustering.postprocess import reindex_labels, aggregate_graph
+
+
+class TestClusteringPostProcessing(unittest.TestCase):
+
+    def test_reindex_clusters(self):
+        truth = np.array([1, 1, 2, 0, 0, 0])
+
+        labels = np.array([0, 0, 1, 2, 2, 2])
+        output = reindex_labels(labels)
+        self.assertTrue(np.array_equal(truth, output))
+
+        labels = np.array([0, 0, 5, 2, 2, 2])
+        output = reindex_labels(labels)
+        self.assertTrue(np.array_equal(truth, output))
+
+    def test_aggregate_graph(self):
+        adjacency = house()
+        labels = np.array([0, 0, 1, 1, 2])
+        aggregate = aggregate_graph(adjacency, labels)
+        self.assertEqual(aggregate.shape, (3, 3))
+
+        biadjacency = star_wars()
+        labels = np.array([0, 0, 1, 2])
+        labels_row = np.array([0, 1, 3, -1])
+        labels_col = np.array([0, 0, 1])
+        aggregate = aggregate_graph(biadjacency, labels=labels, labels_col=labels_col)
+        self.assertEqual(aggregate.shape, (3, 2))
+        self.assertEqual(aggregate.shape, (3, 2))
+        aggregate = aggregate_graph(biadjacency, labels_row=labels_row, labels_col=labels_col)
+        self.assertEqual(aggregate.shape, (4, 2))

sknetwork/data/__init__.py

@@ -0,0 +1,6 @@
+"""data module"""
+from sknetwork.data.base import *
+from sknetwork.data.load import *
+from sknetwork.data.models import *
+from sknetwork.data.parse import from_edge_list, from_adjacency_list, from_csv, from_graphml
+from sknetwork.data.toy_graphs import *

sknetwork/data/base.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+
+class Dataset(dict):
+    """Container object for datasets.
+    Dictionary-like object that exposes its keys as attributes.
+    >>> dataset = Dataset(name='dataset')
+    >>> dataset['name']
+    'dataset'
+    >>> dataset.name
+    'dataset'
+    """
+    def __init__(self, **kwargs):
+        super().__init__(kwargs)
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(key)
+
+
+# alias for Dataset
+Bunch = Dataset
+