scikit-network 0.33.3__cp313-cp313-win_amd64.whl

sknetwork/clustering/louvain_core.pyx

@@ -0,0 +1,124 @@
+# distutils: language=c++
+# cython: language_level=3
+from libcpp.set cimport set
+cimport cython
+
+ctypedef fused int_or_long:
+    int
+    long
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+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
+    ----------
+    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 :
+        Labels of nodes.
+    increase :
+        Increase in modularity.
+    """
+    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 start
+    cdef int_or_long end
+
+    cdef float increase = 0
+    cdef float increase_pass
+    cdef float delta
+    cdef float delta_local
+    cdef float delta_best
+    cdef float in_weight
+    cdef float out_weight
+
+    cdef set[int_or_long] label_set = ()
+
+    n = labels.shape[0]
+    while not stop:
+        increase_pass = 0
+
+        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
+                label_best = label
+
+                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
+                        label_best = label_target
+                    cluster_weights[label_target] = 0
+
+                if label_best != label:
+                    increase_pass += delta_best
+                    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/metrics.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2018
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Optional, Union, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import get_probs
+from sknetwork.utils.format import get_adjacency
+from sknetwork.utils.membership import get_membership
+
+
+def get_modularity(input_matrix: Union[sparse.csr_matrix, np.ndarray], labels: np.ndarray,
+                   labels_col: Optional[np.ndarray] = None, weights: str = 'degree',
+                   resolution: float = 1, return_all: bool = False) -> Union[float, Tuple[float, float, float]]:
+    """Modularity of a clustering.
+
+    The modularity of a clustering is
+
+    :math:`Q = \\dfrac{1}{w} \\sum_{i,j}\\left(A_{ij} - \\gamma \\dfrac{w_iw_j}{w}\\right)\\delta_{c_i,c_j}`
+    for graphs,
+
+    :math:`Q = \\dfrac{1}{w} \\sum_{i,j}\\left(A_{ij} - \\gamma \\dfrac{d^+_id^-_j}{w}\\right)\\delta_{c_i,c_j}`
+    for directed graphs,
+
+    where
+
+    * :math:`c_i` is the cluster of node :math:`i`,\n
+    * :math:`w_i` is the weight of node :math:`i`,\n
+    * :math:`w^+_i, w^-_i` are the out-weight, in-weight of node :math:`i` (for directed graphs),\n
+    * :math:`w = 1^TA1` is the total weight,\n
+    * :math:`\\delta` is the Kronecker symbol,\n
+    * :math:`\\gamma \\ge 0` is the resolution parameter.
+
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    labels :
+        Labels of nodes.
+    labels_col :
+        Labels of column nodes (for bipartite graphs).
+    weights :
+        Weighting of nodes (``'degree'`` (default) or ``'uniform'``).
+    resolution:
+        Resolution parameter (default = 1).
+    return_all:
+        If ``True``, return modularity, fit, diversity.
+
+    Returns
+    -------
+    modularity : float
+    fit: float, optional
+    diversity: float, optional
+
+    Example
+    -------
+    >>> from sknetwork.clustering import get_modularity
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> labels = np.array([0, 0, 1, 1, 0])
+    >>> float(np.round(get_modularity(adjacency, labels), 2))
+    0.11
+    """
+    adjacency, bipartite = get_adjacency(input_matrix.astype(float))
+
+    if bipartite:
+        if labels_col is None:
+            raise ValueError('For bipartite graphs, you must specify the labels of both rows and columns.')
+        else:
+            labels = np.hstack((labels, labels_col))
+
+    if len(labels) != adjacency.shape[0]:
+        raise ValueError('Dimension mismatch between labels and input matrix.')
+
+    probs_row = get_probs(weights, adjacency)
+    probs_col = get_probs(weights, adjacency.T)
+    membership = get_membership(labels).astype(float)
+
+    fit = membership.T.dot(adjacency.dot(membership)).diagonal().sum() / adjacency.data.sum()
+    div = membership.T.dot(probs_col).dot(membership.T.dot(probs_row))
+    mod = fit - resolution * div
+    if return_all:
+        return mod, fit, div
+    else:
+        return mod

sknetwork/clustering/postprocess.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 10, 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.membership import get_membership
+
+
+def reindex_labels(labels: np.ndarray) -> np.ndarray:
+    """Reindex clusters in decreasing order of size.
+
+    Parameters
+    ----------
+    labels :
+        Label of each node.
+    Returns
+    -------
+    new_labels : np.ndarray
+        New label of each node.
+
+    Example
+    -------
+    >>> from sknetwork.clustering import reindex_labels
+    >>> labels = np.array([0, 1, 1])
+    >>> reindex_labels(labels)
+    array([1, 0, 0])
+    """
+    _, index, counts = np.unique(labels, return_inverse=True, return_counts=True)
+    _, new_index = np.unique(np.argsort(-counts), return_index=True)
+    return new_index[index]
+
+
+def aggregate_graph(input_matrix: sparse.csr_matrix, labels: Optional[np.ndarray] = None,
+                    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 discarded).
+
+    Parameters
+    ----------
+    input_matrix: sparse matrix
+        Adjacency or biadjacency matrix of the graph.
+    labels: np.ndarray
+        Labels of nodes.
+    labels_row: np.ndarray
+        Labels of rows (for bipartite graphs). Alias for labels.
+    labels_col: np.ndarray
+        Labels of columns (for bipartite graphs).
+    """
+    if labels_row is not None:
+        membership_row = get_membership(labels_row)
+    else:
+        membership_row = get_membership(labels)
+    if labels_col is not None:
+        membership_col = get_membership(labels_col)
+    else:
+        membership_col = membership_row
+    aggregate_matrix = membership_row.T.dot(input_matrix).dot(membership_col)
+    return aggregate_matrix.tocsr()

sknetwork/clustering/propagation_clustering.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on May, 2020
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.classification.propagation import Propagation
+from sknetwork.clustering.base import BaseClustering
+from sknetwork.utils.format import check_format, get_adjacency
+
+
+class PropagationClustering(BaseClustering, Propagation):
+    """Clustering by label propagation.
+
+    Parameters
+    ----------
+    n_iter : int
+        Maximum number of iterations (-1 for infinity).
+    node_order : str
+        * `'random'`: node labels are updated in random order.
+        * `'increasing'`: node labels are updated by increasing order of weight.
+        * `'decreasing'`: node labels are updated by decreasing order of weight.
+        * Otherwise, node labels are updated by index order.
+    weighted : bool
+        If ``True``, the vote of each neighbor is proportional to the edge weight.
+        Otherwise, all votes have weight 1.
+    sort_clusters : bool
+        If ``True``, sort labels in decreasing order of cluster size.
+    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, 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.
+
+    Example
+    -------
+    >>> from sknetwork.clustering import PropagationClustering
+    >>> from sknetwork.data import karate_club
+    >>> propagation = PropagationClustering()
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels = propagation.fit_predict(adjacency)
+    >>> len(set(labels))
+    2
+
+    References
+    ----------
+    Raghavan, U. N., Albert, R., & Kumara, S. (2007).
+    `Near linear time algorithm to detect community structures in large-scale networks.
+    <https://arxiv.org/pdf/0709.2938.pdf>`_
+    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_probs: bool = True, return_aggregate: bool = True):
+        Propagation.__init__(self, n_iter, node_order, weighted)
+        BaseClustering.__init__(self, sort_clusters, return_probs, return_aggregate)
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> 'PropagationClustering':
+        """Clustering by label propagation.
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+            Adjacency matrix or biadjacency matrix of the graph.
+
+        Returns
+        -------
+        self: :class:`PropagationClustering`
+        """
+        self._init_vars()
+
+        # input
+        input_matrix = check_format(input_matrix)
+        adjacency, bipartite = get_adjacency(input_matrix)
+
+        # propagation
+        Propagation.fit(self, adjacency)
+
+        # output
+        _, self.labels_ = np.unique(self.labels_, return_inverse=True)
+        if bipartite:
+            self._split_vars(input_matrix.shape)
+            self.bipartite = True
+        self._secondary_outputs(input_matrix)
+
+        return self

sknetwork/clustering/tests/__init__.py

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

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,135 @@
+#!/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_format(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+        labels = Louvain().fit_predict(adjacency.toarray())
+        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)