scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/clustering/louvain_core.pyx

@@ -1,9 +1,6 @@
-# distutils: language = c++
+# distutils: language=c++
 # cython: language_level=3
-# cython: linetrace=True
-# distutils: define_macros=CYTHON_TRACE_NOGIL=1
 from libcpp.set cimport set
-from libcpp.vector cimport vector
 cimport cython
 
 ctypedef fused int_or_long:
@@ -12,123 +9,116 @@ ctypedef fused int_or_long:
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def fit_core(float resolution, float tol, float[:] ou_node_probs, float[:] in_node_probs, float[:] self_loops,
-             float[:] data, int_or_long[:] indices, int_or_long[:] indptr):  # pragma: no cover
-    """Fit the clusters to the objective function.
+def optimize_core(int_or_long[:] labels, int_or_long[:] indices, int_or_long[:] indptr, float[:] data,
+    float[:] out_weights, float[:] in_weights, float[:] out_cluster_weights, float[:] in_cluster_weights,
+    float[:] cluster_weights, float[:] self_loops, float resolution, float tol_optimization):  # pragma: no cover
+    """Find clusters maximizing modularity.
 
     Parameters
     ----------
-    resolution :
-        Resolution parameter (positive).
-    tol :
-        Minimum increase in modularity to enter a new optimization pass.
-    ou_node_probs :
-        Distribution of node weights based on their out-edges (sums to 1).
-    in_node_probs :
-        Distribution of node weights based on their in-edges (sums to 1).
-    self_loops :
-        Weights of self loops.
-    data :
-        CSR format data array of the normalized adjacency matrix.
+    labels :
+        Initial labels.
     indices :
         CSR format index array of the normalized adjacency matrix.
     indptr :
         CSR format index pointer array of the normalized adjacency matrix.
+    data :
+        CSR format data array of the normalized adjacency matrix.
+    out_weights :
+        Out-weights of nodes (sum to 1).
+    in_weights :
+        In-weights of nodes (sum to 1).
+    out_cluster_weights :
+        Out-weights of clusters (sum to 1).
+    in_cluster_weights :
+        In-weights of clusters (sum to 1).
+    cluster_weights :
+        Weights of clusters (initialized to 0).
+    self_loops :
+        Weights of self loops.
+    resolution :
+        Resolution parameter (positive).
+    tol_optimization :
+        Minimum increase in modularity to enter a new optimization pass.
 
     Returns
     -------
     labels :
-        Cluster index of each node.
-    total_increase :
-        Score of the clustering (total increase in modularity).
+        Labels of nodes.
+    increase :
+        Increase in modularity.
     """
-    cdef int_or_long n = indptr.shape[0] - 1
-    cdef int_or_long increase = 1
-    cdef int_or_long cluster
-    cdef int_or_long cluster_best
-    cdef int_or_long cluster_node
+    cdef int_or_long n
+    cdef int_or_long stop = 0
+    cdef int_or_long label
+    cdef int_or_long label_target
+    cdef int_or_long label_best
     cdef int_or_long i
     cdef int_or_long j
-    cdef int_or_long j1
-    cdef int_or_long j2
-    cdef int_or_long label
+    cdef int_or_long start
+    cdef int_or_long end
 
-    cdef float increase_total = 0
+    cdef float increase = 0
     cdef float increase_pass
     cdef float delta
-    cdef float delta_best
-    cdef float delta_exit
     cdef float delta_local
-    cdef float node_prob_in
-    cdef float node_prob_ou
-    cdef float ratio_in
-    cdef float ratio_ou
-
-    cdef vector[int_or_long] labels
-    cdef vector[float] neighbor_clusters_weights
-    cdef vector[float] ou_clusters_weights
-    cdef vector[float] in_clusters_weights
-    cdef set[int_or_long] unique_clusters = ()
-
-    for i in range(n):
-        labels.push_back(i)
-        neighbor_clusters_weights.push_back(0.)
-        ou_clusters_weights.push_back(ou_node_probs[i])
-        in_clusters_weights.push_back(in_node_probs[i])
-
-    while increase == 1:
-        increase = 0
-        increase_pass = 0
-
-        for i in range(n):
-            unique_clusters.clear()
-            cluster_node = labels[i]
-            j1 = indptr[i]
-            j2 = indptr[i + 1]
-
-            for j in range(j1, j2):
-                label = labels[indices[j]]
-                neighbor_clusters_weights[label] += data[j]
-                unique_clusters.insert(label)
+    cdef float delta_best
+    cdef float in_weight
+    cdef float out_weight
 
-            unique_clusters.erase(cluster_node)
+    cdef set[int_or_long] label_set = ()
 
-            if not unique_clusters.empty():
-                node_prob_ou = ou_node_probs[i]
-                node_prob_in = in_node_probs[i]
-                ratio_ou = resolution * node_prob_ou
-                ratio_in = resolution * node_prob_in
+    n = labels.shape[0]
+    while not stop:
+        increase_pass = 0
 
-                delta_exit = 2 * (neighbor_clusters_weights[cluster_node] - self_loops[i])
-                delta_exit -= ratio_ou * (in_clusters_weights[cluster_node] - node_prob_in)
-                delta_exit -= ratio_in * (ou_clusters_weights[cluster_node] - node_prob_ou)
+        for i in range(n):
+            label_set.clear()
+            label = labels[i]
+            start = indptr[i]
+            end = indptr[i+1]
+
+            # neighboring clusters
+            for j in range(start, end):
+                label_target = labels[indices[j]]
+                label_set.insert(label_target)
+                cluster_weights[label_target] += data[j]
+            label_set.erase(label)
+
+            if not label_set.empty():
+                out_weight = out_weights[i]
+                in_weight = in_weights[i]
+
+                # node leaving the current cluster
+                delta = 2 * (cluster_weights[label] - self_loops[i])
+                delta -= resolution * out_weight * (in_cluster_weights[label] - in_weight)
+                delta -= resolution * in_weight * (out_cluster_weights[label] - out_weight)
 
                 delta_best = 0
-                cluster_best = cluster_node
+                label_best = label
 
-                for cluster in unique_clusters:
-                    delta = 2 * neighbor_clusters_weights[cluster]
-                    delta -= ratio_ou * in_clusters_weights[cluster]
-                    delta -= ratio_in * ou_clusters_weights[cluster]
-
-                    delta_local = delta - delta_exit
+                for label_target in label_set:
+                    delta_local = 2 * cluster_weights[label_target]
+                    delta_local -= resolution * out_weight * in_cluster_weights[label_target]
+                    delta_local -= resolution * in_weight * out_cluster_weights[label_target]
+                    delta_local -= delta
                     if delta_local > delta_best:
                         delta_best = delta_local
-                        cluster_best = cluster
-
-                    neighbor_clusters_weights[cluster] = 0
+                        label_best = label_target
+                    cluster_weights[label_target] = 0
 
-                if delta_best > 0:
+                if label_best != label:
                     increase_pass += delta_best
-                    ou_clusters_weights[cluster_node] -= node_prob_ou
-                    in_clusters_weights[cluster_node] -= node_prob_in
-                    ou_clusters_weights[cluster_best] += node_prob_ou
-                    in_clusters_weights[cluster_best] += node_prob_in
-                    labels[i] = cluster_best
-
-            neighbor_clusters_weights[cluster_node] = 0
-
-        increase_total += increase_pass
-        if increase_pass > tol:
-            increase = 1
-    return labels, increase_total
+                    labels[i] = label_best
+                    # update weights
+                    out_cluster_weights[label] -= out_weight
+                    in_cluster_weights[label] -= in_weight
+                    out_cluster_weights[label_best] += out_weight
+                    in_cluster_weights[label_best] += in_weight
+
+            cluster_weights[label] = 0
+
+        increase += increase_pass
+        stop = increase_pass <= tol_optimization
+
+    return labels, increase

sknetwork/clustering/postprocess.py

@@ -41,7 +41,7 @@ def aggregate_graph(input_matrix: sparse.csr_matrix, labels: Optional[np.ndarray
                     labels_row: Optional[np.ndarray] = None, labels_col: Optional[np.ndarray] = None) \
         -> sparse.csr_matrix:
     """Aggregate graph per label. All nodes with the same label become a single node.
-    Negative labels are ignored (corresponding nodes are not discarded).
+    Negative labels are ignored (corresponding nodes are discarded).
 
     Parameters
     ----------
@@ -63,4 +63,4 @@ def aggregate_graph(input_matrix: sparse.csr_matrix, labels: Optional[np.ndarray
     else:
         membership_col = membership_row
     aggregate_matrix = membership_row.T.dot(input_matrix).dot(membership_col)
-    return aggregate_matrix
+    return aggregate_matrix.tocsr()

sknetwork/clustering/propagation_clustering.py

@@ -29,27 +29,23 @@ class PropagationClustering(BaseClustering, Propagation):
     weighted : bool
         If ``True``, the vote of each neighbor is proportional to the edge weight.
         Otherwise, all votes have weight 1.
-    sort_clusters :
+    sort_clusters : bool
         If ``True``, sort labels in decreasing order of cluster size.
-    return_membership :
-        If ``True``, return the membership matrix of nodes to each cluster (soft clustering).
-    return_aggregate :
+    return_probs : bool
+        If ``True``, return the probability distribution over clusters (soft clustering).
+    return_aggregate : bool
         If ``True``, return the aggregate adjacency matrix or biadjacency matrix between clusters.
 
     Attributes
     ----------
-    labels_ : np.ndarray
-        Labels of the nodes.
-    labels_row_ : np.ndarray
-        Labels of the rows (for bipartite graphs).
-    labels_col_ : np.ndarray
-        Labels of the columns (for bipartite graphs).
-    membership_ : sparse.csr_matrix
-        Membership matrix of the nodes, shape (n_nodes, n_clusters).
-    membership_row_ : sparse.csr_matrix
-        Membership matrix of the rows (for bipartite graphs).
-    membership_col_ : sparse.csr_matrix
-        Membership matrix of the columns (for bipartite graphs).
+    labels_ : np.ndarray, shape (n_labels,)
+        Label of each node.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_, labels_col_ : np.ndarray
+        Labels of rows and columns, for bipartite graphs.
+    probs_row_, probs_col_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels for rows and columns (for bipartite graphs).
     aggregate_ : sparse.csr_matrix
         Aggregate adjacency matrix or biadjacency matrix between clusters.
 
@@ -72,9 +68,9 @@ class PropagationClustering(BaseClustering, Propagation):
     Physical review E, 76(3), 036106.
     """
     def __init__(self, n_iter: int = 5, node_order: str = 'decreasing', weighted: bool = True,
-                 sort_clusters: bool = True, return_membership: bool = True, return_aggregate: bool = True):
+                 sort_clusters: bool = True, return_probs: bool = True, return_aggregate: bool = True):
         Propagation.__init__(self, n_iter, node_order, weighted)
-        BaseClustering.__init__(self, sort_clusters, return_membership, return_aggregate)
+        BaseClustering.__init__(self, sort_clusters, return_probs, return_aggregate)
         self.bipartite = None
 
     def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> 'PropagationClustering':
@@ -82,7 +78,7 @@ class PropagationClustering(BaseClustering, Propagation):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
 
         Returns

sknetwork/clustering/tests/test_API.py

@@ -9,9 +9,13 @@ 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 [Louvain(return_aggregate=True), PropagationClustering(return_aggregate=True)]:
-            for adjacency in [test_graph(), test_digraph(), test_graph_disconnect()]:
+        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))
@@ -22,13 +26,13 @@ class TestClusteringAPI(unittest.TestCase):
                 n_labels = len(set(labels))
                 self.assertEqual(labels.shape, (n,))
                 self.assertEqual(algo.aggregate_.shape, (n_labels, n_labels))
-                membership = algo.fit_transform(adjacency)
+                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 [Louvain(return_aggregate=True), PropagationClustering(return_aggregate=True)]:
+        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,92 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for KCenters"""
+import unittest
+
+from sknetwork.clustering import KCenters
+from sknetwork.data import karate_club, painters, star_wars
+from sknetwork.data.test_graphs import *
+
+
+class TestKCentersClustering(unittest.TestCase):
+
+    def test_kcenters(self):
+        # Test undirected graph
+        n_clusters = 2
+        adjacency = karate_club()
+        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 = painters()
+        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 = star_wars()
+        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_centers(self):
+        # Test centers for undirected graphs
+        n_clusters = 2
+        adjacency = karate_club()
+        kcenters = KCenters(n_clusters=n_clusters)
+        kcenters.fit(adjacency)
+        centers = kcenters.centers_
+        self.assertEqual(n_clusters, len(set(centers)))
+
+        # Test centers for bipartite graphs
+        n_clusters = 2
+        biadjacency = star_wars()
+        n_row, n_col = biadjacency.shape
+        for position in ["row", "col", "both"]:
+            kcenters = KCenters(n_clusters=n_clusters, center_position=position)
+            kcenters.fit(biadjacency)
+            centers_row = kcenters.centers_row_
+            centers_col = kcenters.centers_col_
+            if position == "row":
+                self.assertEqual(n_clusters, len(set(centers_row)))
+                self.assertTrue(np.all(centers_row < n_row))
+                self.assertTrue(centers_col is None)
+            if position == "col":
+                self.assertEqual(n_clusters, len(set(centers_col)))
+                self.assertTrue(np.all((centers_col < n_col) & (0 <= centers_col)))
+                self.assertTrue(centers_row is None)
+            if position == "both":
+                self.assertEqual(n_clusters, len(set(centers_row)) + len(set(centers_col)))
+                self.assertTrue(np.all(centers_row < n_row))
+                self.assertTrue(np.all((centers_col < n_col) & (0 <= centers_col)))
+
+    def test_kcenters_error(self):
+        # Test value errors
+        adjacency = karate_club()
+        biadjacency = star_wars()
+
+        # 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

@@ -12,7 +12,7 @@ from sknetwork.utils import bipartite2undirected
 class TestLouvainClustering(unittest.TestCase):
 
     def test_disconnected(self):
-        adjacency = test_graph_disconnect()
+        adjacency = test_disconnected_graph()
         n = adjacency.shape[0]
         labels = Louvain().fit_predict(adjacency)
         self.assertEqual(len(labels), n)
@@ -24,7 +24,6 @@ class TestLouvainClustering(unittest.TestCase):
         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)
 
@@ -48,7 +47,7 @@ class TestLouvainClustering(unittest.TestCase):
         # tolerance
         louvain = Louvain(resolution=2, tol_aggregation=0.1)
         labels = louvain.fit_predict(adjacency)
-        self.assertEqual(len(set(labels)), 12)
+        self.assertEqual(len(set(labels)), 7)
 
         # shuffling
         louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)
@@ -78,7 +77,7 @@ class TestLouvainClustering(unittest.TestCase):
         # tolerance
         louvain = Louvain(resolution=2, tol_aggregation=0.1)
         labels = louvain.fit_predict(adjacency)
-        self.assertEqual(len(set(labels)), 12)
+        self.assertEqual(len(set(labels)), 7)
 
         # shuffling
         louvain = Louvain(resolution=2, shuffle_nodes=True, random_state=42)

sknetwork/data/__init__.py

@@ -1,5 +1,6 @@
 """data module"""
-from sknetwork.data.load import load_netset, load_konect, clear_data_home, clean_data_home, get_data_home, save, load
+from sknetwork.data.base import Bunch
+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,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+
+class Bunch(dict):
+    """Container object for datasets.
+    Dictionary-like object that exposes its keys as attributes.
+    >>> dataset = Bunch(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)