scikit-network 0.33.4__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

sknetwork/embedding/spring.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+from scipy.spatial import cKDTree
+
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.embedding.spectral import Spectral
+from sknetwork.linalg import normalize
+from sknetwork.utils.check import check_adjacency_vector, check_format, check_square, is_symmetric
+from sknetwork.utils.format import directed2undirected
+
+
+class Spring(BaseEmbedding):
+    """Spring layout for displaying small graphs.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the graph layout.
+    strength : float
+        Intensity of the force that moves the nodes.
+    n_iter : int
+        Number of iterations to update positions.
+    tol : float
+        Minimum relative change in positions to continue updating.
+    approx_radius : float
+        If a positive value is provided, only the nodes within this distance a given node are used to compute
+        the repulsive force.
+    position_init : str
+        How to initialize the layout. If 'spectral', use Spectral embedding in dimension 2,
+        otherwise, use random initialization.
+
+    Attributes
+    ----------
+    embedding\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import Spring
+    >>> from sknetwork.data import karate_club
+    >>> spring = Spring()
+    >>> adjacency = karate_club()
+    >>> embedding = spring.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    Notes
+    -----
+    Simple implementation designed to display small graphs.
+
+    References
+    ----------
+    Fruchterman, T. M. J.,  Reingold, E. M. (1991).
+    `Graph Drawing by Force-Directed Placement.
+    <https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.4380211102>`_
+    Software – Practice & Experience.
+    """
+    def __init__(self, n_components: int = 2, strength: float = None, n_iter: int = 50, tol: float = 1e-4,
+                 approx_radius: float = -1, position_init: str = 'random'):
+        super(Spring, self).__init__()
+        self.n_components = n_components
+        self.strength = strength
+        self.n_iter = n_iter
+        self.tol = tol
+        self.approx_radius = approx_radius
+        if position_init not in ['random', 'spectral']:
+            raise ValueError('Unknown initial position, try "spectral" or "random".')
+        else:
+            self.position_init = position_init
+
+    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray], position_init: Optional[np.ndarray] = None,
+            n_iter: Optional[int] = None) -> 'Spring':
+        """Compute layout.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph, treated as undirected.
+        position_init : np.ndarray
+            Custom initial positions of the nodes. Shape must be (n, 2).
+            If ``None``, use the value of self.pos_init.
+        n_iter : int
+            Number of iterations to update positions.
+            If ``None``, use the value of self.n_iter.
+
+        Returns
+        -------
+        self: :class:`Spring`
+        """
+        adjacency = check_format(adjacency)
+        check_square(adjacency)
+        if not is_symmetric(adjacency):
+            adjacency = directed2undirected(adjacency)
+        n = adjacency.shape[0]
+
+        position = np.zeros((n, self.n_components))
+        if position_init is None:
+            if self.position_init == 'random':
+                position = np.random.randn(n, self.n_components)
+            elif self.position_init == 'spectral':
+                position = Spectral(n_components=self.n_components).fit_transform(adjacency)
+        elif isinstance(position_init, np.ndarray):
+            if position_init.shape == (n, self.n_components):
+                position = position_init.copy()
+            else:
+                raise ValueError('Initial position has invalid shape.')
+        else:
+            raise TypeError('Initial position must be a numpy array.')
+
+        if n_iter is None:
+            n_iter = self.n_iter
+
+        if self.strength is None:
+            strength = np.sqrt((1 / n))
+        else:
+            strength = self.strength
+
+        pos_max = position.max(axis=0)
+        pos_min = position.min(axis=0)
+        step_max: float = 0.1 * (pos_max - pos_min).max()
+        step: float = step_max / (n_iter + 1)
+        tree = None
+
+        delta = np.zeros((n, self.n_components))
+        for iteration in range(n_iter):
+            delta *= 0
+            if self.approx_radius > 0:
+                tree = cKDTree(position)
+
+            for i in range(n):
+                # attraction
+                indices = adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]
+                attraction = adjacency.data[adjacency.indptr[i]:adjacency.indptr[i+1]] / strength
+
+                grad = position[i] - position[indices]
+                attraction *= np.linalg.norm(grad, axis=1)
+                attraction = (grad * attraction[:, np.newaxis]).sum(axis=0)
+
+                # repulsion
+                if tree is None:
+                    grad: np.ndarray = (position[i] - position)  # shape (n, n_components)
+                    distance: np.ndarray = np.linalg.norm(grad, axis=1)  # shape (n,)
+                else:
+                    neighbors = tree.query_ball_point(position[i], self.approx_radius)
+                    grad: np.ndarray = (position[i] - position[neighbors])  # shape (n_neigh, n_components)
+                    distance: np.ndarray = np.linalg.norm(grad, axis=1)  # shape (n_neigh,)
+
+                distance = np.where(distance < 0.01, 0.01, distance)
+                repulsion = (grad * (strength / distance)[:, np.newaxis] ** 2).sum(axis=0)
+
+                # total force
+                delta[i]: np.ndarray = repulsion - attraction
+
+            length = np.linalg.norm(delta, axis=0)
+            length = np.where(length < 0.01, 0.1, length)
+            delta = delta * step_max / length
+            position += delta
+            step_max -= step
+            err: float = np.linalg.norm(delta) / n
+            if err < self.tol:
+                break
+
+        self.embedding_ = position
+        return self
+
+    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()
+        embedding = self.embedding_
+        n = embedding.shape[0]
+
+        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
+        embedding_vectors = normalize(adjacency_vectors).dot(embedding)
+
+        if embedding_vectors.shape[0] == 1:
+            embedding_vectors = embedding_vectors.ravel()
+
+        return embedding_vectors

sknetwork/embedding/svd.py

@@ -0,0 +1,351 @@
+#!/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, diagonal_pseudo_inverse, 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 = diagonal_pseudo_inverse(np.power(weights_row, self.factor_row))
+        diag_col = diagonal_pseudo_inverse(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 = diagonal_pseudo_inverse(np.power(weights_row, self.factor_row))
+        diag_col = diagonal_pseudo_inverse(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\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+    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)
+
+
+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_nodes, n_components)
+        Embedding of the nodes.
+    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,49 @@
+#!/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()]
+
+    def test_undirected(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+
+        method = Spring()
+        embedding = method.fit_transform(adjacency)
+        self.assertEqual(embedding.shape, (n, 2))
+
+        embedding = method.transform()
+        self.assertEqual(embedding.shape, (n, 2))
+
+    def test_bipartite(self):
+        for adjacency in [test_digraph(), test_bigraph()]:
+            n_row, n_col = adjacency.shape
+
+            for method in self.methods:
+                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))
+
+    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):
+        adjacency = test_graph()
+        adjacency_vector = np.zeros(10, dtype=int)
+        adjacency_vector[:5] = 1
+        louvain = LouvainEmbedding()
+        louvain.fit(adjacency)
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+        louvain.fit(adjacency, force_bipartite=True)
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+
+        # bipartite
+        biadjacency = test_bigraph()
+        louvain.fit(biadjacency)
+        self.assertEqual(louvain.embedding_row_.shape[0], 6)
+        self.assertEqual(louvain.embedding_col_.shape[0], 8)
+
+        for method in ['remove', 'merge', 'keep']:
+            louvain = LouvainEmbedding(isolated_nodes=method)
+            embedding = louvain.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[0], adjacency.shape[0])