scikit-network 0.33.0__cp312-cp312-macosx_10_9_x86_64.whl

sknetwork/classification/diffusion.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2022
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.classification.base import BaseClassifier
+from sknetwork.path.distances import get_distances
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.utils.format import get_adjacency_values
+from sknetwork.utils.membership import get_membership
+from sknetwork.utils.neighbors import get_degrees
+
+
+class DiffusionClassifier(BaseClassifier):
+    """Node classification by heat diffusion.
+
+    For each label, the temperature of a node corresponds to its probability to have this label.
+
+    Parameters
+    ----------
+    n_iter : int
+        Number of iterations of the diffusion (discrete time).
+    centering : bool
+        If ``True``, center the temperature of each label to its mean before classification (default).
+    scale : float
+        Multiplicative factor applied to tempreatures before softmax (default = 5).
+        Used only when centering is ``True``.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.data import karate_club
+    >>> diffusion = DiffusionClassifier()
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels_true = graph.labels
+    >>> labels = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = diffusion.fit_predict(adjacency, labels)
+    >>> round(np.mean(labels_pred == labels_true), 2)
+    0.97
+
+    References
+    ----------
+    Zhu, X., Lafferty, J., & Rosenfeld, R. (2005). `Semi-supervised learning with graphs`
+    (Doctoral dissertation, Carnegie Mellon University, language technologies institute, school of computer science).
+    """
+    def __init__(self, n_iter: int = 10, centering: bool = True, scale: float = 5):
+        super(DiffusionClassifier, self).__init__()
+
+        if n_iter <= 0:
+            raise ValueError('The number of iterations must be positive.')
+        else:
+            self.n_iter = n_iter
+        self.centering = centering
+        self.scale = scale
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
+            labels: Optional[Union[dict, list, np.ndarray]] = None,
+            labels_row: Optional[Union[dict, list, np.ndarray]] = None,
+            labels_col: Optional[Union[dict, list, np.ndarray]] = None, force_bipartite: bool = False) \
+            -> 'DiffusionClassifier':
+        """Compute the solution to the Dirichlet problem (temperatures at equilibrium).
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+            Adjacency matrix or biadjacency matrix of the graph.
+        labels : dict, np.ndarray
+            Known labels (dictionary or vector of int). Negative values ignored.
+        labels_row : dict, np.ndarray
+            Labels of rows for bipartite graphs. Negative values ignored.
+        labels_col : dict, np.ndarray
+            Labels of columns for bipartite graphs. Negative values ignored.
+        force_bipartite : bool
+            If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
+
+        Returns
+        -------
+        self: :class:`DiffusionClassifier`
+        """
+        adjacency, values, self.bipartite = get_adjacency_values(input_matrix, force_bipartite=force_bipartite,
+                                                                 values=labels,
+                                                                 values_row=labels_row,
+                                                                 values_col=labels_col)
+        labels = values.astype(int)
+        if (labels < 0).all():
+            raise ValueError('At least one node must be given a non-negative label.')
+        labels_reindex = labels.copy()
+        labels_unique, inverse = np.unique(labels[labels >= 0], return_inverse=True)
+        labels_reindex[labels >= 0] = inverse
+        temperatures = get_membership(labels_reindex).toarray()
+        temperatures_seeds = temperatures[labels >= 0]
+        temperatures[labels < 0] = 0.5
+        diffusion = normalize(adjacency)
+        for i in range(self.n_iter):
+            temperatures = diffusion.dot(temperatures)
+            temperatures[labels >= 0] = temperatures_seeds
+        if self.centering:
+            temperatures -= temperatures.mean(axis=0)
+        labels_ = labels_unique[temperatures.argmax(axis=1)]
+
+        # softmax
+        if self.centering:
+            temperatures = np.exp(self.scale * temperatures)
+
+        # set label -1 to nodes not reached by diffusion
+        distances = get_distances(adjacency, source=np.flatnonzero(labels >= 0))
+        labels_[distances < 0] = -1
+        temperatures[distances < 0] = 0
+
+        self.labels_ = labels_
+        self.probs_ = sparse.csr_matrix(normalize(temperatures))
+        self._split_vars(input_matrix.shape)
+
+        return self

sknetwork/classification/knn.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.classification.base import BaseClassifier
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg.normalizer import get_norms, normalize
+from sknetwork.utils.check import check_n_neighbors
+from sknetwork.utils.format import get_adjacency_values
+
+
+class NNClassifier(BaseClassifier):
+    """Node classification by K-nearest neighbors in the embedding space.
+
+    Parameters
+    ----------
+    n_neighbors : int
+        Number of nearest neighbors .
+    embedding_method : :class:`BaseEmbedding`
+        Embedding method used to represent nodes in vector space.
+        If ``None`` (default), use identity.
+    normalize : bool
+        If ``True``, apply normalization so that all vectors have norm 1 in the embedding space.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
+
+    Example
+    -------
+    >>> from sknetwork.classification import NNClassifier
+    >>> from sknetwork.data import karate_club
+    >>> classifier = NNClassifier(n_neighbors=1)
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels_true = graph.labels
+    >>> labels = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = classifier.fit_predict(adjacency, labels)
+    >>> round(np.mean(labels_pred == labels_true), 2)
+    0.82
+    """
+    def __init__(self, n_neighbors: int = 3, embedding_method: Optional[BaseEmbedding] = None, normalize: bool = True):
+        super(NNClassifier, self).__init__()
+        self.n_neighbors = n_neighbors
+        self.embedding_method = embedding_method
+        self.normalize = normalize
+
+    @staticmethod
+    def _instantiate_vars(labels: np.ndarray):
+        index_train = np.flatnonzero(labels >= 0)
+        index_test = np.flatnonzero(labels < 0)
+        return index_train, index_test
+
+    def _fit_core(self, embedding, labels, index_train, index_test):
+        n_neighbors = check_n_neighbors(self.n_neighbors, len(index_train))
+
+        norms_train = get_norms(embedding[index_train], p=2)
+        neighbors = []
+        for i in index_test:
+            vector = embedding[i]
+            if sparse.issparse(vector):
+                vector = vector.toarray().ravel()
+            distances = norms_train**2 - 2 * embedding[index_train].dot(vector) + np.sum(vector**2)
+            neighbors += list(index_train[np.argpartition(distances, n_neighbors)[:n_neighbors]])
+        labels_neighbor = labels[neighbors]
+
+        # membership matrix
+        row = list(np.repeat(index_test, n_neighbors))
+        col = list(labels_neighbor)
+        data = list(np.ones_like(labels_neighbor))
+
+        row += list(index_train)
+        col += list(labels[index_train])
+        data += list(np.ones_like(index_train))
+
+        probs = normalize(sparse.csr_matrix((data, (row, col)), shape=(len(labels), np.max(labels) + 1)))
+        labels = np.argmax(probs.toarray(), axis=1)
+
+        return probs, labels
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], labels: Union[np.ndarray, list, dict] = None,
+            labels_row: Union[np.ndarray, list, dict] = None,
+            labels_col: Union[np.ndarray, list, dict] = None) -> 'NNClassifier':
+        """Node classification by k-nearest neighbors in the embedding space.
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+            Adjacency matrix or biadjacency matrix of the graph.
+        labels : np.ndarray, dict
+            Known labels. Negative values ignored.
+        labels_row : np.ndarray, dict
+            Known labels of rows, for bipartite graphs.
+        labels_col : np.ndarray, dict
+            Known labels of columns, for bipartite graphs.
+
+        Returns
+        -------
+        self: :class:`KNN`
+        """
+        adjacency, labels, self.bipartite = get_adjacency_values(input_matrix, values=labels, values_row=labels_row,
+                                                                 values_col=labels_col)
+        labels = labels.astype(int)
+        index_seed, index_remain = self._instantiate_vars(labels)
+
+        if self.embedding_method is None:
+            embedding = adjacency
+        else:
+            embedding = self.embedding_method.fit_transform(adjacency)
+
+        if self.normalize:
+            embedding = normalize(embedding, p=2)
+
+        probs, labels = self._fit_core(embedding, labels, index_seed, index_remain)
+
+        self.labels_ = labels
+        self.probs_ = probs
+        self._split_vars(input_matrix.shape)
+
+        return self

sknetwork/classification/metrics.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from typing import Union, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import check_vector_format
+
+
+def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:
+    """Return the proportion of correctly labeled samples.
+    Negative labels ignored.
+
+    Parameters
+    ----------
+    labels_true : np.ndarray
+        True labels.
+    labels_pred : np.ndarray
+        Predicted labels
+
+    Returns
+    -------
+    accuracy : float
+        A score between 0 and 1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> labels_true = np.array([0, 0, 1, 1])
+    >>> labels_pred = np.array([0, 0, 0, 1])
+    >>> round(get_accuracy_score(labels_true, labels_pred), 2)
+    0.75
+    """
+    check_vector_format(labels_true, labels_pred)
+    mask = (labels_true >= 0) & (labels_pred >= 0)
+    if np.sum(mask):
+        return np.mean(labels_true[mask] == labels_pred[mask])
+    else:
+        raise ValueError('No sample with both true non-negative label and predicted non-negative label.')
+
+
+def get_confusion_matrix(labels_true: np.ndarray, labels_pred: np.ndarray) -> sparse.csr_matrix:
+    """Return the confusion matrix in sparse format (true labels on rows, predicted labels on columns).
+    Negative labels ignored.
+
+    Parameters
+    ----------
+    labels_true : np.ndarray
+        True labels.
+    labels_pred : np.ndarray
+        Predicted labels
+
+    Returns
+    -------
+    confusion matrix : sparse.csr_matrix
+        Confusion matrix.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> labels_true = np.array([0, 0, 1, 1])
+    >>> labels_pred = np.array([0, 0, 0, 1])
+    >>> get_confusion_matrix(labels_true, labels_pred).toarray()
+    array([[2, 0],
+           [1, 1]])
+    """
+    check_vector_format(labels_true, labels_pred)
+    mask = (labels_true >= 0) & (labels_pred >= 0)
+    if np.sum(mask):
+        n_labels = max(max(labels_true), max(labels_pred)) + 1
+        row = labels_true[mask]
+        col = labels_pred[mask]
+        data = np.ones(np.sum(mask), dtype=int)
+        return sparse.csr_matrix((data, (row, col)), shape=(n_labels, n_labels))
+    else:
+        raise ValueError('No sample with both true non-negative label and predicted non-negative label.')
+
+
+def get_f1_score(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \
+        -> Union[float, Tuple[float, float, float]]:
+    """Return the f1 score of binary classification.
+    Negative labels ignored.
+
+    Parameters
+    ----------
+    labels_true : np.ndarray
+        True labels.
+    labels_pred : np.ndarray
+        Predicted labels
+    return_precision_recall : bool
+        If ``True``, also return precision and recall.
+
+    Returns
+    -------
+    score, [precision, recall] : np.ndarray
+        F1 score (between 0 and 1). Optionally, also return precision and recall.
+    Examples
+    --------
+    >>> import numpy as np
+    >>> labels_true = np.array([0, 0, 1, 1])
+    >>> labels_pred = np.array([0, 0, 0, 1])
+    >>> round(get_f1_score(labels_true, labels_pred), 2)
+    0.67
+    """
+    values = set(labels_true[labels_true >= 0]) | set(labels_pred[labels_pred >= 0])
+    if values != {0, 1}:
+        raise ValueError('Labels must be binary. '
+                         'Check get_f1_scores or get_average_f1_score for multi-label classification.')
+    if return_precision_recall:
+        f1_scores, precisions, recalls = get_f1_scores(labels_true, labels_pred, True)
+        return f1_scores[1], precisions[1], recalls[1]
+    else:
+        f1_scores = get_f1_scores(labels_true, labels_pred, False)
+        return f1_scores[1]
+
+
+def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \
+        -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray, np.ndarray]]:
+    """Return the f1 scores of multi-label classification (one per label).
+    Negative labels ignored.
+
+    Parameters
+    ----------
+    labels_true : np.ndarray
+        True labels.
+    labels_pred : np.ndarray
+        Predicted labels
+    return_precision_recall : bool
+        If ``True``, also return precisions and recalls.
+
+    Returns
+    -------
+    scores, [precisions, recalls] : np.ndarray
+        F1 scores (between 0 and 1). Optionally, also return F1 precisions and recalls.
+    Examples
+    --------
+    >>> import numpy as np
+    >>> labels_true = np.array([0, 0, 1, 1])
+    >>> labels_pred = np.array([0, 0, 0, 1])
+    >>> np.round(get_f1_scores(labels_true, labels_pred), 2)
+    array([0.8 , 0.67])
+    """
+    confusion = get_confusion_matrix(labels_true, labels_pred)
+    n_labels = confusion.shape[0]
+    counts_correct = confusion.diagonal()
+    counts_true = confusion.dot(np.ones(n_labels))
+    counts_pred = confusion.T.dot(np.ones(n_labels))
+    mask = counts_true > 0
+    recalls = np.zeros(n_labels)
+    recalls[mask] = counts_correct[mask] / counts_true[mask]
+    precisions = np.zeros(n_labels)
+    mask = counts_pred > 0
+    precisions[mask] = counts_correct[mask] / counts_pred[mask]
+    f1_scores = np.zeros(n_labels)
+    mask = (precisions > 0) & (recalls > 0)
+    f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])
+    if return_precision_recall:
+        return f1_scores, precisions, recalls
+    else:
+        return f1_scores
+
+
+def get_average_f1_score(labels_true: np.ndarray, labels_pred: np.ndarray, average: str = 'macro') -> float:
+    """Return the average f1 score of multi-label classification.
+    Negative labels ignored.
+
+    Parameters
+    ----------
+    labels_true : np.ndarray
+        True labels.
+    labels_pred : np.ndarray
+        Predicted labels
+    average : str
+        Averaging method. Can be either ``'macro'`` (default), ``'micro'`` or ``'weighted'``.
+
+    Returns
+    -------
+    score : float
+        Average F1 score (between 0 and 1).
+    Examples
+    --------
+    >>> import numpy as np
+    >>> labels_true = np.array([0, 0, 1, 1])
+    >>> labels_pred = np.array([0, 0, 0, 1])
+    >>> round(get_average_f1_score(labels_true, labels_pred), 2)
+    0.73
+    """
+    if average == 'micro':
+        # micro averaging = accuracy
+        return get_accuracy_score(labels_true, labels_pred)
+    else:
+        f1_scores = get_f1_scores(labels_true, labels_pred)
+        if average == 'macro':
+            return np.mean(f1_scores)
+        elif average == 'weighted':
+            labels_unique, counts = np.unique(labels_true[labels_true >= 0], return_counts=True)
+            return np.sum(f1_scores[labels_unique] * counts) / np.sum(counts)
+        else:
+            raise ValueError('Check the ``average`` parameter.')

sknetwork/classification/pagerank.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Optional
+
+import numpy as np
+
+from sknetwork.classification.base_rank import RankClassifier
+from sknetwork.ranking.pagerank import PageRank
+
+
+class PageRankClassifier(RankClassifier):
+    """Node classification by multiple personalized PageRanks.
+
+    Parameters
+    ----------
+    damping_factor: float
+        Probability to continue the random walk.
+    solver : str
+        Which solver to use: 'piteration', 'diteration', 'bicgstab', 'lanczos'.
+    n_iter : int
+        Number of iterations for some solvers such as ``'piteration'`` or ``'diteration'``.
+    tol : float
+        Tolerance for the convergence of some solvers such as ``'bicgstab'`` or ``'lanczos'``.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
+
+    Example
+    -------
+    >>> from sknetwork.classification import PageRankClassifier
+    >>> from sknetwork.data import karate_club
+    >>> pagerank = PageRankClassifier()
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels_true = graph.labels
+    >>> labels = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = pagerank.fit_predict(adjacency, labels)
+    >>> np.round(np.mean(labels_pred == labels_true), 2)
+    0.97
+
+    References
+    ----------
+    Lin, F., & Cohen, W. W. (2010). `Semi-supervised classification of network data using very few labels.
+    <https://lti.cs.cmu.edu/sites/default/files/research/reports/2009/cmulti09017.pdf>`_
+    In IEEE International Conference on Advances in Social Networks Analysis and Mining.
+    """
+    def __init__(self, damping_factor: float = 0.85, solver: str = 'piteration', n_iter: int = 10, tol: float = 0.,
+                 n_jobs: Optional[int] = None, verbose: bool = False):
+        algorithm = PageRank(damping_factor, solver, n_iter, tol)
+        super(PageRankClassifier, self).__init__(algorithm, n_jobs, verbose)

sknetwork/classification/propagation.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in April 2020
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.classification.base import BaseClassifier
+from sknetwork.classification.vote import vote_update
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.utils.format import get_adjacency_values
+from sknetwork.utils.membership import get_membership
+
+
+class Propagation(BaseClassifier):
+    """Node classification by label propagation.
+
+    Parameters
+    ----------
+    n_iter : float
+        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 (in-) weight.
+        * ``'decreasing'``: node labels are updated by decreasing order of (in-) 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.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
+
+    Example
+    -------
+    >>> from sknetwork.classification import Propagation
+    >>> from sknetwork.data import karate_club
+    >>> propagation = Propagation()
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels_true = graph.labels
+    >>> labels = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = propagation.fit_predict(adjacency, labels)
+    >>> np.round(np.mean(labels_pred == labels_true), 2)
+    0.94
+
+    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: float = -1, node_order: str = None, weighted: bool = True):
+        super(Propagation, self).__init__()
+
+        if n_iter < 0:
+            self.n_iter = np.inf
+        else:
+            self.n_iter = n_iter
+        self.node_order = node_order
+        self.weighted = weighted
+
+    @staticmethod
+    def _instantiate_vars(labels: np.ndarray):
+        """Instantiate variables for label propagation."""
+        n = len(labels)
+        if len(set(labels)) == n:
+            index_seed = np.arange(n)
+            index_remain = np.arange(n)
+        else:
+            index_seed = np.argwhere(labels >= 0).ravel()
+            index_remain = np.argwhere(labels < 0).ravel()
+            labels = labels[index_seed]
+        return index_seed.astype(np.int32), index_remain.astype(np.int32), labels.astype(np.int32)
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], labels: Union[np.ndarray, list, dict] = None,
+            labels_row: Union[np.ndarray, list, dict] = None,
+            labels_col: Union[np.ndarray, list, dict] = None) -> 'Propagation':
+        """Node classification by label propagation.
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+            Adjacency matrix or biadjacency matrix of the graph.
+        labels : array, list or dict
+            Known labels. Negative values ignored.
+        labels_row : array, list or dict
+            Known labels of rows, for bipartite graphs.
+        labels_col : array, list or dict
+            Known labels of columns, for bipartite graphs.
+
+        Returns
+        -------
+        self: :class:`Propagation`
+        """
+        adjacency, seeds, self.bipartite = get_adjacency_values(input_matrix, values=labels, values_row=labels_row,
+                                                                values_col=labels_col, which='labels')
+        n = adjacency.shape[0]
+        index_seed, index_remain, labels_seed = self._instantiate_vars(seeds)
+
+        if self.node_order == 'random':
+            np.random.shuffle(index_remain)
+        elif self.node_order == 'decreasing':
+            index = np.argsort(-adjacency.T.dot(np.ones(n))).astype(np.int32)
+            index_remain = index[index_remain]
+        elif self.node_order == 'increasing':
+            index = np.argsort(adjacency.T.dot(np.ones(n))).astype(np.int32)
+            index_remain = index[index_remain]
+
+        labels = -np.ones(n, dtype=np.int32)
+        labels[index_seed] = labels_seed
+        labels_remain = np.zeros_like(index_remain, dtype=np.int32)
+
+        indptr = adjacency.indptr.astype(np.int32)
+        indices = adjacency.indices.astype(np.int32)
+        if self.weighted:
+            data = adjacency.data.astype(np.float32)
+        else:
+            data = np.ones(n, dtype=np.float32)
+
+        t = 0
+        while t < self.n_iter and not np.array_equal(labels_remain, labels[index_remain]):
+            t += 1
+            labels_remain = labels[index_remain].copy()
+            labels = np.asarray(vote_update(indptr, indices, data, labels, index_remain))
+
+        probs = get_membership(labels)
+        probs = normalize(adjacency.dot(probs))
+
+        self.labels_ = labels
+        self.probs_ = probs
+        self._split_vars(input_matrix.shape)
+
+        return self