scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/classification/knn.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on 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 scipy.spatial import cKDTree
+
+from sknetwork.classification.base import BaseClassifier
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.embedding.svd import GSVD
+from sknetwork.linalg.normalization import normalize
+from sknetwork.utils.check import check_n_neighbors, check_n_jobs
+from sknetwork.utils.format import get_adjacency_seeds
+
+
+class KNN(BaseClassifier):
+    """Node classification by K-nearest neighbors in the embedding space.
+
+    For bigraphs, classify rows only (see ``BiKNN`` for joint classification of rows and columns).
+
+    Parameters
+    ----------
+    embedding_method :
+        Which algorithm to use to project the nodes in vector space. Default is ``GSVD``.
+    n_neighbors :
+        Number of nearest neighbors to consider.
+    factor_distance :
+        Power weighting factor :math:`\\alpha` applied to the distance to each neighbor.
+        Neighbor at distance :math:``d`` has weight :math:`1 / d^\\alpha`. Default is 2.
+    leaf_size :
+        Leaf size passed to KDTree.
+    p :
+        Which Minkowski p-norm to use. Default is 2 (Euclidean distance).
+    tol_nn :
+        Tolerance in nearest neighbors search; the k-th returned value is guaranteed to be no further
+        than ``1 + tol_nn`` times the distance to the actual k-th nearest neighbor.
+    n_jobs :
+        Number of jobs to schedule for parallel processing. If -1 is given all processors are used.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Label of each node.
+    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix of rows, for bipartite graphs.
+    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Membership matrix of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.classification import KNN
+    >>> from sknetwork.embedding import GSVD
+    >>> from sknetwork.data import karate_club
+    >>> knn = KNN(GSVD(3), n_neighbors=1)
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> labels_true = graph.labels
+    >>> seeds = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = knn.fit_predict(adjacency, seeds)
+    >>> np.round(np.mean(labels_pred == labels_true), 2)
+    0.97
+    """
+    def __init__(self, embedding_method: BaseEmbedding = GSVD(10), n_neighbors: int = 5,
+                 factor_distance: float = 2, leaf_size: int = 16, p: float = 2, tol_nn: float = 0.01,
+                 n_jobs: Optional[int] = None):
+        super(KNN, self).__init__()
+
+        self.embedding_method = embedding_method
+        self.n_neighbors = n_neighbors
+        self.factor_distance = factor_distance
+        self.leaf_size = leaf_size
+        self.p = p
+        self.tol_nn = tol_nn
+        self.n_jobs = check_n_jobs(n_jobs)
+        if self.n_jobs is None:
+            self.n_jobs = -1
+        self.bipartite = None
+
+    @staticmethod
+    def _instantiate_vars(seeds: Union[np.ndarray, dict]):
+        labels = seeds.astype(int)
+        index_seed = np.argwhere(labels >= 0).ravel()
+        index_remain = np.argwhere(labels < 0).ravel()
+        labels_seed = labels[index_seed]
+        return index_seed, index_remain, labels_seed
+
+    def _fit_core(self, n, labels_seed, embedding, index_seed, index_remain):
+        n_seeds = len(labels_seed)
+        embedding_seed = embedding[index_seed]
+        embedding_remain = embedding[index_remain]
+        n_neighbors = check_n_neighbors(self.n_neighbors, n_seeds)
+        tree = cKDTree(embedding_seed, self.leaf_size)
+        distances, neighbors = tree.query(embedding_remain, n_neighbors, self.tol_nn, self.p, workers=self.n_jobs)
+
+        if n_neighbors == 1:
+            distances = distances[:, np.newaxis]
+            neighbors = neighbors[:, np.newaxis]
+
+        labels_neighbor = labels_seed[neighbors]
+        index = (np.min(distances, axis=1) == 0)
+        weights_neighbor = np.zeros_like(distances).astype(float)
+        # take all seeds at distance zero, if any
+        weights_neighbor[index] = (distances[index] == 0).astype(float)
+        # assign weights with respect to distances for other
+        weights_neighbor[~index] = 1 / np.power(distances[~index], self.factor_distance)
+
+        # form the corresponding matrix
+        row = list(np.repeat(index_remain, n_neighbors))
+        col = list(labels_neighbor.ravel())
+        data = list(weights_neighbor.ravel())
+
+        row += list(index_seed)
+        col += list(labels_seed)
+        data += list(np.ones_like(index_seed))
+
+        membership = normalize(sparse.csr_matrix((data, (row, col)), shape=(n, np.max(labels_seed) + 1)))
+        membership_dense = membership.toarray()
+        labels = np.argmax(membership_dense, axis=1)
+
+        return membership, labels
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], seeds: Union[np.ndarray, dict] = None,
+            seeds_row: Union[np.ndarray, dict] = None, seeds_col: Union[np.ndarray, dict] = None) -> 'KNN':
+        """Node classification by k-nearest neighbors in the embedding space.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        seeds :
+            Seed nodes. Can be a dict {node: label} or an array where "-1" means no label.
+        seeds_row, seeds_col :
+            Seeds of rows and columns (for bipartite graphs).
+
+        Returns
+        -------
+        self: :class:`KNN`
+        """
+        adjacency, seeds, self.bipartite = get_adjacency_seeds(input_matrix, seeds=seeds, seeds_row=seeds_row,
+                                                               seeds_col=seeds_col)
+        index_seed, index_remain, labels_seed = self._instantiate_vars(seeds)
+        embedding = self.embedding_method.fit_transform(adjacency)
+        membership, labels = self._fit_core(adjacency.shape[0], labels_seed, embedding, index_seed, index_remain)
+
+        self.membership_ = membership
+        self.labels_ = labels
+
+        if self.bipartite:
+            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])
+    >>> get_accuracy_score(labels_true, labels_pred)
+    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])
+    >>> np.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 = (counts_true > 0) & (counts_pred > 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])
+    >>> np.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 on 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:
+        Probability to continue the random walk.
+    solver : :obj:`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,)
+        Label of each node.
+    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix of rows, for bipartite graphs.
+    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Membership matrix 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
+    >>> seeds = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = pagerank.fit_predict(adjacency, seeds)
+    >>> 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 on 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.normalization import normalize
+from sknetwork.utils.format import get_adjacency_seeds
+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,)
+        Label of each node.
+    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix.
+    labels_row_ : np.ndarray
+        Labels of rows, for bipartite graphs.
+    labels_col_ : np.ndarray
+        Labels of columns, for bipartite graphs.
+    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Membership matrix of rows, for bipartite graphs.
+    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Membership matrix 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
+    >>> seeds = {0: labels_true[0], 33: labels_true[33]}
+    >>> labels_pred = propagation.fit_predict(adjacency, seeds)
+    >>> 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
+        self.bipartite = None
+
+    @staticmethod
+    def _instantiate_vars(seeds: np.ndarray):
+        """Instantiate variables for label propagation."""
+        n = len(seeds)
+        if len(set(seeds)) == n:
+            index_seed = np.arange(n)
+            index_remain = np.arange(n)
+            labels = seeds
+        else:
+            index_seed = np.argwhere(seeds >= 0).ravel()
+            index_remain = np.argwhere(seeds < 0).ravel()
+            labels = seeds[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], seeds: Union[np.ndarray, dict] = None,
+            seeds_row: Union[np.ndarray, dict] = None, seeds_col: Union[np.ndarray, dict] = None) -> 'Propagation':
+        """Node classification by label propagation.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        seeds :
+            Seed nodes. Can be a dict {node: label} or an array where "-1" means no label.
+        seeds_row, seeds_col :
+            Seeds of rows and columns (for bipartite graphs).
+        Returns
+        -------
+        self: :class:`Propagation`
+        """
+        adjacency, seeds, self.bipartite = get_adjacency_seeds(input_matrix, seeds=seeds, seeds_row=seeds_row,
+                                                               seeds_col=seeds_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))
+
+        membership = get_membership(labels)
+        membership = normalize(adjacency.dot(membership))
+
+        self.labels_ = labels
+        self.membership_ = membership
+
+        if self.bipartite:
+            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,35 @@
+#!/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(),
+                           KNN(embedding_method=LouvainEmbedding(), n_neighbors=1), Propagation()]
+
+            with self.assertRaises(ValueError):
+                classifiers[0].score(0)
+
+            for algo in classifiers:
+                labels1 = algo.fit_predict(adjacency, seeds_array)
+                labels2 = algo.fit_predict(adjacency, seeds_dict)
+                scores = algo.score(0)
+                self.assertTrue((labels1 == labels2).all())
+                self.assertEqual(labels2.shape, (n,))
+                membership = algo.fit_transform(adjacency, seeds_array)
+                self.assertTupleEqual(membership.shape, (n, 2))
+                self.assertEqual(scores.shape, (n,))

sknetwork/classification/tests/test_diffusion.py

@@ -0,0 +1,37 @@
+#!/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()
+        seeds = {0: 0, 1: 1}
+        algo = DiffusionClassifier()
+        algo.fit(adjacency, seeds=seeds)
+        self.assertTrue(len(algo.labels_) == adjacency.shape[0])
+        adjacency = test_digraph()
+        algo = DiffusionClassifier(centering=False)
+        algo.fit(adjacency, seeds=seeds)
+        self.assertTrue(len(algo.labels_) == adjacency.shape[0])
+        with self.assertRaises(ValueError):
+            DiffusionClassifier(n_iter=0)
+        algo = DiffusionClassifier(centering=False, threshold=1)
+        algo.fit(adjacency, seeds=seeds)
+        self.assertTrue(max(algo.labels_) == -1)
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+        seeds_row = {0: 0, 1: 1}
+        seeds_col = {5: 1}
+        algo = DiffusionClassifier()
+        algo.fit(biadjacency, seeds_row=seeds_row, seeds_col=seeds_col)
+        self.assertTrue(len(algo.labels_row_) == n_row)
+        self.assertTrue(len(algo.labels_col_) == n_col)

sknetwork/classification/tests/test_knn.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for KNN"""
+import unittest
+
+from sknetwork.classification import KNN
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import LouvainEmbedding
+
+
+class TestDiffusionClassifier(unittest.TestCase):
+
+    def test_parallel(self):
+        for adjacency in [test_graph(), test_digraph(), test_bigraph()]:
+            seeds = {0: 0, 1: 1}
+
+            algo1 = KNN(n_neighbors=1, n_jobs=None, embedding_method=LouvainEmbedding())
+            algo2 = KNN(n_neighbors=1, n_jobs=-1, embedding_method=LouvainEmbedding())
+
+            labels1 = algo1.fit_predict(adjacency, seeds)
+            labels2 = algo2.fit_predict(adjacency, seeds)
+
+            self.assertTrue(np.allclose(labels1, labels2))
+