scikit-network 0.33.4__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

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])
+    >>> float(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])
+    >>> float(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])
+    >>> float(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,58 @@
+#!/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_nodes,)
+        Labels of nodes.
+    probs\_ : sparse.csr_matrix, shape (n_nodes, n_labels)
+        Probability distribution over labels.
+
+    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)
+    >>> float(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,144 @@
+#!/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_nodes,)
+        Labels of nodes.
+    probs\_ : sparse.csr_matrix, shape (n_nodes, n_labels)
+        Probability distribution over labels.
+
+    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)
+    >>> float(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

sknetwork/classification/tests/__init__.py

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

sknetwork/classification/tests/test_API.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for classification API"""
+
+import unittest
+
+from sknetwork.classification import *
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import LouvainEmbedding
+
+
+class TestClassificationAPI(unittest.TestCase):
+
+    def test_undirected(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+            seeds_array = -np.ones(n)
+            seeds_array[:2] = np.arange(2)
+            seeds_dict = {0: 0, 1: 1}
+
+            classifiers = [PageRankClassifier(), DiffusionClassifier(),
+                           NNClassifier(embedding_method=LouvainEmbedding(), n_neighbors=1), Propagation()]
+
+            for algo in classifiers:
+                labels1 = algo.fit_predict(adjacency, seeds_array)
+                labels2 = algo.fit_predict(adjacency, seeds_dict)
+                self.assertTrue((labels1 == labels2).all())
+                self.assertEqual(labels2.shape, (n,))
+                membership = algo.fit_transform(adjacency, seeds_array)
+                self.assertTupleEqual(membership.shape, (n, 2))

sknetwork/classification/tests/test_diffusion.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for DiffusionClassifier"""
+
+import unittest
+
+from sknetwork.classification import DiffusionClassifier
+from sknetwork.data.test_graphs import *
+
+
+class TestDiffusionClassifier(unittest.TestCase):
+
+    def test_graph(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        algo.fit(adjacency, labels=labels)
+        self.assertTrue(len(algo.labels_) == n_nodes)
+        adjacency = test_digraph()
+        algo = DiffusionClassifier(centering=False)
+        algo.fit(adjacency, labels=labels)
+        self.assertTrue(len(algo.labels_) == n_nodes)
+        with self.assertRaises(ValueError):
+            DiffusionClassifier(n_iter=0)
+        algo = DiffusionClassifier(centering=True, scale=10)
+        probs = algo.fit_predict_proba(adjacency, labels=labels)[:, 1]
+        self.assertTrue(max(probs) > 0.99)
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        labels_row = {0: 0, 1: 1}
+        labels_col = {5: 1}
+        algo = DiffusionClassifier()
+        algo.fit(biadjacency, labels_row=labels_row, labels_col=labels_col)
+        self.assertTrue(len(algo.labels_row_) == n_row)
+        self.assertTrue(len(algo.labels_col_) == n_col)
+        self.assertTrue(all(algo.labels_col_ == algo.predict(columns=True)))
+
+    def test_predict(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(adjacency, labels=labels)
+        self.assertTrue(len(labels_pred) == n_nodes)
+        probs_pred = algo.fit_predict_proba(adjacency, labels=labels)
+        self.assertTrue(probs_pred.shape == (n_nodes, 2))
+        membership = algo.fit_transform(adjacency, labels=labels)
+        self.assertTrue(membership.shape == (n_nodes, 2))
+
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        labels_row = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(biadjacency, labels_row=labels_row)
+        self.assertTrue(len(labels_pred) == n_row)
+        labels_pred = algo.predict(columns=True)
+        self.assertTrue(len(labels_pred) == n_col)
+        probs_pred = algo.fit_predict_proba(biadjacency, labels_row=labels_row)
+        self.assertTrue(probs_pred.shape == (n_row, 2))
+        probs_pred = algo.predict_proba(columns=True)
+        self.assertTrue(probs_pred.shape == (n_col, 2))
+        membership = algo.fit_transform(biadjacency, labels_row=labels_row)
+        self.assertTrue(membership.shape == (n_row, 2))
+        membership = algo.transform(columns=True)
+        self.assertTrue(membership.shape == (n_col, 2))
+
+    def test_reindex_label(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 2, 2: 3}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(adjacency, labels=labels)
+        self.assertTrue(len(labels_pred) == n_nodes)
+        self.assertTrue(set(list(labels_pred)) == {0, 2, 3})

sknetwork/classification/tests/test_knn.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for KNN"""
+import unittest
+
+from sknetwork.classification import NNClassifier
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral
+
+
+class TestKNNClassifier(unittest.TestCase):
+
+    def test_classification(self):
+        for adjacency in [test_graph(), test_digraph(), test_bigraph()]:
+            labels = {0: 0, 1: 1}
+
+            algo = NNClassifier(n_neighbors=1)
+            labels_pred = algo.fit_predict(adjacency, labels)
+            self.assertTrue(len(set(labels_pred)) == 2)
+
+            algo = NNClassifier(n_neighbors=1, embedding_method=Spectral(2), normalize=False)
+            labels_pred = algo.fit_predict(adjacency, labels)
+            self.assertTrue(len(set(labels_pred)) == 2)

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