scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/embedding/svd.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2018
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg import SVDSolver, LanczosSVD, safe_sparse_dot, diag_pinv, normalize, Regularizer, SparseLR
+from sknetwork.utils.check import check_format, check_adjacency_vector, check_nonnegative, check_n_components
+
+
+class GSVD(BaseEmbedding):
+    """Graph embedding by Generalized Singular Value Decomposition of the adjacency or biadjacency matrix :math:`A`.
+    This is equivalent to the Singular Value Decomposition of the matrix :math:`D_1^{- \\alpha_1}AD_2^{- \\alpha_2}`
+    where :math:`D_1, D_2` are the diagonal matrices of row weights and columns weights, respectively, and
+    :math:`\\alpha_1, \\alpha_2` are parameters.
+
+    Parameters
+    -----------
+    n_components : int
+        Dimension of the embedding.
+    regularization : ``None`` or float (default = ``None``)
+        Regularization factor :math:`\\alpha` so that the matrix is :math:`A + \\alpha \\frac{11^T}{n}`.
+    factor_row : float (default = 0.5)
+        Power factor :math:`\\alpha_1` applied to the diagonal matrix of row weights.
+    factor_col : float (default = 0.5)
+        Power factor :math:`\\alpha_2` applied to the diagonal matrix of column weights.
+    factor_singular : float (default = 0.)
+        Parameter :math:`\\alpha` applied to the singular values on right singular vectors.
+        The embedding of rows and columns are respectively :math:`D_1^{- \\alpha_1}U \\Sigma^{1-\\alpha}` and
+        :math:`D_2^{- \\alpha_2}V \\Sigma^\\alpha` where:
+
+        * :math:`U` is the matrix of left singular vectors, shape (n_row, n_components)
+        * :math:`V` is the matrix of right singular vectors, shape (n_col, n_components)
+        * :math:`\\Sigma` is the diagonal matrix of singular values, shape (n_components, n_components)
+
+    normalized : bool (default = ``True``)
+        If ``True``, normalized the embedding so that each vector has norm 1 in the embedding space, i.e.,
+        each vector lies on the unit sphere.
+    solver : ``'lanczos'`` (Lanczos algorithm, default) or :class:`SVDSolver` (custom solver)
+        Which solver to use.
+
+    Attributes
+    ----------
+    embedding_ : array, shape = (n, n_components)
+        Embedding of the nodes.
+    embedding_row_ : array, shape = (n_row, n_components)
+        Embedding of the rows, for bipartite graphs.
+    embedding_col_ : array, shape = (n_col, n_components)
+        Embedding of the columns, for bipartite graphs.
+    singular_values_ : np.ndarray, shape = (n_components)
+        Singular values.
+    singular_vectors_left_ : np.ndarray, shape = (n_row, n_components)
+        Left singular vectors.
+    singular_vectors_right_ : np.ndarray, shape = (n_col, n_components)
+        Right singular vectors.
+    weights_col_ : np.ndarray, shape = (n2)
+        Weights applied to columns.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import GSVD
+    >>> from sknetwork.data import karate_club
+    >>> gsvd = GSVD()
+    >>> adjacency = karate_club()
+    >>> embedding = gsvd.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    References
+    ----------
+    Abdi, H. (2007).
+    `Singular value decomposition (SVD) and generalized singular value decomposition.
+    <https://www.cs.cornell.edu/cv/ResearchPDF/Generalizing%20The%20Singular%20Value%20Decomposition.pdf>`_
+    Encyclopedia of measurement and statistics, 907-912.
+    """
+    def __init__(self, n_components=2, regularization: Union[None, float] = None,
+                 factor_row: float = 0.5, factor_col: float = 0.5, factor_singular: float = 0., normalized: bool = True,
+                 solver: Union[str, SVDSolver] = 'lanczos'):
+        super(GSVD, self).__init__()
+
+        self.n_components = n_components
+        if regularization == 0:
+            self.regularization = None
+        else:
+            self.regularization = regularization
+        self.factor_row = factor_row
+        self.factor_col = factor_col
+        self.factor_singular = factor_singular
+        self.normalized = normalized
+        self.solver = solver
+
+        self.singular_values_ = None
+        self.singular_vectors_left_ = None
+        self.singular_vectors_right_ = None
+        self.regularization_ = None
+        self.weights_col_ = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> 'GSVD':
+        """Compute the embedding of the graph.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+
+        Returns
+        -------
+        self: :class:`GSVD`
+        """
+        self._init_vars()
+
+        adjacency = check_format(input_matrix).asfptype()
+        n_row, n_col = adjacency.shape
+        n_components = check_n_components(self.n_components, min(n_row, n_col) - 1)
+
+        if isinstance(self.solver, str):
+            self.solver = LanczosSVD()
+        regularization = self.regularization
+        if regularization:
+            adjacency_reg = Regularizer(adjacency, regularization)
+        else:
+            adjacency_reg = adjacency
+
+        weights_row = adjacency_reg.dot(np.ones(n_col))
+        weights_col = adjacency_reg.T.dot(np.ones(n_row))
+        diag_row = diag_pinv(np.power(weights_row, self.factor_row))
+        diag_col = diag_pinv(np.power(weights_col, self.factor_col))
+        self.solver.fit(safe_sparse_dot(diag_row, safe_sparse_dot(adjacency_reg, diag_col)), n_components)
+
+        singular_values = self.solver.singular_values_
+        index = np.argsort(-singular_values)
+        singular_values = singular_values[index]
+        singular_vectors_left = self.solver.singular_vectors_left_[:, index]
+        singular_vectors_right = self.solver.singular_vectors_right_[:, index]
+        singular_left_diag = sparse.diags(np.power(singular_values, 1 - self.factor_singular))
+        singular_right_diag = sparse.diags(np.power(singular_values, self.factor_singular))
+
+        embedding_row = diag_row.dot(singular_vectors_left)
+        embedding_col = diag_col.dot(singular_vectors_right)
+        embedding_row = singular_left_diag.dot(embedding_row.T).T
+        embedding_col = singular_right_diag.dot(embedding_col.T).T
+
+        if self.normalized:
+            embedding_row = normalize(embedding_row, p=2)
+            embedding_col = normalize(embedding_col, p=2)
+
+        self.embedding_row_ = embedding_row
+        self.embedding_col_ = embedding_col
+        self.embedding_ = embedding_row
+        self.singular_values_ = singular_values
+        self.singular_vectors_left_ = singular_vectors_left
+        self.singular_vectors_right_ = singular_vectors_right
+        self.weights_col_ = weights_col
+
+        return self
+
+    @staticmethod
+    def _check_adj_vector(adjacency_vectors):
+        check_nonnegative(adjacency_vectors)
+
+    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
+        """Predict the embedding of new rows, defined by their adjacency vectors.
+
+        Parameters
+        ----------
+        adjacency_vectors :
+            Adjacency vectors of nodes.
+            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
+
+        Returns
+        -------
+        embedding_vectors : np.ndarray
+            Embedding of the nodes.
+        """
+        self._check_fitted()
+        singular_vectors_right = self.singular_vectors_right_
+        singular_values = self.singular_values_
+
+        n_row, _ = self.embedding_row_.shape
+        n_col, _ = self.embedding_col_.shape
+
+        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n_col)
+        self._check_adj_vector(adjacency_vectors)
+
+        # regularization
+        if self.regularization:
+            adjacency_vectors = Regularizer(adjacency_vectors, self.regularization)
+
+        # weighting
+        weights_row = adjacency_vectors.dot(np.ones(n_col))
+        diag_row = diag_pinv(np.power(weights_row, self.factor_row))
+        diag_col = diag_pinv(np.power(self.weights_col_, self.factor_col))
+        adjacency_vectors = safe_sparse_dot(diag_row, safe_sparse_dot(adjacency_vectors, diag_col))
+
+        # projection in the embedding space
+        averaging = adjacency_vectors
+        embedding_vectors = diag_row.dot(averaging.dot(singular_vectors_right))
+
+        # scaling
+        embedding_vectors /= np.power(singular_values, self.factor_singular)
+
+        if self.normalized:
+            embedding_vectors = normalize(embedding_vectors, p=2)
+
+        if len(embedding_vectors) == 1:
+            embedding_vectors = embedding_vectors.ravel()
+
+        return embedding_vectors
+
+
+class SVD(GSVD):
+    """Graph embedding by Singular Value Decomposition of the adjacency or biadjacency matrix of the graph.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the embedding.
+    regularization : ``None`` or float (default = ``None``)
+        Regularization factor :math:`\\alpha` so that the matrix is :math:`A + \\alpha \\frac{11^T}{n}`.
+    factor_singular : float (default = 0.)
+        Power factor :math:`\\alpha` applied to the singular values on right singular vectors.
+        The embedding of rows and columns are respectively :math:`U \\Sigma^{1-\\alpha}` and
+        :math:`V \\Sigma^\\alpha` where:
+
+        * :math:`U` is the matrix of left singular vectors, shape (n_row, n_components)
+        * :math:`V` is the matrix of right singular vectors, shape (n_col, n_components)
+        * :math:`\\Sigma` is the diagonal matrix of singular values, shape (n_components, n_components)
+
+    normalized : bool (default = ``False``)
+        If ``True``, normalized the embedding so that each vector has norm 1 in the embedding space, i.e.,
+        each vector lies on the unit sphere.
+    solver : ``'lanczos'`` (Lanczos algorithm, default) or :class:`SVDSolver` (custom solver)
+        Which solver to use.
+
+    Attributes
+    ----------
+    embedding_ : array, shape = (n, n_components)
+        Embedding of the nodes.
+    embedding_row_ : array, shape = (n_row, n_components)
+        Embedding of the rows, for bipartite graphs.
+    embedding_col_ : array, shape = (n_col, n_components)
+        Embedding of the columns, for bipartite graphs.
+    singular_values_ : np.ndarray, shape = (n_components)
+        Singular values.
+    singular_vectors_left_ : np.ndarray, shape = (n_row, n_components)
+        Left singular vectors.
+    singular_vectors_right_ : np.ndarray, shape = (n_col, n_components)
+        Right singular vectors.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import SVD
+    >>> from sknetwork.data import karate_club
+    >>> svd = SVD()
+    >>> adjacency = karate_club()
+    >>> embedding = svd.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    References
+    ----------
+    Abdi, H. (2007).
+    `Singular value decomposition (SVD) and generalized singular value decomposition.
+    <https://www.cs.cornell.edu/cv/ResearchPDF/Generalizing%20The%20Singular%20Value%20Decomposition.pdf>`_
+    Encyclopedia of measurement and statistics.
+    """
+    def __init__(self, n_components=2, regularization: Union[None, float] = None, factor_singular: float = 0.,
+                 normalized: bool = False, solver: Union[str, SVDSolver] = 'lanczos'):
+        super(SVD, self).__init__(n_components=n_components, regularization=regularization,
+                                  factor_singular=factor_singular, factor_row=0., factor_col=0., normalized=normalized,
+                                  solver=solver)
+
+    @staticmethod
+    def _check_adj_vector(adjacency_vectors: np.ndarray):
+        return
+
+
+class PCA(SVD):
+    """Graph embedding by Principal Component Analysis of the adjacency or biadjacency matrix.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the embedding.
+    normalized : bool (default = ``False``)
+        If ``True``, normalized the embedding so that each vector has norm 1 in the embedding space, i.e.,
+        each vector lies on the unit sphere.
+    solver : ``'lanczos'`` (Lanczos algorithm, default) or :class:`SVDSolver` (custom solver)
+        Which solver to use.
+
+    Attributes
+    ----------
+    embedding_ : array, shape = (n, n_components)
+        Embedding of the nodes.
+    embedding_row_ : array, shape = (n_row, n_components)
+        Embedding of the rows, for bipartite graphs.
+    embedding_col_ : array, shape = (n_col, n_components)
+        Embedding of the columns, for bipartite graphs.
+    singular_values_ : np.ndarray, shape = (n_components)
+        Singular values.
+    singular_vectors_left_ : np.ndarray, shape = (n_row, n_components)
+        Left singular vectors.
+    singular_vectors_right_ : np.ndarray, shape = (n_col, n_components)
+        Right singular vectors.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import PCA
+    >>> from sknetwork.data import karate_club
+    >>> pca = PCA()
+    >>> adjacency = karate_club()
+    >>> embedding = pca.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    References
+    ----------
+    Jolliffe, I.T. (2002).
+    `Principal Component Analysis`
+    Series: Springer Series in Statistics.
+    """
+    def __init__(self, n_components=2, normalized: bool = False, solver: Union[str, SVDSolver] = 'lanczos'):
+        super(PCA, self).__init__()
+        self.n_components = n_components
+        self.normalized = normalized
+        if isinstance(solver, str):
+            self.solver = LanczosSVD()
+        else:
+            self.solver = solver
+
+    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray]) -> 'PCA':
+        """Compute the embedding of the graph.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency or biadjacency matrix of the graph.
+
+        Returns
+        -------
+        self: :class:`PCA`
+        """
+        adjacency = check_format(adjacency).asfptype()
+        n_row, n_col = adjacency.shape
+        adjacency_centered = SparseLR(adjacency, (-np.ones(n_row), adjacency.T.dot(np.ones(n_row)) / n_row))
+
+        svd = self.solver
+        svd.fit(adjacency_centered, self.n_components)
+        self.embedding_row_ = svd.singular_vectors_left_
+        self.embedding_col_ = svd.singular_vectors_right_
+        self.embedding_ = svd.singular_vectors_left_
+        self.singular_values_ = svd.singular_values_
+        self.singular_vectors_left_ = svd.singular_vectors_left_
+        self.singular_vectors_right_ = svd.singular_vectors_right_
+
+        return self

sknetwork/embedding/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for embedding"""

sknetwork/embedding/tests/test_API.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for embeddings"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral, SVD, GSVD, Spring
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def setUp(self):
+        """Algorithms by input types."""
+        self.methods = [Spectral(), GSVD(), SVD()]
+        self.bimethods = [GSVD(), SVD()]
+
+    def test_undirected(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+
+        method = Spring()
+        embedding = method.fit_transform(adjacency)
+        self.assertEqual(embedding.shape, (n, 2))
+        pred1 = method.predict(adjacency[0])
+        pred2 = method.predict(adjacency[0].toarray())
+        self.assertEqual(pred1.shape, (2,))
+        self.assertAlmostEqual(np.linalg.norm(pred1 - pred2), 0)
+
+        pred1 = method.predict(adjacency)
+        pred2 = method.predict(adjacency.toarray())
+        self.assertTupleEqual(pred1.shape, (n, 2))
+        self.assertAlmostEqual(np.linalg.norm(pred1 - pred2), 0)
+
+    def test_bimethods(self):
+
+        for adjacency in [test_digraph(), test_bigraph()]:
+            n_row, n_col = adjacency.shape
+
+            for method in self.bimethods:
+                method.fit(adjacency)
+
+                self.assertEqual(method.embedding_.shape, (n_row, 2))
+                self.assertEqual(method.embedding_row_.shape, (n_row, 2))
+                self.assertEqual(method.embedding_col_.shape, (n_col, 2))
+
+                ref = method.embedding_[0]
+                pred1 = method.predict(adjacency[0])
+                pred2 = method.predict(adjacency[0].toarray())
+
+                self.assertEqual(pred1.shape, (2,))
+                self.assertAlmostEqual(np.linalg.norm(pred1 - pred2), 0)
+                self.assertAlmostEqual(np.linalg.norm(pred1 - ref), 0)
+
+                ref = method.embedding_
+                pred1 = method.predict(adjacency)
+                pred2 = method.predict(adjacency.toarray())
+
+                self.assertTupleEqual(pred1.shape, (n_row, 2))
+                self.assertAlmostEqual(np.linalg.norm(pred1 - pred2), 0)
+                self.assertAlmostEqual(np.linalg.norm(pred1 - ref), 0)
+
+    def test_disconnected(self):
+        n = 10
+        adjacency = np.eye(n)
+        for method in self.methods:
+            embedding = method.fit_transform(adjacency)
+            self.assertEqual(embedding.shape, (n, 2))
+
+    def test_regularization(self):
+        adjacency = test_graph()
+        method = Spectral()
+        self.assertEqual(method._get_regularization(-1, adjacency), 0)

sknetwork/embedding/tests/test_force_atlas.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for force atlas2 embeddings"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph, test_digraph
+from sknetwork.embedding.force_atlas import ForceAtlas
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_options(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+
+            force_atlas = ForceAtlas()
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas = ForceAtlas(lin_log=True)
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas = ForceAtlas(approx_radius=1.)
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas.fit(adjacency, pos_init=layout, n_iter=1)
+
+    def test_errors(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            ForceAtlas().fit(adjacency, pos_init=np.ones((5, 7)))

sknetwork/embedding/tests/test_louvain_embedding.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for Louvain embedding"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph, test_bigraph
+from sknetwork.embedding import LouvainEmbedding
+
+
+class TestLouvainEmbedding(unittest.TestCase):
+
+    def test_predict(self):
+        louvain = LouvainEmbedding()
+        louvain.fit(test_graph())
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+        louvain.fit(test_graph(), force_bipartite=True)
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+
+        for method in ['remove', 'merge', 'keep']:
+            louvain = LouvainEmbedding(isolated_nodes=method)
+            louvain.fit(test_graph())
+            embedding_vector = louvain.predict(np.array([1, 0, 0, 0, 1, 1, 0, 0, 0, 1]))
+            self.assertEqual(embedding_vector.shape[0], 1)
+
+        for method in ['remove', 'merge', 'keep']:
+            bilouvain = LouvainEmbedding(isolated_nodes=method)
+            bilouvain.fit(test_bigraph())
+            embedding_vector = bilouvain.predict(np.array([1, 0, 0, 0, 1, 1, 0, 1]))
+            self.assertEqual(embedding_vector.shape[0], 1)
+
+

sknetwork/embedding/tests/test_louvain_hierarchy.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for LouvainNE"""
+import unittest
+
+from sknetwork.data.test_graphs import test_graph, test_graph_disconnect, test_digraph, test_bigraph
+from sknetwork.embedding import LouvainNE
+
+
+class TestLouvainNE(unittest.TestCase):
+
+    def test_louvain_hierarchy(self):
+        louvain = LouvainNE()
+        for adjacency in [test_graph(), test_graph_disconnect(), test_digraph()]:
+            self.assertTupleEqual(louvain.fit_transform(adjacency).shape, (10, 2))
+        louvain.fit(test_bigraph())
+        self.assertTupleEqual(louvain.embedding_.shape, (6, 2))
+        louvain.fit(test_graph(), force_bipartite=True)
+        self.assertTupleEqual(louvain.embedding_.shape, (10, 2))

sknetwork/embedding/tests/test_metrics.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for embeddings metrics"""
+
+import unittest
+
+from sknetwork.data.test_graphs import test_bigraph, test_graph
+from sknetwork.embedding import Spectral
+from sknetwork.embedding.metrics import get_cosine_similarity
+
+
+class TestClusteringMetrics(unittest.TestCase):
+
+    def test_cosine(self):
+        biadjacency = test_bigraph()
+        method = Spectral(3)
+
+        embedding = method.fit_transform(biadjacency)
+        embedding_col = method.embedding_col_
+        similarity = get_cosine_similarity(biadjacency, embedding, embedding_col)
+        self.assertAlmostEqual(similarity, 0.56, 2)
+
+        adjacency = test_graph()
+        embedding = method.fit_transform(adjacency)
+        similarity = get_cosine_similarity(adjacency, embedding)
+        self.assertAlmostEqual(similarity, 0.32, 2)
+
+        with self.assertRaises(ValueError):
+            get_cosine_similarity(biadjacency, embedding)

sknetwork/embedding/tests/test_random_projection.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for random projection"""
+import unittest
+
+from sknetwork.data.test_graphs import test_graph, test_bigraph, test_digraph, test_graph_disconnect
+from sknetwork.embedding import RandomProjection
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_random_projection(self):
+        for algo in [RandomProjection(), RandomProjection(random_walk=True)]:
+            adjacency = test_graph()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            embedding = algo.fit_transform(adjacency, force_bipartite=True)
+            self.assertEqual(embedding.shape[1], 2)
+            adjacency = test_digraph()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            adjacency = test_graph_disconnect()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            biadjacency = test_bigraph()
+            embedding = algo.fit_transform(biadjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            self.assertEqual(algo.embedding_col_.shape[1], 2)

sknetwork/embedding/tests/test_spectral.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for spectral embedding."""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral
+from sknetwork.utils.check import is_weakly_connected
+from sknetwork.utils.format import bipartite2undirected
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_undirected(self):
+        for adjacency in [test_graph(), test_graph_disconnect()]:
+            n = adjacency.shape[0]
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            weights = adjacency.dot(np.ones(n))
+            if not is_weakly_connected(adjacency):
+                weights += 1
+            self.assertAlmostEqual(np.linalg.norm(embedding.T.dot(weights)), 0)
+            self.assertAlmostEqual(np.linalg.norm(embedding[1:4] - spectral.predict(adjacency[1:4])), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+            self.assertAlmostEqual(np.linalg.norm(embedding[1:4] - spectral.predict(adjacency[1:4])), 0)
+
+    def test_directed(self):
+        for adjacency in [test_digraph(), test_digraph().astype(bool)]:
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding[6:8] - spectral.predict(adjacency[6:8])), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(spectral.eigenvectors_.sum(axis=0)), 0)
+            self.assertAlmostEqual(np.linalg.norm(embedding[6:8] - spectral.predict(adjacency[6:8])), 0)
+
+    def test_regularization(self):
+        for adjacency in [test_graph(), test_graph_disconnect()]:
+            n = adjacency.shape[0]
+            # random walk
+            regularization = 0.1
+            spectral = Spectral(3, regularization=regularization, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            weights = adjacency.dot(np.ones(n)) + regularization
+            self.assertAlmostEqual(np.linalg.norm(embedding.T.dot(weights)), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', regularization=1, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+            # without regularization
+            spectral = Spectral(3, decomposition='laplacian', regularization=-1, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+
+    def test_bipartite(self):
+        for biadjacency in [test_digraph(), test_bigraph(), test_bigraph_disconnect()]:
+            n_row, n_col = biadjacency.shape
+            adjacency = bipartite2undirected(biadjacency)
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            spectral.fit(biadjacency)
+            embedding_full = np.vstack([spectral.embedding_row_, spectral.embedding_col_])
+            weights = adjacency.dot(np.ones(n_row + n_col))
+            if not is_weakly_connected(adjacency):
+                weights += 1
+            self.assertAlmostEqual(np.linalg.norm(embedding_full.T.dot(weights)), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            spectral.fit(biadjacency)
+            embedding_full = np.vstack([spectral.embedding_row_, spectral.embedding_col_])
+            self.assertAlmostEqual(np.linalg.norm(embedding_full.sum(axis=0)), 0)
+
+    def test_normalization(self):
+        for adjacency in [test_graph(), test_graph_disconnect()]:
+            spectral = Spectral(3)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(np.linalg.norm(embedding, axis=1) - np.ones(adjacency.shape[0])), 0)