scikit-network 0.33.3__cp312-cp312-macosx_10_13_x86_64.whl

sknetwork/ranking/tests/test_pagerank.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for pagerank.py"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.models import cyclic_digraph
+from sknetwork.data.test_graphs import test_graph, test_digraph, test_bigraph
+from sknetwork.ranking.pagerank import PageRank
+
+
+class TestPageRank(unittest.TestCase):
+
+    def setUp(self) -> None:
+        """Cycle graph for tests."""
+        self.n = 5
+        self.adjacency = cyclic_digraph(self.n)
+        self.truth = np.ones(self.n) / self.n
+
+    def test_params(self):
+        with self.assertRaises(ValueError):
+            PageRank(damping_factor=1789)
+
+    def test_solvers(self):
+        for solver in ['piteration', 'lanczos', 'bicgstab', 'RH']:
+            pagerank = PageRank(solver=solver)
+            scores = pagerank.fit_predict(self.adjacency)
+            self.assertAlmostEqual(0, np.linalg.norm(scores - self.truth))
+        with self.assertRaises(ValueError):
+            PageRank(solver='toto').fit_predict(self.adjacency)
+
+    def test_seeding(self):
+        pagerank = PageRank()
+        seeds_array = np.zeros(self.n)
+        seeds_array[0] = 1.
+        seeds_dict = {0: 1}
+
+        scores1 = pagerank.fit_predict(self.adjacency, seeds_array)
+        scores2 = pagerank.fit_predict(self.adjacency, seeds_dict)
+        self.assertAlmostEqual(np.linalg.norm(scores1 - scores2), 0.)
+
+    def test_input(self):
+        pagerank = PageRank()
+        scores = pagerank.fit_predict(self.adjacency, force_bipartite=True)
+        self.assertEqual(len(scores), len(pagerank.scores_col_))
+
+    def test_damping(self):
+        pagerank = PageRank(damping_factor=0.99)
+        scores = pagerank.fit_predict(self.adjacency)
+        self.assertAlmostEqual(np.linalg.norm(scores - self.truth), 0.)
+
+        pagerank = PageRank(damping_factor=0.01)
+        scores = pagerank.fit_predict(self.adjacency)
+        self.assertAlmostEqual(np.linalg.norm(scores - self.truth), 0.)
+
+    def test_bigraph(self):
+        pagerank = PageRank()
+        for adjacency in [test_graph(), test_digraph(), test_bigraph()]:
+            pagerank.fit(adjacency, weights_col={0: 1})
+            self.assertAlmostEqual(np.linalg.norm(pagerank.scores_col_ - pagerank.predict(columns=True)), 0.)

sknetwork/ranking/tests/test_postprocess.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for postprocessing"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.ranking.postprocess import top_k
+
+
+class TestPostprocessing(unittest.TestCase):
+
+    def test_top_k(self):
+        scores = np.arange(10)
+        index = top_k(scores, 3)
+        self.assertTrue(set(index) == {7, 8, 9})
+        index = top_k(scores, 10)
+        self.assertTrue(len(index) == 10)
+        index = top_k(scores, 20)
+        self.assertTrue(len(index) == 10)
+        scores = [3, 1, 6, 2]
+        index = top_k(scores, 2)
+        self.assertTrue(set(index) == {0, 2})
+        index = top_k(scores, 2, sort=True)
+        self.assertTrue(list(index) == [2, 0])

sknetwork/regression/__init__.py

@@ -0,0 +1,4 @@
+"""regression module"""
+from sknetwork.regression.base import BaseRegressor
+from sknetwork.regression.diffusion import Diffusion, Dirichlet
+

sknetwork/regression/base.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on April 2022
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from abc import ABC
+
+import numpy as np
+
+from sknetwork.base import Algorithm
+
+
+class BaseRegressor(Algorithm, ABC):
+    """Base class for regression algorithms.
+
+    Attributes
+    ----------
+    values_ : np.ndarray
+        Value of each node.
+    values_row_: np.ndarray
+        Values of rows, for bipartite graphs.
+    values_col_: np.ndarray
+        Values of columns, for bipartite graphs.
+    """
+    def __init__(self):
+        self.values_ = None
+
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the values predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        values : np.ndarray
+            Values.
+        """
+        if columns:
+            return self.values_col_
+        return self.values_
+
+    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to data and return the values. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        values : np.ndarray
+            Values.
+        """
+        self.fit(*args, **kwargs)
+        return self.values_
+
+    def _split_vars(self, shape):
+        n_row = shape[0]
+        self.values_row_ = self.values_[:n_row]
+        self.values_col_ = self.values_[n_row:]
+        self.values_ = self.values_row_

sknetwork/regression/diffusion.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from typing import Union, Optional, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.regression.base import BaseRegressor
+from sknetwork.utils import get_adjacency_values, get_degrees
+
+
+def init_temperatures(seeds: np.ndarray, init: Optional[float]) -> Tuple[np.ndarray, np.ndarray]:
+    """Init temperatures."""
+    n = len(seeds)
+    border = (seeds >= 0)
+    if init is None:
+        temperatures = seeds[border].mean() * np.ones(n)
+    else:
+        temperatures = init * np.ones(n)
+    temperatures[border] = seeds[border]
+    return temperatures, border
+
+
+class Diffusion(BaseRegressor):
+    """Regression by diffusion along the edges, given the temperatures of some seed nodes (heat equation).
+
+    The row vector of tempreatures :math:`T` evolves like:
+
+    :math:`T \\gets (1-\\alpha) T + \\alpha  PT`
+
+    where :math:`\\alpha` is the damping factor and :math:`P` is the transition matrix of the random walk in the graph.
+
+    All values are updated, including those of seed nodes (free diffusion).
+    See ``Dirichlet`` for diffusion with boundary constraints.
+
+    Parameters
+    ----------
+    n_iter : int
+        Number of iterations of the diffusion (must be positive).
+    damping_factor : float
+        Damping factor.
+
+    Attributes
+    ----------
+    values_ : np.ndarray
+        Value of each node (= temperature).
+    values_row_: np.ndarray
+        Values of rows, for bipartite graphs.
+    values_col_: np.ndarray
+        Values of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.data import house
+    >>> diffusion = Diffusion(n_iter=1)
+    >>> adjacency = house()
+    >>> values = {0: 1, 2: 0}
+    >>> values_pred = diffusion.fit_predict(adjacency, values)
+    >>> np.round(values_pred, 1)
+    array([0.8, 0.5, 0.2, 0.4, 0.6])
+
+    References
+    ----------
+    Chung, F. (2007). The heat kernel as the pagerank of a graph. Proceedings of the National Academy of Sciences.
+    """
+    def __init__(self, n_iter: int = 3, damping_factor: float = 0.5):
+        super(Diffusion, self).__init__()
+
+        if n_iter <= 0:
+            raise ValueError('The number of iterations must be positive.')
+        else:
+            self.n_iter = n_iter
+        self.damping_factor = damping_factor
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
+            values: Optional[Union[dict, list, np.ndarray]] = None,
+            values_row: Optional[Union[dict, list, np.ndarray]] = None,
+            values_col: Optional[Union[dict, list, np.ndarray]] = None, init: Optional[float] = None,
+            force_bipartite: bool = False) -> 'Diffusion':
+        """Compute the diffusion (temperatures at equilibrium).
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        values :
+            Temperatures of nodes in initial state (dictionary or vector). Negative temperatures ignored.
+        values_row, values_col :
+            Temperatures of rows and columns for bipartite graphs. Negative temperatures ignored.
+        init :
+            Temperature of nodes in initial state.
+            If ``None``, use the average temperature of seed nodes (default).
+        force_bipartite :
+            If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
+
+        Returns
+        -------
+        self: :class:`Diffusion`
+        """
+        adjacency, values, self.bipartite = get_adjacency_values(input_matrix, force_bipartite=force_bipartite,
+                                                                 values=values,
+                                                                 values_row=values_row,
+                                                                 values_col=values_col)
+        values, _ = init_temperatures(values, init)
+        diffusion = normalize(adjacency.T.tocsr())
+        degrees = get_degrees(diffusion)
+        diag = sparse.diags((degrees == 0).astype(int)).tocsr()
+        diffusion += diag
+
+        diffusion = (1 - self.damping_factor) * sparse.identity(len(degrees)).tocsr() + self.damping_factor * diffusion
+
+        for i in range(self.n_iter):
+            values = diffusion.dot(values)
+
+        self.values_ = values
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+        return self
+
+
+class Dirichlet(BaseRegressor):
+    """Regression by the Dirichlet problem (heat diffusion with boundary constraints).
+
+    The temperatures of some seed nodes are fixed. The temperatures of other nodes are computed.
+
+    Parameters
+    ----------
+    n_iter : int
+        Number of iterations of the diffusion (must be positive).
+
+    Attributes
+    ----------
+    values_ : np.ndarray
+        Value of each node (= temperature).
+    values_row_: np.ndarray
+        Values of rows, for bipartite graphs.
+    values_col_: np.ndarray
+        Values of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.regression import Dirichlet
+    >>> from sknetwork.data import house
+    >>> dirichlet = Dirichlet()
+    >>> adjacency = house()
+    >>> values = {0: 1, 2: 0}
+    >>> values_pred = dirichlet.fit_predict(adjacency, values)
+    >>> np.round(values_pred, 2)
+    array([1.  , 0.54, 0.  , 0.31, 0.62])
+
+    References
+    ----------
+    Chung, F. (2007). The heat kernel as the pagerank of a graph. Proceedings of the National Academy of Sciences.
+    """
+    def __init__(self, n_iter: int = 10):
+        super(Dirichlet, self).__init__()
+
+        if n_iter <= 0:
+            raise ValueError('The number of iterations must be positive.')
+        else:
+            self.n_iter = n_iter
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
+            values: Optional[Union[dict, list, np.ndarray]] = None,
+            values_row: Optional[Union[dict, list, np.ndarray]] = None,
+            values_col: Optional[Union[dict, list, np.ndarray]] = None, init: Optional[float] = None,
+            force_bipartite: bool = False) -> 'Dirichlet':
+        """Compute the solution to the Dirichlet problem (temperatures at equilibrium).
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        values :
+            Temperatures of nodes (dictionary or vector). Negative temperatures ignored.
+        values_row, values_col :
+            Temperatures of rows and columns for bipartite graphs. Negative temperatures ignored.
+        init :
+            Temperature of nodes in initial state.
+            If ``None``, use the average temperature of seed nodes (default).
+        force_bipartite :
+            If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
+
+        Returns
+        -------
+        self: :class:`Dirichlet`
+        """
+        adjacency, values, self.bipartite = get_adjacency_values(input_matrix, force_bipartite=force_bipartite,
+                                                                 values=values,
+                                                                 values_row=values_row,
+                                                                 values_col=values_col)
+        temperatures, border = init_temperatures(values, init)
+        values = temperatures.copy()
+        diffusion = normalize(adjacency)
+        for i in range(self.n_iter):
+            values = diffusion.dot(values)
+            values[border] = temperatures[border]
+
+        self.values_ = values
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+        return self

sknetwork/regression/tests/__init__.py

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

sknetwork/regression/tests/test_API.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for regression API"""
+import unittest
+
+from sknetwork.data.test_graphs import test_bigraph, test_graph, test_digraph
+from sknetwork.regression import *
+
+
+class TestAPI(unittest.TestCase):
+
+    def test_basic(self):
+        methods = [Diffusion(), Dirichlet()]
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+            for method in methods:
+                score = method.fit_predict(adjacency)
+                self.assertEqual(score.shape, (n, ))
+                self.assertTrue(min(score) >= 0)
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+
+        methods = [Diffusion(), Dirichlet()]
+        for method in methods:
+            method.fit(biadjacency)
+            values_row = method.values_row_
+            values_col = method.values_col_
+
+            self.assertEqual(values_row.shape, (n_row,))
+            self.assertEqual(values_col.shape, (n_col,))

sknetwork/regression/tests/test_diffusion.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for diffusion.py"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.regression import Diffusion, Dirichlet
+
+
+# noinspection DuplicatedCode
+class TestDiffusion(unittest.TestCase):
+
+    def setUp(self):
+        self.algos = [Diffusion(), Dirichlet()]
+
+    def test_predict(self):
+        adjacency = test_graph()
+        for algo in self.algos:
+            values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5})
+            values_ = algo.predict()
+            self.assertAlmostEqual(np.linalg.norm(values - values_), 0)
+
+    def test_no_iter(self):
+        with self.assertRaises(ValueError):
+            Diffusion(n_iter=-1)
+
+    def test_single_node_graph(self):
+        for algo in self.algos:
+            algo.fit(sparse.identity(1, format='csr'), {0: 1})
+            self.assertEqual(algo.values_, [1])
+
+    def test_range(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            for algo in self.algos:
+                values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5})
+                self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+
+        biadjacency = test_bigraph()
+        for algo in [Diffusion(), Dirichlet()]:
+            values = algo.fit_predict(biadjacency, values_row={0: 1})
+            self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+            values = algo.fit_predict(biadjacency, values_row={0: 0.1}, values_col={1: 2}, init=0.3)
+            self.assertTrue(np.all(values <= 2) and np.all(values >= 0.1))
+            self.assertAlmostEqual(np.linalg.norm(algo.values_col_ - algo.predict(columns=True)), 0)
+
+    def test_initial_state(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            for algo in self.algos:
+                values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5}, 0.3)
+                self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+
+    def test_n_iter(self):
+        with self.assertRaises(ValueError):
+            Dirichlet(n_iter=0)
+

sknetwork/sknetwork.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+"""Main module."""

sknetwork/test_base.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for base.py"""
+import unittest
+
+from sknetwork.base import Algorithm
+
+
+class TestBase(unittest.TestCase):
+
+    def setUp(self):
+        class NewAlgo(Algorithm):
+            """Docstring"""
+            def __init__(self, param: int, name: str):
+                self.param = param
+                self.name = name
+
+            def fit(self):
+                """Docstring"""
+                pass
+        self.algo = NewAlgo(1, 'abc')
+
+    def test_repr(self):
+        self.assertEqual(repr(self.algo), "NewAlgo(param=1, name='abc')")
+
+    def test_get_params(self):
+        self.assertEqual(len(self.algo.get_params()), 2)
+
+    def test_set_params(self):
+        self.algo.set_params({'param': 3})
+        self.assertEqual(self.algo.param, 3)
+
+    def test_fit(self):
+        stub = Algorithm()
+        self.assertRaises(NotImplementedError, stub.fit, None)

sknetwork/test_log.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for verbose.py"""
+
+import unittest
+
+from sknetwork.log import Log
+
+
+class TestVerbose(unittest.TestCase):
+
+    def test_prints(self):
+        logger = Log(verbose=True)
+        logger.print_log('Hello', 42)
+        self.assertEqual(str(logger.log), 'Hello 42\n')

sknetwork/topology/__init__.py

@@ -0,0 +1,8 @@
+"""Module on topology."""
+from sknetwork.topology.cliques import count_cliques
+from sknetwork.topology.core import get_core_decomposition
+from sknetwork.topology.triangles import count_triangles, get_clustering_coefficient
+from sknetwork.topology.structure import is_connected, is_bipartite, is_symmetric, get_connected_components, \
+    get_largest_connected_component
+from sknetwork.topology.cycles import is_acyclic, get_cycles, break_cycles
+from sknetwork.topology.weisfeiler_lehman import color_weisfeiler_lehman, are_isomorphic