scikit-network 0.33.0__cp312-cp312-macosx_11_0_arm64.whl

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,))

sknetwork/classification/vote.pyx

@@ -0,0 +1,56 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in 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,8 @@
+"""clustering module"""
+from sknetwork.clustering.base import BaseClustering
+from sknetwork.clustering.louvain import Louvain
+from sknetwork.clustering.leiden import Leiden
+from sknetwork.clustering.propagation_clustering import PropagationClustering
+from sknetwork.clustering.metrics import get_modularity
+from sknetwork.clustering.postprocess import reindex_labels, aggregate_graph
+from sknetwork.clustering.kcenters import KCenters

sknetwork/clustering/base.py

@@ -0,0 +1,172 @@
+#!/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.normalizer import normalize
+from sknetwork.base import Algorithm
+from sknetwork.utils.membership import get_membership
+
+
+class BaseClustering(Algorithm, ABC):
+    """Base class for clustering algorithms.
+
+    Attributes
+    ----------
+    labels_ : np.ndarray, shape (n_labels,)
+        Label of each node.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
+    labels_row_, labels_col_ : np.ndarray
+        Labels of rows and columns, for bipartite graphs.
+    probs_row_, probs_col_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels for rows and columns (for bipartite graphs).
+    aggregate_ : sparse.csr_matrix
+        Aggregate adjacency matrix or biadjacency matrix between clusters.
+    """
+    def __init__(self, sort_clusters: bool = True, return_probs: bool = False, return_aggregate: bool = False):
+        self.sort_clusters = sort_clusters
+        self.return_probs = return_probs
+        self.return_aggregate = return_aggregate
+        self._init_vars()
+
+    def predict(self, columns=False) -> np.ndarray:
+        """Return the labels predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        labels : np.ndarray
+            Labels.
+        """
+        if columns:
+            return self.labels_col_
+        return self.labels_
+
+    def fit_predict(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.predict()
+
+    def predict_proba(self, columns=False) -> np.ndarray:
+        """Return the probability distribution over labels as predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        probs : np.ndarray
+            Probability distribution over labels.
+        """
+        if columns:
+            return self.probs_col_.toarray()
+        return self.probs_.toarray()
+
+    def fit_predict_proba(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the probability distribution over labels.
+        Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        probs : np.ndarray
+            Probability of each label.
+        """
+        self.fit(*args, **kwargs)
+        return self.predict_proba()
+
+    def transform(self, columns=False) -> sparse.csr_matrix:
+        """Return the probability distribution over labels in sparse format.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        probs : sparse.csr_matrix
+            Probability distribution over labels.
+        """
+        if columns:
+            return self.probs_col_
+        return self.probs_
+
+    def fit_transform(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the membership matrix. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        membership : np.ndarray
+            Membership matrix (distribution over clusters).
+        """
+        self.fit(*args, **kwargs)
+        return self.transform()
+
+    def _init_vars(self):
+        """Init variables."""
+        self.labels_ = None
+        self.labels_row_ = None
+        self.labels_col_ = None
+        self.probs_ = None
+        self.probs_row_ = None
+        self.probs_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_probs or self.return_aggregate:
+            input_matrix = input_matrix.astype(float)
+            if not self.bipartite:
+                probs = get_membership(self.labels_)
+                if self.return_probs:
+                    self.probs_ = normalize(input_matrix.dot(probs))
+                if self.return_aggregate:
+                    self.aggregate_ = sparse.csr_matrix(probs.T.dot(input_matrix.dot(probs)))
+            else:
+                if self.labels_col_ is None:
+                    n_labels = max(self.labels_) + 1
+                    probs_row = get_membership(self.labels_, n_labels=n_labels)
+                    probs_col = normalize(input_matrix.T.dot(probs_row))
+                else:
+                    n_labels = max(max(self.labels_row_), max(self.labels_col_)) + 1
+                    probs_row = get_membership(self.labels_row_, n_labels=n_labels)
+                    probs_col = get_membership(self.labels_col_, n_labels=n_labels)
+                if self.return_probs:
+                    self.probs_row_ = normalize(input_matrix.dot(probs_col))
+                    self.probs_col_ = normalize(input_matrix.T.dot(probs_row))
+                    self.probs_ = self.probs_row_
+                if self.return_aggregate:
+                    aggregate_ = sparse.csr_matrix(probs_row.T.dot(input_matrix))
+                    aggregate_ = aggregate_.dot(probs_col)
+                    self.aggregate_ = aggregate_
+
+        return self