scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/ranking/betweenness.pyx

@@ -1,7 +1,5 @@
 # distutils: language = c++
 # cython: language_level=3
-# cython: linetrace=True
-# distutils: define_macros=CYTHON_TRACE_NOGIL=1
 """
 Created on September 17 2020
 @author: Tiphaine Viard <tiphaine.viard@telecom-paris.fr>

sknetwork/ranking/closeness.py

@@ -16,20 +16,15 @@ from sknetwork.utils.check import check_format, check_square, check_connected
 
 
 class Closeness(BaseRanking):
-    """Closeness centrality of each node in a connected graph, corresponding to the average length of the
+    """Ranking by closeness centrality of each node in a connected graph, corresponding to the average length of the
     shortest paths from that node to all the other ones.
 
-    For a directed graph, the closeness centrality is computed in terms of outgoing paths.
-
     Parameters
     ----------
     method :
         Denotes if the results should be exact or approximate.
     tol: float
         If ``method=='approximate'``, the allowed tolerance on each score entry.
-    n_jobs:
-        If an integer value is given, denotes the number of workers to use (-1 means the maximum number will be used).
-        If ``None``, no parallel computations are made.
 
     Attributes
     ----------
@@ -55,12 +50,11 @@ class Closeness(BaseRanking):
     Society for Industrial and Applied Mathematics.
     """
 
-    def __init__(self, method: str = 'exact', tol: float = 1e-1, n_jobs: Optional[int] = None):
+    def __init__(self, method: str = 'exact', tol: float = 1e-1):
         super(Closeness, self).__init__()
 
         self.method = method
         self.tol = tol
-        self.n_jobs = n_jobs
 
     def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray]) -> 'Closeness':
         """Closeness centrality for connected graphs.
@@ -88,8 +82,11 @@ class Closeness(BaseRanking):
         else:
             raise ValueError("Method should be either 'exact' or 'approximate'.")
 
-        dists = get_distances(adjacency, n_jobs=self.n_jobs, sources=sources)
+        distances = np.array([get_distances(adjacency, source=source) for source in sources])
 
-        self.scores_ = ((n - 1) * n_sources / n) / dists.T.dot(np.ones(n_sources))
+        distances_min = np.min(distances, axis=1)
+        scores = (n - 1) / n / np.mean(distances, axis=1)
+        scores[distances_min < 0] = 0
+        self.scores_ = scores
 
         return self

sknetwork/ranking/pagerank.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on May 2019
+Created in May 2019
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 @author: Thomas Bonald <bonald@enst.fr>
 """
@@ -9,16 +9,14 @@ from typing import Union, Optional
 
 import numpy as np
 from scipy import sparse
-from scipy.sparse.linalg import LinearOperator
 
 from sknetwork.linalg.ppr_solver import get_pagerank
 from sknetwork.ranking.base import BaseRanking
 from sknetwork.utils.check import check_damping_factor
 from sknetwork.utils.format import get_adjacency_values
-from sknetwork.utils.verbose import VerboseMixin
 
 
-class PageRank(BaseRanking, VerboseMixin):
+class PageRank(BaseRanking):
     """PageRank of each node, corresponding to its frequency of visit by a random walk.
 
     The random walk restarts with some fixed probability. The restart distribution can be personalized by the user.
@@ -74,24 +72,26 @@ class PageRank(BaseRanking, VerboseMixin):
         self.tol = tol
         self.bipartite = None
 
-    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray, LinearOperator],
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
             weights: Optional[Union[dict, np.ndarray]] = None, weights_row: Optional[Union[dict, np.ndarray]] = None,
             weights_col: Optional[Union[dict, np.ndarray]] = None, force_bipartite: bool = False) -> 'PageRank':
-        """Fit algorithm to data.
+        """Compute the pagerank of each node.
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        weights :
-            Parameter to be used for Personalized PageRank.
-            Restart distribution as a vector or a dict (node: weight).
+        weights : np.ndarray, dict
+            Weights of the restart distribution for Personalized PageRank.
             If ``None``, the uniform distribution is used (no personalization, default).
-        weights_row, weights_col :
-            Parameter to be used for Personalized PageRank on bipartite graphs.
-            Restart distribution as vectors or dicts on rows, columns (node: weight).
+        weights_row : np.ndarray, dict
+            Weights on rows of the restart distribution for Personalized PageRank.
+            Used for bipartite graphs.
             If both weights_row and weights_col are ``None`` (default), the uniform distribution on rows is used.
-        force_bipartite :
+        weights_col : np.ndarray, dict
+            Weights on columns of the restart distribution for Personalized PageRank.
+            Used for bipartite graphs.
+        force_bipartite : bool
             If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
         Returns
         -------

sknetwork/ranking/postprocess.py

@@ -7,7 +7,7 @@ Created on May 2019
 import numpy as np
 
 
-def top_k(scores: np.ndarray, k: int = 1):
+def top_k(scores: np.ndarray, k: int = 1, sort: bool = True):
     """Return the indices of the k elements of highest values.
 
     Parameters
@@ -16,13 +16,22 @@ def top_k(scores: np.ndarray, k: int = 1):
         Array of values.
     k : int
         Number of elements to return.
+    sort : bool
+        If ``True``, sort the indices in decreasing order of value (element of highest value first).
 
     Examples
     --------
     >>> top_k([1, 3, 2], k=2)
     array([1, 2])
     """
+    scores = np.array(scores)
     if k >= len(scores):
-        return np.arange(len(scores))
+        if sort:
+            index = np.argsort(-scores)
+        else:
+            index = np.arange(scores)
     else:
-        return np.argpartition(-np.array(scores), k)[:k]
+        index = np.argpartition(-scores, k)[:k]
+        if sort:
+            index = index[np.argsort(-scores[index])]
+    return index

sknetwork/ranking/tests/test_API.py

@@ -3,22 +3,20 @@
 """tests for ranking API"""
 import unittest
 
-from sknetwork.data.test_graphs import test_bigraph, test_graph, test_digraph
+from sknetwork.data.test_graphs import *
 from sknetwork.ranking import *
 
 
 class TestPageRank(unittest.TestCase):
 
     def test_basic(self):
-        methods = [PageRank(), Closeness(), HITS(), Harmonic(), Katz()]
+        methods = [PageRank(), Closeness(), HITS(), Katz()]
         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)
-                score = method.fit_transform(adjacency)
-                self.assertEqual(score.shape, (n,))
 
     def test_bipartite(self):
         biadjacency = test_bigraph()

sknetwork/ranking/tests/test_betweenness.py

@@ -6,7 +6,7 @@ import unittest
 import numpy as np
 
 from sknetwork.ranking.betweenness import Betweenness
-from sknetwork.data.test_graphs import test_graph, test_graph_disconnect
+from sknetwork.data.test_graphs import test_graph, test_disconnected_graph
 from sknetwork.data.toy_graphs import bow_tie, star_wars
 
 
@@ -25,7 +25,7 @@ class TestBetweenness(unittest.TestCase):
         self.assertEqual(np.sum(scores > 0), 1)
 
     def test_disconnected(self):
-        adjacency = test_graph_disconnect()
+        adjacency = test_disconnected_graph()
         betweenness = Betweenness()
         with self.assertRaises(ValueError):
             betweenness.fit(adjacency)
@@ -35,4 +35,4 @@ class TestBetweenness(unittest.TestCase):
         betweenness = Betweenness()
 
         with self.assertRaises(ValueError):
-            betweenness.fit_transform(adjacency)
+            betweenness.fit_predict(adjacency)

sknetwork/ranking/tests/test_closeness.py

@@ -20,15 +20,11 @@ class TestDiffusion(unittest.TestCase):
         n = adjacency.shape[0]
 
         closeness = Closeness(method='approximate')
-        scores1 = closeness.fit_predict(adjacency)
-        closeness = Closeness(method='approximate', n_jobs=-1)
-        scores2 = closeness.fit_predict(adjacency)
-
-        self.assertEqual(scores1.shape, (n,))
-        self.assertAlmostEqual(np.linalg.norm(scores1 - scores2), 0)
+        scores = closeness.fit_predict(adjacency)
+        self.assertEqual(scores.shape, (n,))
 
     def test_disconnected(self):
-        adjacency = test_graph_disconnect()
+        adjacency = test_disconnected_graph()
         closeness = Closeness()
         with self.assertRaises(ValueError):
             closeness.fit(adjacency)

sknetwork/ranking/tests/test_pagerank.py

@@ -7,7 +7,7 @@ import unittest
 import numpy as np
 
 from sknetwork.data.models import cyclic_digraph
-from sknetwork.data.test_graphs import test_bigraph
+from sknetwork.data.test_graphs import test_graph, test_digraph, test_bigraph
 from sknetwork.ranking.pagerank import PageRank
 
 
@@ -37,8 +37,8 @@ class TestPageRank(unittest.TestCase):
         seeds_array[0] = 1.
         seeds_dict = {0: 1}
 
-        scores1 = pagerank.fit_transform(self.adjacency, seeds_array)
-        scores2 = pagerank.fit_transform(self.adjacency, seeds_dict)
+        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):
@@ -48,9 +48,15 @@ class TestPageRank(unittest.TestCase):
 
     def test_damping(self):
         pagerank = PageRank(damping_factor=0.99)
-        scores = pagerank.fit_transform(self.adjacency)
+        scores = pagerank.fit_predict(self.adjacency)
         self.assertAlmostEqual(np.linalg.norm(scores - self.truth), 0.)
 
         pagerank = PageRank(damping_factor=0.01)
-        scores = pagerank.fit_transform(self.adjacency)
+        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

@@ -19,3 +19,8 @@ class TestPostprocessing(unittest.TestCase):
         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/base.py

@@ -8,7 +8,7 @@ from abc import ABC
 
 import numpy as np
 
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class BaseRegressor(Algorithm, ABC):
@@ -26,8 +26,25 @@ class BaseRegressor(Algorithm, ABC):
     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 scores. Same parameters as the ``fit`` method.
+        """Fit algorithm to data and return the values. Same parameters as the ``fit`` method.
 
         Returns
         -------

sknetwork/regression/diffusion.py

@@ -10,9 +10,9 @@ from typing import Union, Optional, Tuple
 import numpy as np
 from scipy import sparse
 
-from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.regression.base import BaseRegressor
-from sknetwork.utils.format import get_adjacency_values
+from sknetwork.utils import get_adjacency_values, get_degrees
 
 
 def init_temperatures(seeds: np.ndarray, init: Optional[float]) -> Tuple[np.ndarray, np.ndarray]:
@@ -30,6 +30,12 @@ def init_temperatures(seeds: np.ndarray, init: Optional[float]) -> Tuple[np.ndar
 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.
 
@@ -37,6 +43,8 @@ class Diffusion(BaseRegressor):
     ----------
     n_iter : int
         Number of iterations of the diffusion (must be positive).
+    damping_factor : float
+        Damping factor.
 
     Attributes
     ----------
@@ -49,24 +57,25 @@ class Diffusion(BaseRegressor):
     Example
     -------
     >>> from sknetwork.data import house
-    >>> diffusion = Diffusion(n_iter=2)
+    >>> diffusion = Diffusion(n_iter=1)
     >>> adjacency = house()
     >>> values = {0: 1, 2: 0}
     >>> values_pred = diffusion.fit_predict(adjacency, values)
-    >>> np.round(values_pred, 2)
-    array([0.58, 0.56, 0.38, 0.58, 0.42])
+    >>> 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):
+    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],
@@ -98,7 +107,13 @@ class Diffusion(BaseRegressor):
                                                                  values_row=values_row,
                                                                  values_col=values_col)
         values, _ = init_temperatures(values, init)
-        diffusion = normalize(adjacency)
+        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)
 
@@ -110,10 +125,9 @@ class Diffusion(BaseRegressor):
 
 
 class Dirichlet(BaseRegressor):
-    """Regression by the Dirichlet problem, given the temperature of some seed nodes
-     (heat diffusion with boundary constraints).
+    """Regression by the Dirichlet problem (heat diffusion with boundary constraints).
 
-     Only values of non-seed nodes are updated. The temperatures of seed nodes are fixed.
+    The temperatures of some seed nodes are fixed. The temperatures of other nodes are computed.
 
     Parameters
     ----------

sknetwork/regression/tests/test_diffusion.py

@@ -14,6 +14,13 @@ 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)
@@ -35,6 +42,7 @@ class TestDiffusion(unittest.TestCase):
             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()]:

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

@@ -1,9 +1,8 @@
 """Module on topology."""
-from sknetwork.topology.kcliques import Cliques
-from sknetwork.topology.kcore import CoreDecomposition
-from sknetwork.topology.triangles import Triangles
-
-from sknetwork.topology.dag import DAG
-from sknetwork.topology.structure import is_acyclic, is_bipartite, is_connected, get_largest_connected_component, \
-    get_connected_components
-from sknetwork.topology.weisfeiler_lehman import WeisfeilerLehman, are_isomorphic
+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