scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

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()
+        seeds = {0: 0, 1: 1}
+
+        ref = PageRankClassifier(solver='piteration').fit_predict(adjacency, seeds)
+        for solver in ['lanczos', 'bicgstab']:
+            labels = PageRankClassifier(solver=solver).fit_predict(adjacency, seeds)
+            self.assertTrue((ref == labels).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]
+            seeds = {0: 0, 1: 1}
+            propagation = Propagation(n_iter=3, weighted=False)
+            labels = propagation.fit_predict(adjacency, seeds)
+            self.assertEqual(labels.shape, (n,))
+
+            for order in ['random', 'decreasing', 'increasing']:
+                propagation = Propagation(node_order=order)
+                labels = propagation.fit_predict(adjacency, seeds)
+                self.assertEqual(labels.shape, (n,))

sknetwork/classification/vote.pyx

@@ -0,0 +1,58 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on April, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from libcpp.set cimport set
+from libcpp.vector cimport vector
+
+cimport cython
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def vote_update(int[:] indptr, int[:] indices, float[:] data, int[:] labels, int[:] index):
+    """One pass of label updates over the graph by majority vote among neighbors."""
+    cdef int i
+    cdef int ii
+    cdef int j
+    cdef int jj
+    cdef int n_indices = index.shape[0]
+    cdef int label
+    cdef int label_neigh_size
+    cdef float best_score
+
+    cdef vector[int] labels_neigh
+    cdef vector[float] votes_neigh, votes
+    cdef set[int] labels_unique = ()
+
+    cdef int n = labels.shape[0]
+    for i in range(n):
+        votes.push_back(0)
+
+    for ii in range(n_indices):
+        i = index[ii]
+        labels_neigh.clear()
+        for j in range(indptr[i], indptr[i + 1]):
+            jj = indices[j]
+            labels_neigh.push_back(labels[jj])
+            votes_neigh.push_back(data[jj])
+
+        labels_unique.clear()
+        label_neigh_size = labels_neigh.size()
+        for jj in range(label_neigh_size):
+            label = labels_neigh[jj]
+            if label >= 0:
+                labels_unique.insert(label)
+                votes[label] += votes_neigh[jj]
+
+        best_score = -1
+        for label in labels_unique:
+            if votes[label] > best_score:
+                labels[i] = label
+                best_score = votes[label]
+            votes[label] = 0
+    return labels

sknetwork/clustering/__init__.py

@@ -0,0 +1,7 @@
+"""clustering module"""
+from sknetwork.clustering.base import BaseClustering
+from sknetwork.clustering.kmeans import KMeans
+from sknetwork.clustering.louvain import Louvain
+from sknetwork.clustering.metrics import get_modularity
+from sknetwork.clustering.postprocess import reindex_labels, aggregate_graph
+from sknetwork.clustering.propagation_clustering import PropagationClustering

sknetwork/clustering/base.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Nov, 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+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.utils.membership import get_membership
+
+
+class BaseClustering(Algorithm, ABC):
+    """Base class for clustering algorithms.
+
+    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).
+    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):
+        self.sort_clusters = sort_clusters
+        self.return_membership = return_membership
+        self.return_aggregate = return_aggregate
+        self._init_vars()
+
+    def fit_transform(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the labels. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        labels : np.ndarray
+            Labels.
+        """
+        self.fit(*args, **kwargs)
+        return self.labels_
+
+    def _init_vars(self):
+        """Init variables."""
+        self.labels_ = None
+        self.labels_row_ = None
+        self.labels_col_ = None
+        self.membership_ = None
+        self.membership_row_ = None
+        self.membership_col_ = None
+        self.aggregate_ = None
+        self.bipartite = None
+        return self
+
+    def _split_vars(self, shape):
+        """Split labels_ into labels_row_ and labels_col_"""
+        n_row = shape[0]
+        self.labels_row_ = self.labels_[:n_row]
+        self.labels_col_ = self.labels_[n_row:]
+        self.labels_ = self.labels_row_
+        return self
+
+    def _secondary_outputs(self, input_matrix: sparse.csr_matrix):
+        """Compute different variables from labels_."""
+        if self.return_membership 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))
+                if self.return_aggregate:
+                    self.aggregate_ = sparse.csr_matrix(membership.T.dot(input_matrix.dot(membership)))
+            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))
+                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_
+                if self.return_aggregate:
+                    aggregate_ = sparse.csr_matrix(membership_row.T.dot(input_matrix))
+                    aggregate_ = aggregate_.dot(membership_col)
+                    self.aggregate_ = aggregate_
+
+        return self

sknetwork/clustering/kmeans.py

@@ -0,0 +1,142 @@
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Union, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.clustering.base import BaseClustering
+from sknetwork.clustering.postprocess import reindex_labels
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.embedding.spectral import Spectral
+from sknetwork.utils.format import is_square
+from sknetwork.utils.check import check_n_clusters, check_format
+from sknetwork.utils.kmeans import KMeansDense
+
+
+def get_embedding(input_matrix: Union[sparse.csr_matrix, np.ndarray], method: BaseEmbedding,
+                  co_embedding: bool = False) -> Tuple[np.ndarray, bool]:
+    """Return the embedding of the input_matrix.
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix of biadjacency matrix of the graph.
+    method :
+        Embedding method.
+    co_embedding : bool
+        If ``True``, co-embedding of rows and columns.
+        Otherwise, do it only if the input matrix is not square or not symmetric with ``allow_directed=False``.
+    """
+    bipartite = (not is_square(input_matrix)) or co_embedding
+    if co_embedding:
+        try:
+            method.fit(input_matrix, force_bipartite=True)
+        except:
+            method.fit(input_matrix)
+        embedding = np.vstack((method.embedding_row_, method.embedding_col_))
+    else:
+        method.fit(input_matrix)
+        embedding = method.embedding_
+    return embedding, bipartite
+
+
+class KMeans(BaseClustering):
+    """K-means clustering applied in the embedding space.
+
+    Parameters
+    ----------
+    n_clusters :
+        Number of desired clusters (default = 2).
+    embedding_method :
+        Embedding method (default = Spectral embedding in dimension 10).
+    co_cluster :
+        If ``True``, co-cluster rows and columns, considered as different nodes (default = ``False``).
+    sort_clusters :
+            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 :
+            If ``True``, return the adjacency matrix of the graph 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).
+    aggregate_ : sparse.csr_matrix
+        Aggregate adjacency matrix or biadjacency matrix between clusters.
+
+    Example
+    -------
+    >>> from sknetwork.clustering import KMeans
+    >>> from sknetwork.data import karate_club
+    >>> kmeans = KMeans(n_clusters=3)
+    >>> adjacency = karate_club()
+    >>> labels = kmeans.fit_transform(adjacency)
+    >>> len(set(labels))
+    3
+    """
+    def __init__(self, n_clusters: int = 2, embedding_method: BaseEmbedding = Spectral(10), co_cluster: bool = False,
+                 sort_clusters: bool = True, return_membership: bool = True, return_aggregate: bool = True):
+        super(KMeans, self).__init__(sort_clusters=sort_clusters, return_membership=return_membership,
+                                     return_aggregate=return_aggregate)
+        self.n_clusters = n_clusters
+        self.embedding_method = embedding_method
+        self.co_cluster = co_cluster
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> 'KMeans':
+        """Apply embedding method followed by K-means.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+
+        Returns
+        -------
+        self: :class:`KMeans`
+        """
+        self._init_vars()
+
+        # input
+        input_matrix = check_format(input_matrix)
+        if self.co_cluster:
+            check_n_clusters(self.n_clusters, np.sum(input_matrix.shape))
+        else:
+            check_n_clusters(self.n_clusters, input_matrix.shape[0])
+
+        # embedding
+        embedding, self.bipartite = get_embedding(input_matrix, self.embedding_method, self.co_cluster)
+
+        # clustering
+        kmeans = KMeansDense(self.n_clusters)
+        kmeans.fit(embedding)
+
+        # sort
+        if self.sort_clusters:
+            labels = reindex_labels(kmeans.labels_)
+        else:
+            labels = kmeans.labels_
+
+        # output
+        self.labels_ = labels
+        if self.co_cluster:
+            self._split_vars(input_matrix.shape)
+        self._secondary_outputs(input_matrix)
+
+        return self

sknetwork/clustering/louvain.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2018
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Union, Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.clustering.base import BaseClustering
+from sknetwork.clustering.louvain_core import fit_core
+from sknetwork.clustering.postprocess import reindex_labels
+from sknetwork.utils.check import check_random_state, get_probs
+from sknetwork.utils.format import check_format, get_adjacency, directed2undirected
+from sknetwork.utils.membership import get_membership
+from sknetwork.utils.verbose import VerboseMixin
+
+
+class Louvain(BaseClustering, VerboseMixin):
+    """Louvain algorithm for clustering graphs by maximization of modularity.
+
+    For bipartite graphs, the algorithm maximizes Barber's modularity by default.
+
+    Parameters
+    ----------
+    resolution :
+        Resolution parameter.
+    modularity : str
+        Which objective function to maximize. Can be ``'Dugue'``, ``'Newman'`` or ``'Potts'`` (default = ``'dugue'``).
+    tol_optimization :
+        Minimum increase in the objective function to enter a new optimization pass.
+    tol_aggregation :
+        Minimum increase in the objective function 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_membership :
+        If ``True``, return the membership matrix of nodes to each cluster (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
+        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).
+    aggregate_ : sparse.csr_matrix
+        Aggregate adjacency matrix or biadjacency matrix between clusters.
+
+    Example
+    -------
+    >>> from sknetwork.clustering import Louvain
+    >>> from sknetwork.data import karate_club
+    >>> louvain = Louvain()
+    >>> adjacency = karate_club()
+    >>> labels = louvain.fit_transform(adjacency)
+    >>> len(set(labels))
+    4
+
+    References
+    ----------
+    * Blondel, V. D., Guillaume, J. L., Lambiotte, R., & Lefebvre, E. (2008).
+      `Fast unfolding of communities in large networks.
+      <https://arxiv.org/abs/0803.0476>`_
+      Journal of statistical mechanics: theory and experiment, 2008.
+
+    * Dugué, N., & Perez, A. (2015).
+      `Directed Louvain: maximizing modularity in directed networks
+      <https://hal.archives-ouvertes.fr/hal-01231784/document>`_
+      (Doctoral dissertation, Université d'Orléans).
+
+    * Barber, M. J. (2007).
+      `Modularity and community detection in bipartite networks
+      <https://arxiv.org/pdf/0707.1616>`_
+      Physical Review E, 76(6).
+    """
+    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_membership: bool = True, return_aggregate: bool = True,
+                 random_state: Optional[Union[np.random.RandomState, int]] = None, verbose: bool = False):
+        super(Louvain, self).__init__(sort_clusters=sort_clusters, return_membership=return_membership,
+                                      return_aggregate=return_aggregate)
+        VerboseMixin.__init__(self, verbose)
+
+        self.labels_ = None
+        self.resolution = resolution
+        self.modularity = modularity.lower()
+        self.tol = 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, adjacency_norm, probs_ou, probs_in):
+        """One local optimization pass of the Louvain algorithm
+
+        Parameters
+        ----------
+        adjacency_norm :
+            the norm of the adjacency
+        probs_ou :
+            the array of degrees of the adjacency
+        probs_in :
+            the array of degrees of the transpose of the adjacency
+
+        Returns
+        -------
+        labels :
+            the communities of each node after optimization
+        pass_increase :
+            the increase in modularity gained after optimization
+        """
+        node_probs_in = probs_in.astype(np.float32)
+        node_probs_ou = probs_ou.astype(np.float32)
+
+        adjacency = 0.5 * directed2undirected(adjacency_norm)
+
+        self_loops = adjacency.diagonal().astype(np.float32)
+
+        indptr: np.ndarray = adjacency.indptr
+        indices: np.ndarray = adjacency.indices
+        data: np.ndarray = adjacency.data.astype(np.float32)
+
+        return fit_core(self.resolution, self.tol, node_probs_ou, node_probs_in, self_loops, data, indices, indptr)
+
+    @staticmethod
+    def _aggregate(adjacency_norm, probs_out, probs_in, membership: Union[sparse.csr_matrix, np.ndarray]):
+        """Aggregate nodes belonging to the same cluster.
+
+        Parameters
+        ----------
+        adjacency_norm :
+            the norm of the adjacency
+        probs_out :
+            the array of degrees of the adjacency
+        probs_in :
+            the array of degrees of the transpose of the adjacency
+        membership :
+            membership matrix (rows).
+
+        Returns
+        -------
+        Aggregate graph.
+        """
+        adjacency_norm = (membership.T.dot(adjacency_norm.dot(membership))).tocsr()
+        probs_in = np.array(membership.T.dot(probs_in).T)
+        probs_out = np.array(membership.T.dot(probs_out).T)
+        return adjacency_norm, probs_out, probs_in
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) -> 'Louvain':
+        """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:`Louvain`
+        """
+        self._init_vars()
+        input_matrix = check_format(input_matrix)
+        if self.modularity == 'dugue':
+            adjacency, self.bipartite = get_adjacency(input_matrix, force_directed=True,
+                                                      force_bipartite=force_bipartite)
+        else:
+            adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+
+        n = adjacency.shape[0]
+
+        index = np.arange(n)
+        if self.shuffle_nodes:
+            index = self.random_state.permutation(index)
+            adjacency = adjacency[index][:, index]
+
+        if self.modularity == 'potts':
+            probs_out = get_probs('uniform', adjacency)
+            probs_in = probs_out.copy()
+        elif self.modularity == 'newman':
+            probs_out = get_probs('degree', adjacency)
+            probs_in = probs_out.copy()
+        elif self.modularity == 'dugue':
+            probs_out = get_probs('degree', adjacency)
+            probs_in = get_probs('degree', adjacency.T)
+        else:
+            raise ValueError('Unknown modularity function.')
+
+        adjacency_cluster = adjacency / adjacency.data.sum()
+
+        membership = sparse.identity(n, format='csr')
+        increase = True
+        count_aggregations = 0
+        self.log.print("Starting with", n, "nodes.")
+        while increase:
+            count_aggregations += 1
+
+            labels_cluster, pass_increase = self._optimize(adjacency_cluster, probs_out, probs_in)
+            _, labels_cluster = np.unique(labels_cluster, return_inverse=True)
+
+            if pass_increase <= self.tol_aggregation:
+                increase = False
+            else:
+                membership_cluster = get_membership(labels_cluster)
+                membership = membership.dot(membership_cluster)
+                adjacency_cluster, probs_out, probs_in = self._aggregate(adjacency_cluster, probs_out, probs_in,
+                                                                         membership_cluster)
+
+                n = adjacency_cluster.shape[0]
+                if n == 1:
+                    break
+            self.log.print("Aggregation", count_aggregations, "completed with", n, "clusters and ",
+                           pass_increase, "increment.")
+            if count_aggregations == self.n_aggregations:
+                break
+
+        if self.sort_clusters:
+            labels = reindex_labels(membership.indices)
+        else:
+            labels = membership.indices
+        if self.shuffle_nodes:
+            reverse = np.empty(index.size, index.dtype)
+            reverse[index] = np.arange(index.size)
+            labels = labels[reverse]
+
+        self.labels_ = labels
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+        self._secondary_outputs(input_matrix)
+
+        return self