scikit-network 0.33.3__cp313-cp313-win_amd64.whl

sknetwork/linalg/push.pyx

@@ -0,0 +1,71 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created on Mars 2021
+@author: Wenzhuo Zhao <wenzhuo.zhao@etu.sorbonne-universite.fr>
+"""
+from libcpp.queue cimport queue
+from cython.parallel cimport prange
+import numpy as np
+cimport numpy as cnp
+cimport cython
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def push_pagerank(int n, cnp.ndarray[cnp.int32_t, ndim=1] degrees,
+                  int[:] indptr, int[:] indices,
+                  int[:] rev_indptr, int[:] rev_indices,
+                  cnp.ndarray[cnp.float32_t, ndim=1] seeds,
+                  cnp.float32_t damping_factor, cnp.float32_t tol):
+    """Push-based PageRank"""
+    cdef cnp.ndarray[cnp.float32_t, ndim=1] residuals
+    cdef int vertex
+    cdef int neighbor
+    cdef int j1
+    cdef int j2
+    cdef int j
+    cdef int[:] indexes
+    cdef int index
+    cdef float probability
+    cdef queue[int] worklist
+    cdef cnp.ndarray[cnp.float32_t, ndim=1] scores
+    cdef cnp.float32_t tmp
+    cdef float norm
+
+    residuals = np.zeros(n, dtype=np.float32)
+    for vertex in prange(n, nogil=True):
+        j1 = rev_indptr[vertex]
+        j2 = rev_indptr[vertex + 1]
+        # iterate node's in-coming neighbors
+        for j in range(j1, j2):
+            neighbor = rev_indices[j]
+            residuals[vertex] += 1 / degrees[neighbor]
+        """add the probability of seeds"""
+        residuals[vertex] *= (1 - damping_factor) * \
+            damping_factor * (1 + seeds[vertex])
+
+    # node with high residual value will be processed first
+    indexes = np.argsort(-residuals).astype(np.int32)
+    for index in indexes:
+        worklist.push(index)
+    scores = np.full(n, (1 - damping_factor), dtype=np.float32)
+
+    while not worklist.empty():
+        vertex = worklist.front()
+        worklist.pop()
+        # scores[v]_new
+        scores[vertex] += residuals[vertex]
+        # iterate node's out-coming neighbors
+        j1 = indptr[vertex]
+        j2 = indptr[vertex + 1]
+        for j in prange(j1, j2, nogil=True):
+            neighbor = indices[j]
+            tmp = residuals[neighbor]
+            residuals[neighbor] += residuals[vertex] * \
+                (1 - damping_factor) / degrees[vertex]
+            if residuals[neighbor] > tol > tmp:
+                worklist.push(neighbor)
+    norm = np.linalg.norm(scores, 1)
+    scores /= norm
+    return scores

sknetwork/linalg/sparse_lowrank.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 19 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union, Tuple
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+
+class SparseLR(LinearOperator):
+    """Class for matrices with "sparse + low rank" structure.
+    Example:
+
+    :math:`A + xy^T`
+
+    Parameters
+    ----------
+    sparse_mat: scipy.spmatrix
+        Sparse component. Is converted to csr format automatically.
+    low_rank_tuples: list
+        Single tuple of arrays of list of tuples, representing the low rank components [(x1, y1), (x2, y2),...].
+        Each low rank component is of the form :math:`xy^T`.
+
+    Examples
+    --------
+    >>> from scipy import sparse
+    >>> from sknetwork.linalg import SparseLR
+    >>> adjacency = sparse.eye(2, format='csr')
+    >>> slr = SparseLR(adjacency, (np.ones(2), np.ones(2)))
+    >>> x = np.ones(2)
+    >>> slr.dot(x)
+    array([3., 3.])
+    >>> slr.sum(axis=0)
+    array([3., 3.])
+    >>> slr.sum(axis=1)
+    array([3., 3.])
+    >>> float(slr.sum())
+    6.0
+
+    References
+    ----------
+    De Lara (2019). `The Sparse + Low Rank trick for Matrix Factorization-Based Graph Algorithms.
+    <http://www.mlgworkshop.org/2019/papers/MLG2019_paper_1.pdf>`_
+    Proceedings of the 15th International Workshop on Mining and Learning with Graphs (MLG).
+    """
+    def __init__(self, sparse_mat: Union[sparse.csr_matrix, sparse.csc_matrix], low_rank_tuples: Union[list, Tuple],
+                 dtype=float):
+        n_row, n_col = sparse_mat.shape
+        self.sparse_mat = sparse_mat.tocsr().astype(dtype)
+        super(SparseLR, self).__init__(dtype=dtype, shape=(n_row, n_col))
+
+        if isinstance(low_rank_tuples, Tuple):
+            low_rank_tuples = [low_rank_tuples]
+        self.low_rank_tuples = []
+        for x, y in low_rank_tuples:
+            if x.shape == (n_row,) and y.shape == (n_col,):
+                self.low_rank_tuples.append((x.astype(self.dtype), y.astype(self.dtype)))
+            else:
+                raise ValueError('For each low rank tuple, x (resp. y) should be a vector of length {} (resp. {})'
+                                 .format(n_row, n_col))
+
+    def __neg__(self):
+        return SparseLR(-self.sparse_mat, [(-x, y) for (x, y) in self.low_rank_tuples])
+
+    def __add__(self, other: 'SparseLR'):
+        if type(other) == sparse.csr_matrix:
+            return SparseLR(self.sparse_mat + other, self.low_rank_tuples)
+        else:
+            return SparseLR(self.sparse_mat + other.sparse_mat, self.low_rank_tuples + other.low_rank_tuples)
+
+    def __sub__(self, other):
+        return self.__add__(-other)
+
+    def __mul__(self, other):
+        return SparseLR(other * self.sparse_mat, [(other * x, y) for (x, y) in self.low_rank_tuples])
+
+    def _matvec(self, matrix: np.ndarray):
+        """Right dot product with a dense matrix.
+
+        Parameters
+        ----------
+        matrix:
+            Matrix.
+
+        Returns
+        -------
+        Dot product as a dense array
+        """
+        prod = self.sparse_mat.dot(matrix)
+        if len(matrix.shape) == 1:
+            for (x, y) in self.low_rank_tuples:
+                prod += x * matrix.dot(y)
+        else:
+            transposed = matrix.T
+            for (x, y) in self.low_rank_tuples:
+                prod += x[:, np.newaxis].dot(transposed.dot(y)[:, np.newaxis].T)
+        return prod
+
+    def _transpose(self):
+        """Transposed operator."""
+        transposed_sparse = sparse.csr_matrix(self.sparse_mat.T)
+        transposed_tuples = [(y, x) for (x, y) in self.low_rank_tuples]
+        return SparseLR(transposed_sparse, transposed_tuples)
+
+    def _adjoint(self):
+        return self.transpose()
+
+    def left_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Left dot product with a sparse matrix."""
+        return SparseLR(matrix.dot(self.sparse_mat), [(matrix.dot(x), y) for (x, y) in self.low_rank_tuples])
+
+    def right_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Right dot product with a sparse matrix."""
+        return SparseLR(self.sparse_mat.dot(matrix), [(x, matrix.T.dot(y)) for (x, y) in self.low_rank_tuples])
+
+    def sum(self, axis=None):
+        """Row-wise, column-wise or total sum of operator's coefficients.
+
+        Parameters
+        ----------
+        axis :
+            If 0, return column-wise sum. If 1, return row-wise sum. Otherwise, return total sum.
+        """
+        if axis == 0:
+            s = self.T.dot(np.ones(self.shape[0]))
+        elif axis == 1:
+            s = self.dot(np.ones(self.shape[1]))
+        else:
+            s = self.dot(np.ones(self.shape[1])).sum()
+        return s
+
+    def astype(self, dtype: Union[str, np.dtype]):
+        """Change dtype of the object."""
+        self.sparse_mat = self.sparse_mat.astype(dtype)
+        self.low_rank_tuples = [(x.astype(dtype), y.astype(dtype)) for (x, y) in self.low_rank_tuples]
+        self.dtype = np.dtype(dtype)
+
+        return self

sknetwork/linalg/svd_solver.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on July 10 2019
+
+Authors:
+Nathan De Lara <nathan.delara@telecom-paris.fr>
+"""
+from abc import ABC
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import svds
+
+from sknetwork.base import Algorithm
+
+
+class SVDSolver(Algorithm, ABC):
+    """Generic class for SVD-solvers.
+
+    Attributes
+    ----------
+    singular_vectors_left_: np.ndarray
+        Two-dimensional array, each column is a left singular vector of the input.
+    singular_vectors_right_: np.ndarray
+        Two-dimensional array, each column is a right singular vector of the input.
+    singular_values_: np.ndarray
+        Singular values.
+    """
+    def __init__(self):
+        self.singular_vectors_left_ = None
+        self.singular_vectors_right_ = None
+        self.singular_values_ = None
+
+
+class LanczosSVD(SVDSolver):
+    """SVD solver using Lanczos method on :math:`AA^T` or :math:`A^TA`.
+
+    Parameters
+    ----------
+    n_iter : int
+        Maximum number of Arnoldi update iterations allowed.
+        Default = 10 * nb or rows or columns.
+    tol : float
+        Relative accuracy for eigenvalues (stopping criterion).
+        Default = 0 (machine precision).
+
+    Attributes
+    ----------
+    singular_vectors_left_: np.ndarray
+        Two-dimensional array, each column is a left singular vector of the input.
+    singular_vectors_right_: np.ndarray
+        Two-dimensional array, each column is a right singular vector of the input.
+    singular_values_: np.ndarray
+        Singular values.
+
+    See Also
+    --------
+    scipy.sparse.linalg.svds
+    """
+    def __init__(self, n_iter: int = None, tol: float = 0.):
+        super(LanczosSVD, self).__init__()
+        self.n_iter = n_iter
+        self.tol = tol
+
+    def fit(self, matrix: Union[sparse.csr_matrix, sparse.linalg.LinearOperator], n_components: int,
+            init_vector: np.ndarray = None):
+        """Perform singular value decomposition on input matrix.
+
+        Parameters
+        ----------
+        matrix :
+            Matrix to decompose.
+        n_components : int
+            Number of singular values to compute
+        init_vector : np.ndarray
+            Starting vector for iteration.
+            Default = random.
+        Returns
+        -------
+        self: :class:`SVDSolver`
+        """
+        u, s, vt = svds(matrix.astype(float), n_components, v0=init_vector)
+        # order the singular values by decreasing order
+        index = np.argsort(-s)
+        self.singular_vectors_left_ = u[:, index]
+        self.singular_vectors_right_ = vt.T[:, index]
+        self.singular_values_ = s[index]
+
+        return self

sknetwork/linalg/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for linalg"""

sknetwork/linalg/tests/test_eig.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for eigenvalue solver."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import miserables, karate_club
+from sknetwork.linalg import LanczosEig, SparseLR
+
+
+def eigenvector_err(matrix, eigenvectors, eigenvalues):
+    """Approximation error for eigenvectors."""
+    err = matrix.dot(eigenvectors) - eigenvectors * eigenvalues
+    return np.linalg.norm(err)
+
+
+# noinspection DuplicatedCode
+class TestSolvers(unittest.TestCase):
+
+    def setUp(self):
+        """Load les Miserables and regularized version"""
+        self.adjacency = miserables()
+        self.random_state = np.random.RandomState(123)
+        n = self.adjacency.shape[0]
+        x = np.random.random(n)
+        self.slr = SparseLR(self.adjacency, [(x, x)])
+
+    def test_lanczos(self):
+        solver = LanczosEig('LM')
+        solver.fit(self.adjacency, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(self.adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)
+
+        solver.fit(self.slr, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(self.slr, solver.eigenvectors_, solver.eigenvalues_), 0)
+
+        adjacency = karate_club()
+        solver = LanczosEig('SM')
+        solver.fit(adjacency, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)

sknetwork/linalg/tests/test_laplacian.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for laplacian."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.linalg import get_laplacian
+
+
+class TestLaplacian(unittest.TestCase):
+
+    def test(self):
+        adjacency = test_graph()
+        laplacian = get_laplacian(adjacency)
+        self.assertEqual(np.linalg.norm(laplacian.dot(np.ones(adjacency.shape[0]))), 0)

sknetwork/linalg/tests/test_normalization.py

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

sknetwork/linalg/tests/test_operators.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+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
+from sknetwork.linalg.basics import safe_sparse_dot
+
+
+class TestOperators(unittest.TestCase):
+
+    def test_laplacian(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n = adjacency.shape[1]
+            # regular Laplacian
+            laplacian = Laplacian(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.ones(n))), 0)
+            # normalized Laplacian
+            laplacian = Laplacian(adjacency, normalized_laplacian=True)
+            weights = adjacency.dot(np.ones(n))
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.sqrt(weights))), 0)
+            # regularization
+            regularization = 0.1
+            laplacian = Laplacian(adjacency, regularization=regularization, normalized_laplacian=True)
+            weights = adjacency.dot(np.ones(n)) + regularization
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.sqrt(weights))), 0)
+            # product
+            shape = (n, 3)
+            self.assertEqual(laplacian.dot(np.ones(shape)).shape, shape)
+            self.assertEqual(safe_sparse_dot(laplacian, np.ones(shape)).shape, shape)
+
+    def test_normalizer(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n_row, n_col = adjacency.shape
+            # square matrix
+            normalizer = Normalizer(adjacency)
+            non_zeros = adjacency.dot(np.ones(n_col)) > 0
+            self.assertAlmostEqual(np.linalg.norm(normalizer.dot(np.ones(n_col)) - non_zeros), 0)
+            # single row
+            normalizer = Normalizer(adjacency[1])
+            self.assertAlmostEqual(float(normalizer.dot(np.ones(n_col))), 1)
+            normalizer = Normalizer(adjacency[2].toarray().ravel())
+            self.assertAlmostEqual(float(normalizer.dot(np.ones(n_col))), 1)
+            # regularization
+            normalizer = Normalizer(adjacency, 1)
+            self.assertAlmostEqual(np.linalg.norm(normalizer.dot(np.ones(n_col)) - np.ones(n_row)), 0)
+
+    def test_coneighbors(self):
+        biadjacency = test_bigraph()
+        operator = CoNeighbor(biadjacency)
+        operator.astype('float')
+        operator.right_sparse_dot(sparse.eye(operator.shape[1], format='csr'))
+
+        operator1 = CoNeighbor(biadjacency, normalized=False)
+        operator2 = CoNeighbor(biadjacency, normalized=False)
+        x = np.random.randn(operator.shape[1])
+        x1 = (-operator1).dot(x)
+        x2 = (operator2 * -1).dot(x)
+        x3 = operator1.T.dot(x)
+        self.assertAlmostEqual(np.linalg.norm(x1 - x2), 0)
+        self.assertAlmostEqual(np.linalg.norm(x2 - x3), 0)

sknetwork/linalg/tests/test_polynome.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for polynomials."""
+
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.linalg import Polynome
+
+
+class TestPolynome(unittest.TestCase):
+
+    def test_init(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            Polynome(adjacency, np.array([]))
+
+    def test_operations(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+        polynome = Polynome(adjacency, np.arange(3))
+        x = np.random.randn(n)
+
+        y1 = (polynome * 2).dot(x)
+        y2 = (-polynome).dot(x)
+        self.assertAlmostEqual(np.linalg.norm(0.5 * y1 + y2), 0)
+
+    def test_dot(self):
+        adjacency = sparse.eye(5, format='csr')
+        polynome = Polynome(adjacency, np.arange(2))
+
+        x = np.random.randn(5, 3)
+        y = polynome.dot(x)
+        self.assertAlmostEqual(np.linalg.norm(x - y), 0)
+

sknetwork/linalg/tests/test_ppr.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for d-iteration"""
+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,2 @@
+"""link prediction module"""
+from sknetwork.linkpred.nn import NNLinker