scikit-network 0.31.0__cp310-cp310-win_amd64.whl → 0.32.1__cp310-cp310-win_amd64.whl

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,7 +9,6 @@ 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
@@ -73,24 +72,26 @@ class PageRank(BaseRanking):
         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/tests/test_API.py

@@ -17,8 +17,6 @@ class TestPageRank(unittest.TestCase):
                 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

@@ -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_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/regression/base.py

@@ -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/topology/__init__.py

@@ -2,5 +2,7 @@
 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 *
+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