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

sknetwork/linalg/tests/test_normalization.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on April 2020
+Created in April 2020
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 
@@ -10,7 +10,7 @@ import unittest
 import numpy as np
 from scipy import sparse
 
-from sknetwork.linalg import normalize, CoNeighbor
+from sknetwork.linalg import normalize
 
 
 class TestNormalization(unittest.TestCase):
@@ -19,12 +19,10 @@ class TestNormalization(unittest.TestCase):
         n = 5
         mat1 = normalize(np.eye(n))
         mat2 = normalize(sparse.eye(n))
-        mat3 = normalize(CoNeighbor(mat2))
 
         x = np.random.randn(n)
         self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - x), 0)
         self.assertAlmostEqual(np.linalg.norm(mat2.dot(x) - x), 0)
-        self.assertAlmostEqual(np.linalg.norm(mat3.dot(x) - x), 0)
 
         mat1 = np.random.rand(n**2).reshape((n, n))
         mat2 = sparse.csr_matrix(mat1)
@@ -32,7 +30,5 @@ class TestNormalization(unittest.TestCase):
         mat2 = normalize(mat2, p=2)
         self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - mat2.dot(x)), 0)
 
-        with self.assertRaises(NotImplementedError):
-            normalize(mat3, p=2)
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(ValueError):
             normalize(mat1, p=3)

sknetwork/linalg/tests/test_operators.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on Apr 2020
+Created in April 2020
 @author: Thomas Bonald <bonald@enst.fr>
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 import unittest
 
 from sknetwork.data.test_graphs import *
-from sknetwork.linalg import Laplacian, Normalizer, CoNeighbor, normalize
+from sknetwork.linalg import Laplacian, Normalizer, CoNeighbor
 from sknetwork.linalg.basics import safe_sparse_dot
 
 
@@ -53,10 +53,6 @@ class TestOperators(unittest.TestCase):
     def test_coneighbors(self):
         biadjacency = test_bigraph()
         operator = CoNeighbor(biadjacency)
-        transition = normalize(operator)
-        x = transition.dot(np.ones(transition.shape[1]))
-
-        self.assertAlmostEqual(np.linalg.norm(x - np.ones(operator.shape[0])), 0)
         operator.astype('float')
         operator.right_sparse_dot(sparse.eye(operator.shape[1], format='csr'))
 

sknetwork/linalg/tests/test_ppr.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Tests for Louvain"""
+"""Tests for d-iteration"""
 import unittest
 
 import numpy as np

sknetwork/linkpred/base.py

@@ -7,6 +7,7 @@ Created in March 2022
 from abc import ABC
 
 import numpy as np
+from scipy import sparse
 
 from sknetwork.base import Algorithm
 
@@ -23,7 +24,17 @@ class BaseLinker(Algorithm, ABC):
     def __init__(self):
         self.links_ = None
 
-    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+    def predict(self) -> sparse.csr_matrix:
+        """Return the predicted links.
+
+        Returns
+        -------
+        links_ : sparse.csr_matrix
+            Link matrix.
+        """
+        return self.links_
+
+    def fit_predict(self, *args, **kwargs) -> sparse.csr_matrix:
         """Fit algorithm to data and return the links. Same parameters as the ``fit`` method.
 
         Returns

sknetwork/linkpred/nn.py

@@ -11,7 +11,7 @@ from scipy import sparse
 
 from sknetwork.linkpred.base import BaseLinker
 from sknetwork.embedding.base import BaseEmbedding
-from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.utils.check import check_n_neighbors
 from sknetwork.utils.format import get_adjacency
 
@@ -23,11 +23,11 @@ class NNLinker(BaseLinker):
 
     Parameters
     ----------
-    n_neighbors :
+    n_neighbors : int
         Number of nearest neighbors. If ``None``, all nodes are considered.
-    threshold :
+    threshold : float
         Threshold on cosine similarity. Only links above this threshold are kept.
-    embedding_method :
+    embedding_method : :class:`BaseEmbedding`
         Embedding method used to represent nodes in vector space.
         If ``None`` (default), use identity.
 
@@ -95,9 +95,9 @@ class NNLinker(BaseLinker):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        index :
+        index : np.ndarray
             Index of source nodes to consider. If ``None``, the links are predicted for all nodes.
 
         Returns

sknetwork/path/distances.py

@@ -14,7 +14,8 @@ from sknetwork.utils.format import get_adjacency
 
 def get_distances(input_matrix: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
                   source_row: Optional[Union[int, Iterable]] = None,
-                  source_col: Optional[Union[int, Iterable]] = None, force_bipartite: bool = False) \
+                  source_col: Optional[Union[int, Iterable]] = None, transpose: bool = False,
+                  force_bipartite: bool = False) \
         -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]:
     """Get the distances from a source (or a set of sources) in number of hops.
 
@@ -24,10 +25,12 @@ def get_distances(input_matrix: sparse.csr_matrix, source: Optional[Union[int, I
         Adjacency matrix or biadjacency matrix of the graph.
     source :
         If an integer, index of the source node.
-        If a list, indices of source nodes (the shortest distances to one of these nodes in returned).
+        If a list or array, indices of source nodes (the shortest distances to one of these nodes is returned).
     source_row, source_col :
         For bipartite graphs, index of source nodes on rows and columns.
         The parameter source_row is an alias for source (at least one of them must be ``None``).
+    transpose :
+        If ``True``, transpose the input matrix.
     force_bipartite :
         If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
         Set to ``True`` is the parameters source_row or source_col re specified.
@@ -47,11 +50,15 @@ def get_distances(input_matrix: sparse.csr_matrix, source: Optional[Union[int, I
     >>> get_distances(adjacency, source=[0, 2])
     array([0, 1, 0])
     """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
     if source_row is not None or source_col is not None:
         force_bipartite = True
-    adjacency, bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite, allow_empty=True)
+    adjacency, bipartite = get_adjacency(matrix, force_bipartite=force_bipartite, allow_empty=True)
     adjacency_transpose = adjacency.astype(bool).T.tocsr()
-    n_row, n_col = input_matrix.shape
+    n_row, n_col = matrix.shape
     n_nodes = adjacency.shape[0]
 
     mask = np.zeros(n_nodes, dtype=bool)

sknetwork/path/shortest_path.py

@@ -37,7 +37,7 @@ def get_shortest_path(input_matrix: sparse.csr_matrix, source: Optional[Union[in
     Returns
     -------
     path : sparse.csr_matrix
-        Adjacency matrix of the graph of the shortest paths to the source node (or the set of source nodes).
+        Adjacency matrix of the graph of the shortest paths from the source node (or the set of source nodes).
         If the input graph is a bipartite graph, the shape of the matrix is (n_row + n_col, n_row + n_col) with the new
         index corresponding to the rows then the columns of the original graph.
 

sknetwork/path/tests/test_distances.py

@@ -21,6 +21,8 @@ class TestDistances(unittest.TestCase):
         distances = get_distances(adjacency, 0)
         distances_ = np.array([0, 1, 3, 2, 2, 3, 2, 3, 4, 4])
         self.assertTrue(all(distances == distances_))
+        distances = get_distances(adjacency, 0, transpose=True)
+        self.assertTrue(all(distances == distances_))
         distances = get_distances(adjacency, [0, 5])
         distances_ = np.array([0, 1, 3, 2, 1, 0, 1, 2, 4, 3])
         self.assertTrue(all(distances == distances_))
@@ -36,6 +38,11 @@ class TestDistances(unittest.TestCase):
         distances = get_distances(adjacency, [0])
         distances_ = np.array([0, 1, 3, 2, 2, 3, -1, -1, -1, -1])
         self.assertTrue(all(distances == distances_))
+        distances = get_distances(adjacency, [0], transpose=True)
+        self.assertTrue(sum(distances < 0) == 9)
+        distances = get_distances(adjacency, [0, 5], transpose=True)
+        distances_ = np.array([0, 2, -1, -1, 1, 0, 1, -1, -1, -1])
+        self.assertTrue(all(distances == distances_))
 
         biadjacency = test_bigraph()
         distances_row, distances_col = get_distances(biadjacency, [0])

sknetwork/path/tests/test_search.py

@@ -36,5 +36,5 @@ class TestSearch(unittest.TestCase):
 
         adjacency = test_digraph()
         search = breadth_first_search(adjacency, 1)
-        search_ = np.array([1, 3, 4, 2, 5])
-        self.assertTrue(all(search == search_))
+        search_ = {1, 3, 4, 2, 5}
+        self.assertTrue(set(list(search)) == search_)

sknetwork/ranking/base.py

@@ -26,20 +26,25 @@ class BaseRanking(Algorithm, ABC):
     def __init__(self):
         self.scores_ = None
 
-    def fit_predict(self, *args, **kwargs) -> np.ndarray:
-        """Fit algorithm to data and return the scores. Same parameters as the ``fit`` method.
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the scores predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
 
         Returns
         -------
         scores : np.ndarray
             Scores.
         """
-        self.fit(*args, **kwargs)
+        if columns:
+            return self.scores_col_
         return self.scores_
 
-    def fit_transform(self, *args, **kwargs) -> np.ndarray:
-        """Fit algorithm to data and return the scores. Alias for ``fit_predict``.
-        Same parameters as the ``fit`` method.
+    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to data and return the scores. Same parameters as the ``fit`` method.
 
         Returns
         -------