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

sknetwork/classification/vote.pyx

@@ -1,9 +1,7 @@
 # distutils: language = c++
 # cython: language_level=3
-# cython: linetrace=True
-# distutils: define_macros=CYTHON_TRACE_NOGIL=1
 """
-Created on April, 2020
+Created in April 2020
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 from libcpp.set cimport set

sknetwork/clustering/__init__.py

@@ -1,6 +1,8 @@
 """clustering module"""
 from sknetwork.clustering.base import BaseClustering
 from sknetwork.clustering.louvain import Louvain
+from sknetwork.clustering.leiden import Leiden
+from sknetwork.clustering.propagation_clustering import PropagationClustering
 from sknetwork.clustering.metrics import get_modularity
 from sknetwork.clustering.postprocess import reindex_labels, aggregate_graph
-from sknetwork.clustering.propagation_clustering import PropagationClustering
+from sknetwork.clustering.kcenters import KCenters

sknetwork/clustering/base.py

@@ -9,8 +9,8 @@ from abc import ABC
 import numpy as np
 from scipy import sparse
 
-from sknetwork.linalg.normalization import normalize
-from sknetwork.utils.base import Algorithm
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.base import Algorithm
 from sknetwork.utils.membership import get_membership
 
 
@@ -19,24 +19,20 @@ class BaseClustering(Algorithm, ABC):
 
     Attributes
     ----------
-    labels_ : np.ndarray
-        Labels of the nodes (rows for bipartite graphs)
-    labels_row_ : np.ndarray
-        Labels of the rows (for bipartite graphs).
-    labels_col_ : np.ndarray
-        Labels of the columns (for bipartite graphs, in case of co-clustering).
-    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, in case of co-clustering).
+    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.
     """
-    def __init__(self, sort_clusters: bool = True, return_membership: bool = False, return_aggregate: bool = False):
+    def __init__(self, sort_clusters: bool = True, return_probs: bool = False, return_aggregate: bool = False):
         self.sort_clusters = sort_clusters
-        self.return_membership = return_membership
+        self.return_probs = return_probs
         self.return_aggregate = return_aggregate
         self._init_vars()
 
@@ -82,8 +78,8 @@ class BaseClustering(Algorithm, ABC):
             Probability distribution over labels.
         """
         if columns:
-            return self.membership_col_.toarray()
-        return self.membership_.toarray()
+            return self.probs_col_.toarray()
+        return self.probs_.toarray()
 
     def fit_predict_proba(self, *args, **kwargs) -> np.ndarray:
         """Fit algorithm to the data and return the probability distribution over labels.
@@ -107,12 +103,12 @@ class BaseClustering(Algorithm, ABC):
 
         Returns
         -------
-        membership : sparse.csr_matrix
-            Probability distribution over labels (aka membership matrix).
+        probs : sparse.csr_matrix
+            Probability distribution over labels.
         """
         if columns:
-            return self.membership_col_
-        return self.membership_
+            return self.probs_col_
+        return self.probs_
 
     def fit_transform(self, *args, **kwargs) -> np.ndarray:
         """Fit algorithm to the data and return the membership matrix. Same parameters as the ``fit`` method.
@@ -130,9 +126,9 @@ class BaseClustering(Algorithm, ABC):
         self.labels_ = None
         self.labels_row_ = None
         self.labels_col_ = None
-        self.membership_ = None
-        self.membership_row_ = None
-        self.membership_col_ = None
+        self.probs_ = None
+        self.probs_row_ = None
+        self.probs_col_ = None
         self.aggregate_ = None
         self.bipartite = None
         return self
@@ -147,30 +143,30 @@ class BaseClustering(Algorithm, ABC):
 
     def _secondary_outputs(self, input_matrix: sparse.csr_matrix):
         """Compute different variables from labels_."""
-        if self.return_membership or self.return_aggregate:
+        if self.return_probs or self.return_aggregate:
             input_matrix = input_matrix.astype(float)
             if not self.bipartite:
-                membership = get_membership(self.labels_)
-                if self.return_membership:
-                    self.membership_ = normalize(input_matrix.dot(membership))
+                probs = get_membership(self.labels_)
+                if self.return_probs:
+                    self.probs_ = normalize(input_matrix.dot(probs))
                 if self.return_aggregate:
-                    self.aggregate_ = sparse.csr_matrix(membership.T.dot(input_matrix.dot(membership)))
+                    self.aggregate_ = sparse.csr_matrix(probs.T.dot(input_matrix.dot(probs)))
             else:
                 if self.labels_col_ is None:
                     n_labels = max(self.labels_) + 1
-                    membership_row = get_membership(self.labels_, n_labels=n_labels)
-                    membership_col = normalize(input_matrix.T.dot(membership_row))
+                    probs_row = get_membership(self.labels_, n_labels=n_labels)
+                    probs_col = normalize(input_matrix.T.dot(probs_row))
                 else:
                     n_labels = max(max(self.labels_row_), max(self.labels_col_)) + 1
-                    membership_row = get_membership(self.labels_row_, n_labels=n_labels)
-                    membership_col = get_membership(self.labels_col_, n_labels=n_labels)
-                if self.return_membership:
-                    self.membership_row_ = normalize(input_matrix.dot(membership_col))
-                    self.membership_col_ = normalize(input_matrix.T.dot(membership_row))
-                    self.membership_ = self.membership_row_
+                    probs_row = get_membership(self.labels_row_, n_labels=n_labels)
+                    probs_col = get_membership(self.labels_col_, n_labels=n_labels)
+                if self.return_probs:
+                    self.probs_row_ = normalize(input_matrix.dot(probs_col))
+                    self.probs_col_ = normalize(input_matrix.T.dot(probs_row))
+                    self.probs_ = self.probs_row_
                 if self.return_aggregate:
-                    aggregate_ = sparse.csr_matrix(membership_row.T.dot(input_matrix))
-                    aggregate_ = aggregate_.dot(membership_col)
+                    aggregate_ = sparse.csr_matrix(probs_row.T.dot(input_matrix))
+                    aggregate_ = aggregate_.dot(probs_col)
                     self.aggregate_ = aggregate_
 
         return self

sknetwork/clustering/kcenters.py

@@ -0,0 +1,253 @@
+"""
+Created in March 2024
+@author: Laurène David <laurene.david@ip-paris.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.clustering import BaseClustering
+from sknetwork.ranking import PageRank
+from sknetwork.clustering import get_modularity
+from sknetwork.classification.pagerank import PageRankClassifier
+from sknetwork.utils.format import get_adjacency, directed2undirected
+
+
+class KCenters(BaseClustering):
+    """K-center clustering algorithm. The center of each cluster is obtained by the PageRank algorithm.
+
+    Parameters
+    ----------
+    n_clusters : int
+        Number of clusters.
+    directed : bool, default False
+        If ``True``, the graph is considered directed.
+    center_position : str, default "row"
+        Force centers to correspond to the nodes on the rows or columns of the biadjacency matrix.
+        Can be ``row``, ``col`` or ``both``. Only considered for bipartite graphs.
+    n_init : int, default 5
+        Number of reruns of the k-centers algorithm with different centers.
+        The run that produce the best modularity is chosen as the final result.
+    max_iter : int, default 20
+        Maximum number of iterations of the k-centers algorithm for a single run.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_nodes,)
+        Label of each node.
+    labels_row_, labels_col_ : np.ndarray
+        Labels of rows and columns, for bipartite graphs.
+    centers_ : np.ndarray, shape (n_nodes,)
+        Cluster centers.
+    centers_row_, centers_col_ : np.ndarray
+        Cluster centers of rows and columns, for bipartite graphs.
+
+    Example
+    -------
+    >>> from sknetwork.clustering import KCenters
+    >>> from sknetwork.data import karate_club
+    >>> kcenters = KCenters(n_clusters=2)
+    >>> adjacency = karate_club()
+    >>> labels = kcenters.fit_predict(adjacency)
+    >>> len(set(labels))
+    2
+
+    """
+    def __init__(self, n_clusters: int, directed: bool = False, center_position: str = "row", n_init: int = 5,
+                 max_iter: int = 20):
+        super(BaseClustering, self).__init__()
+        self.n_clusters = n_clusters
+        self.directed = directed
+        self.bipartite = None
+        self.center_position = center_position
+        self.n_init = n_init
+        self.max_iter = max_iter
+        self.labels_ = None
+        self.centers_ = None
+        self.centers_row_ = None
+        self.centers_col_ = None
+
+    def _compute_mask_centers(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]):
+        """Generate mask to filter nodes that can be cluster centers.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+
+        Return
+        ------
+        mask : np.array, shape (n_nodes,)
+            Mask for possible cluster centers.
+
+        """
+        n_row, n_col = input_matrix.shape
+        if self.bipartite:
+            n_nodes = n_row + n_col
+            mask = np.zeros(n_nodes, dtype=bool)
+            if self.center_position == "row":
+                mask[:n_row] = True
+            elif self.center_position == "col":
+                mask[n_row:] = True
+            elif self.center_position == "both":
+                mask[:] = True
+            else:
+                raise ValueError('Unknown center position')
+        else:
+            mask = np.ones(n_row, dtype=bool)
+
+        return mask
+
+    @staticmethod
+    def _init_centers(adjacency: Union[sparse.csr_matrix, np.ndarray], mask: np.ndarray, n_clusters: int):
+        """
+        Kcenters++ initialization to select cluster centers.
+        This algorithm is an adaptation of the Kmeans++ algorithm to graphs.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph.
+        mask :
+            Initial mask for allowed positions of centers.
+        n_clusters : int
+            Number of centers to initialize.
+
+        Returns
+        ---------
+        centers : np.array, shape (n_clusters,)
+            Initial cluster centers.
+        """
+        mask = mask.copy()
+        n_nodes = adjacency.shape[0]
+        nodes = np.arange(n_nodes)
+        centers = []
+
+        # Choose the first center uniformly at random
+        center = np.random.choice(nodes[mask])
+        mask[center] = 0
+        centers.append(center)
+
+        pagerank = PageRank()
+        weights = {center: 1}
+
+        for k in range(n_clusters - 1):
+            # select nodes that are far from existing centers
+            ppr_scores = pagerank.fit_predict(adjacency, weights)
+            ppr_scores = ppr_scores[mask]
+
+            if min(ppr_scores) == 0:
+                center = np.random.choice(nodes[mask][ppr_scores == 0])
+            else:
+                probs = 1 / ppr_scores
+                probs = probs / np.sum(probs)
+                center = np.random.choice(nodes[mask], p=probs)
+
+            mask[center] = 0
+            centers.append(center)
+            weights.update({center: 1})
+
+        centers = np.array(centers)
+        return centers
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) -> "KCenters":
+        """Compute the clustering of the graph by k-centers.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite :
+            If ``True``, force the input matrix to be considered as a biadjacency matrix even if square.
+
+        Returns
+        -------
+        self : :class:`KCenters`
+        """
+
+        if self.n_clusters < 2:
+            raise ValueError("The number of clusters must be at least 2.")
+
+        if self.n_init < 1:
+            raise ValueError("The n_init parameter must be at least 1.")
+
+        if self.directed:
+            input_matrix = directed2undirected(input_matrix)
+
+        adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+        n_row = input_matrix.shape[0]
+        n_nodes = adjacency.shape[0]
+        nodes = np.arange(n_nodes)
+
+        mask = self._compute_mask_centers(input_matrix)
+        if self.n_clusters > np.sum(mask):
+            raise ValueError("The number of clusters is to high. This might be due to the center_position parameter.")
+
+        pagerank_clf = PageRankClassifier()
+        pagerank = PageRank()
+
+        labels_ = []
+        centers_ = []
+        modularity_ = []
+
+        # Restarts
+        for i in range(self.n_init):
+
+            # Initialization
+            centers = self._init_centers(adjacency, mask, self.n_clusters)
+            prev_centers = None
+            labels = None
+            n_iter = 0
+
+            while not np.equal(prev_centers, centers).all() and (n_iter < self.max_iter):
+
+                # Assign nodes to centers
+                labels_center = {center: label for label, center in enumerate(centers)}
+                labels = pagerank_clf.fit_predict(adjacency, labels_center)
+
+                # Find new centers
+                prev_centers = centers.copy()
+                new_centers = []
+
+                for label in np.unique(labels):
+                    mask_cluster = labels == label
+                    mask_cluster &= mask
+                    scores = pagerank.fit_predict(adjacency, weights=mask_cluster)
+                    scores[~mask_cluster] = 0
+                    new_centers.append(nodes[np.argmax(scores)])
+
+                n_iter += 1
+
+            # Store results
+            if self.bipartite:
+                labels_row = labels[:n_row]
+                labels_col = labels[n_row:]
+                modularity = get_modularity(input_matrix, labels_row, labels_col)
+            else:
+                modularity = get_modularity(adjacency, labels)
+
+            labels_.append(labels)
+            centers_.append(centers)
+            modularity_.append(modularity)
+
+        # Select restart with the highest modularity
+        idx_max = np.argmax(modularity_)
+        self.labels_ = np.array(labels_[idx_max])
+        self.centers_ = np.array(centers_[idx_max])
+
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+            # Define centers based on center position
+            if self.center_position == "row":
+                self.centers_row_ = self.centers_
+            elif self.center_position == "col":
+                self.centers_col_ = self.centers_ - n_row
+            else:
+                self.centers_row_ = self.centers_[self.centers_ < n_row]
+                self.centers_col_ = self.centers_[~np.isin(self.centers_, self.centers_row_)] - n_row
+
+        return self

sknetwork/clustering/leiden.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2024
+@author: Thomas Bonald <bonald@enst.fr>
+@author: Ahmed Zaiou <ahmed.zaiou@capgemini.com>
+"""
+from typing import Union, Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.clustering import Louvain
+from sknetwork.clustering.louvain_core import optimize_core
+from sknetwork.clustering.leiden_core import optimize_refine_core
+from sknetwork.utils.membership import get_membership
+from sknetwork.utils.check import check_random_state
+from sknetwork.log import Log
+
+
+class Leiden(Louvain):
+    """Leiden algorithm for clustering graphs by maximization of modularity.
+    Compared to the Louvain algorithm, the partition is refined before each aggregation.
+
+    For bipartite graphs, the algorithm maximizes Barber's modularity by default.
+
+    Parameters
+    ----------
+    resolution :
+        Resolution parameter.
+    modularity : str
+        Type of modularity to maximize. Can be ``'Dugue'``, ``'Newman'`` or ``'Potts'`` (default = ``'dugue'``).
+    tol_optimization :
+        Minimum increase in modularity to enter a new optimization pass in the local search.
+    tol_aggregation :
+        Minimum increase in modularity to enter a new aggregation pass.
+    n_aggregations :
+        Maximum number of aggregations.
+        A negative value is interpreted as no limit.
+    shuffle_nodes :
+        Enables node shuffling before optimization.
+    sort_clusters :
+        If ``True``, sort labels in decreasing order of cluster size.
+    return_probs :
+        If ``True``, return the probability distribution over clusters (soft clustering).
+    return_aggregate :
+        If ``True``, return the adjacency matrix of the graph between clusters.
+    random_state :
+        Random number generator or random seed. If None, numpy.random is used.
+    verbose :
+        Verbose mode.
+
+    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 Leiden
+    >>> from sknetwork.data import karate_club
+    >>> leiden = Leiden()
+    >>> adjacency = karate_club()
+    >>> labels = leiden.fit_predict(adjacency)
+    >>> len(set(labels))
+    4
+
+    References
+    ----------
+    * Traag, V. A., Waltman, L., & Van Eck, N. J. (2019).
+     `From Louvain to Leiden: guaranteeing well-connected communities`, Scientific reports.
+    """
+
+    def __init__(self, resolution: float = 1, modularity: str = 'dugue', tol_optimization: float = 1e-3,
+                 tol_aggregation: float = 1e-3, n_aggregations: int = -1, shuffle_nodes: bool = False,
+                 sort_clusters: bool = True, return_probs: bool = True, return_aggregate: bool = True,
+                 random_state: Optional[Union[np.random.RandomState, int]] = None, verbose: bool = False):
+        super(Leiden, self).__init__(sort_clusters=sort_clusters, return_probs=return_probs,
+                                     return_aggregate=return_aggregate)
+        Log.__init__(self, verbose)
+
+        self.labels_ = None
+        self.resolution = resolution
+        self.modularity = modularity.lower()
+        self.tol_optimization = tol_optimization
+        self.tol_aggregation = tol_aggregation
+        self.n_aggregations = n_aggregations
+        self.shuffle_nodes = shuffle_nodes
+        self.random_state = check_random_state(random_state)
+        self.bipartite = None
+
+    def _optimize(self, labels, adjacency, out_weights, in_weights):
+        """One optimization pass of the Leiden algorithm.
+
+        Parameters
+        ----------
+        labels :
+            Labels of nodes.
+        adjacency :
+            Adjacency matrix.
+        out_weights :
+            Out-weights of nodes.
+        in_weights :
+            In-weights of nodes
+
+        Returns
+        -------
+        labels :
+            Labels of nodes after optimization.
+        increase :
+            Gain in modularity after optimization.
+        """
+        indices = adjacency.indices
+        indptr = adjacency.indptr
+        data = adjacency.data.astype(np.float32)
+        out_weights = out_weights.astype(np.float32)
+        in_weights = in_weights.astype(np.float32)
+        membership = get_membership(labels)
+        out_cluster_weights = membership.T.dot(out_weights)
+        in_cluster_weights = membership.T.dot(in_weights)
+        cluster_weights = np.zeros_like(out_cluster_weights).astype(np.float32)
+        labels = labels.astype(np.int32)
+        self_loops = adjacency.diagonal().astype(np.float32)
+        return optimize_core(labels, indices, indptr, data, out_weights, in_weights, out_cluster_weights,
+                             in_cluster_weights, cluster_weights, self_loops, self.resolution, self.tol_optimization)
+
+    def _optimize_refine(self, labels, labels_refined, adjacency, out_weights, in_weights):
+        """Get the refined partition optimizing modularity.
+
+        Parameters
+        ----------
+        labels :
+            Labels of nodes.
+        labels_refined :
+            Refined labels of nodes.
+        adjacency :
+            Adjacency matrix.
+        out_weights :
+            Out-weights of nodes.
+        in_weights :
+            In-weights of nodes
+
+        Returns
+        -------
+        labels_refined :
+            Refined labels of nodes.
+        """
+        indices = adjacency.indices
+        indptr = adjacency.indptr
+        data = adjacency.data.astype(np.float32)
+        out_weights = out_weights.astype(np.float32)
+        in_weights = in_weights.astype(np.float32)
+        membership = get_membership(labels_refined)
+        out_cluster_weights = membership.T.dot(out_weights)
+        in_cluster_weights = membership.T.dot(in_weights)
+        cluster_weights = np.zeros_like(out_cluster_weights).astype(np.float32)
+        self_loops = adjacency.diagonal().astype(np.float32)
+        labels = labels.astype(np.int32)
+        labels_refined = labels_refined.astype(np.int32)
+        return optimize_refine_core(labels, labels_refined, indices, indptr, data, out_weights, in_weights,
+                                    out_cluster_weights, in_cluster_weights, cluster_weights, self_loops,
+                                    self.resolution)
+
+    @staticmethod
+    def _aggregate_refine(labels, labels_refined, adjacency, out_weights, in_weights):
+        """Aggregate nodes according to refined labels.
+
+        Parameters
+        ----------
+        labels :
+            Labels of nodes.
+        labels_refined :
+            Refined labels of nodes.
+        adjacency :
+            Adjacency matrix.
+        out_weights :
+            Out-weights of nodes.
+        in_weights :
+            In-weights of nodes.
+
+        Returns
+        -------
+        Aggregate graph (labels, adjacency matrix, out-weights, in-weights).
+        """
+        membership = get_membership(labels)
+        membership_refined = get_membership(labels_refined)
+        adjacency_ = membership_refined.T.tocsr().dot(adjacency.dot(membership_refined))
+        out_weights_ = membership_refined.T.dot(out_weights)
+        in_weights_ = membership_refined.T.dot(in_weights)
+        labels_ = membership_refined.T.tocsr().dot(membership).indices
+        return labels_, adjacency_, out_weights_, in_weights_
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) -> 'Leiden':
+        """Fit algorithm to data.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite :
+            If ``True``, force the input matrix to be considered as a biadjacency matrix even if square.
+
+        Returns
+        -------
+        self : :class:`Leiden`
+        """
+        adjacency, out_weights, in_weights, membership, index = self._pre_processing(input_matrix, force_bipartite)
+        n = adjacency.shape[0]
+        labels = np.arange(n)
+        count = 0
+        stop = False
+        while not stop:
+            count += 1
+            labels, increase = self._optimize(labels, adjacency, out_weights, in_weights)
+            _, labels = np.unique(labels, return_inverse=True)
+            labels_original = labels.copy()
+            labels_refined = np.arange(len(labels))
+            labels_refined = self._optimize_refine(labels, labels_refined, adjacency, out_weights, in_weights)
+            _, labels_refined = np.unique(labels_refined, return_inverse=True)
+            labels, adjacency, out_weights, in_weights = self._aggregate_refine(labels, labels_refined, adjacency,
+                                                                                out_weights, in_weights)
+            n = adjacency.shape[0]
+            stop = n == 1
+            stop |= increase <= self.tol_aggregation
+            stop |= count == self.n_aggregations
+            if stop:
+                membership = membership.dot(get_membership(labels_original))
+            else:
+                membership = membership.dot(get_membership(labels_refined))
+            self.print_log("Aggregation:", count, " Clusters:", n, " Increase:", increase)
+
+        self._post_processing(input_matrix, membership, index)
+        return self