scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/linalg/tests/test_ppr.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Louvain"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, karate_club
+from sknetwork.data.parse import from_edge_list
+from sknetwork.data.test_graphs import *
+from sknetwork.linalg.operators import Regularizer
+from sknetwork.linalg.ppr_solver import get_pagerank
+from sknetwork.utils.check import is_proba_array
+
+
+class TestPPR(unittest.TestCase):
+
+    def test_diteration(self):
+        # test convergence by tolerance
+        for adjacency in [house(), test_graph(), test_digraph()]:
+            seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+            pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+            self.assertTrue(is_proba_array(pr))
+
+        # test graph with some null out-degree
+        adjacency = from_edge_list([(0, 1)])
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))
+
+        # test invalid entry
+        adjacency = Regularizer(house(), 0.1)
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        with self.assertRaises(ValueError):
+            get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+
+    def test_push(self):
+        # test convergence by tolerance
+        adjacency = karate_club()
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85,
+                          n_iter=100, tol=1e-1, solver='push', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))
+
+    def test_piteration(self):
+        # test on SparseLR matrix
+        adjacency = Regularizer(house(), 0.1)
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='piteration', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))

sknetwork/linalg/tests/test_sparse_lowrank.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for embeddings metrics."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, star_wars
+from sknetwork.linalg.sparse_lowrank import SparseLR
+
+
+class TestSparseLowRank(unittest.TestCase):
+
+    def setUp(self):
+        """Simple regularized adjacency and biadjacency for tests."""
+        self.undirected = SparseLR(house(), [(np.ones(5), np.ones(5))])
+        self.bipartite = SparseLR(star_wars(), [(np.ones(4), np.ones(3))])
+
+    def test_init(self):
+        with self.assertRaises(ValueError):
+            SparseLR(house(), [(np.ones(5), np.ones(4))])
+        with self.assertRaises(ValueError):
+            SparseLR(house(), [(np.ones(4), np.ones(5))])
+
+    def test_addition(self):
+        addition = self.undirected + self.undirected
+        expected = SparseLR(2 * house(), [(np.ones(5), 2 * np.ones(5))])
+        err = (addition.sparse_mat - expected.sparse_mat).count_nonzero()
+        self.assertEqual(err, 0)
+        x = np.random.rand(5)
+        self.assertAlmostEqual(np.linalg.norm(addition.dot(x) - expected.dot(x)), 0)
+
+    def test_operations(self):
+        adjacency = self.undirected.sparse_mat
+        slr = -self.undirected
+        slr += adjacency
+        slr -= adjacency
+        slr.left_sparse_dot(adjacency)
+        slr.right_sparse_dot(adjacency)
+        slr.astype(float)
+
+    def test_product(self):
+        prod = self.undirected.dot(np.ones(5))
+        self.assertEqual(prod.shape, (5,))
+        prod = self.bipartite.dot(np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - np.array([5., 4., 6., 5.])), 0.)
+        prod = self.bipartite.dot(0.5 * np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - np.array([2.5, 2., 3., 2.5])), 0.)
+        prod = (2 * self.bipartite).dot(0.5 * np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - 2 * np.array([2.5, 2., 3., 2.5])), 0.)
+
+    def test_transposition(self):
+        transposed = self.undirected.T
+        error = (self.undirected.sparse_mat - transposed.sparse_mat).data
+        self.assertEqual(abs(error).sum(), 0.)
+        transposed = self.bipartite.T
+        x, y = transposed.low_rank_tuples[0]
+        self.assertTrue((x == np.ones(3)).all())
+        self.assertTrue((y == np.ones(4)).all())
+

sknetwork/linalg/tests/test_svd.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for svd."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import movie_actor
+from sknetwork.linalg import LanczosSVD, SparseLR
+
+
+def svd_err(matrix, u, v, sigma):
+    """Approximation error for singular vectors."""
+    err = matrix.dot(v) - u * sigma
+    return np.linalg.norm(err)
+
+
+# noinspection DuplicatedCode
+class TestSolvers(unittest.TestCase):
+
+    def setUp(self):
+        """Simple biadjacency for tests."""
+        self.biadjacency = movie_actor()
+        n_row, n_col = self.biadjacency.shape
+        self.slr = SparseLR(self.biadjacency, [(np.random.rand(n_row), np.random.rand(n_col))])
+
+    def test_lanczos(self):
+        solver = LanczosSVD()
+        solver.fit(self.biadjacency, 2)
+        self.assertEqual(len(solver.singular_values_), 2)
+        self.assertAlmostEqual(svd_err(self.biadjacency, solver.singular_vectors_left_, solver.singular_vectors_right_,
+                                       solver.singular_values_), 0)
+
+        solver.fit(self.slr, 2)
+        self.assertEqual(len(solver.singular_values_), 2)
+        self.assertAlmostEqual(svd_err(self.slr, solver.singular_vectors_left_, solver.singular_vectors_right_,
+                                       solver.singular_values_), 0)

sknetwork/linkpred/__init__.py

@@ -0,0 +1,4 @@
+"""link prediction module"""
+from sknetwork.linkpred.first_order import CommonNeighbors, JaccardIndex, SaltonIndex, SorensenIndex, HubPromotedIndex,\
+    HubDepressedIndex, AdamicAdar, ResourceAllocation, PreferentialAttachment
+from sknetwork.linkpred.postprocessing import is_edge, whitened_sigmoid

sknetwork/linkpred/base.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on May, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from abc import ABC
+from typing import Union, Iterable, Tuple
+
+import numpy as np
+
+from sknetwork.utils.base import Algorithm
+
+
+class BaseLinkPred(Algorithm, ABC):
+    """Base class for link prediction algorithms."""
+
+    def _predict_base(self, source: int, targets: Iterable):
+        """Prediction for a single node and multiple targets"""
+        raise NotImplementedError
+
+    def _predict_node(self, node: int):
+        """Prediction for a single node."""
+        raise NotImplementedError
+
+    def _predict_nodes(self, nodes: np.ndarray):
+        """Prediction for multiple nodes."""
+        preds = []
+        for node in nodes:
+            preds.append(self._predict_node(node))
+        return np.array(preds)
+
+    def _predict_edge(self, source: int, target: int):
+        """Prediction for a single edge."""
+        return self._predict_base(source, [target])[0]
+
+    def _predict_edges(self, edges: np.ndarray):
+        """Prediction for a list of edges."""
+        preds = []
+        for edge in edges:
+            i, j = edge[0], edge[1]
+            preds.append(self._predict_edge(i, j))
+        return np.array(preds)
+
+    def predict(self, query: Union[int, Iterable, Tuple]):
+        """Compute similarity scores.
+
+        Parameters
+        ----------
+        query : int, list, array or Tuple
+            * If int i, return the similarities s(i, j) for all j.
+            * If list or array integers, return s(i, j) for i in query, for all j as array.
+            * If tuple (i, j), return the similarity s(i, j).
+            * If list of tuples or array of shape (n_queries, 2), return s(i, j) for (i, j) in query as array.
+
+        Returns
+        -------
+        predictions : int, float or array
+            The prediction scores.
+        """
+        if np.issubdtype(type(query), np.integer):
+            return self._predict_node(query)
+        if isinstance(query, Tuple):
+            return self._predict_edge(query[0], query[1])
+        if isinstance(query, list):
+            query = np.array(query)
+        if isinstance(query, np.ndarray):
+            if query.ndim == 1:
+                return self._predict_nodes(query)
+            elif query.ndim == 2 and query.shape[1] == 2:
+                return self._predict_edges(query)
+            else:
+                raise ValueError("Query not understood.")
+        else:
+            raise ValueError("Query not understood.")
+
+    def fit_predict(self, adjacency, query):
+        """Fit algorithm to data and compute scores for requested edges."""
+        self.fit(adjacency)
+        return self.predict(query)