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

sknetwork/data/toy_graphs.py

@@ -11,10 +11,10 @@ from typing import Union
 import numpy as np
 from scipy import sparse
 
-from sknetwork.data.base import Bunch
+from sknetwork.data.base import Dataset
 
 
-def house(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def house(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """House graph.
 
     * Undirected graph
@@ -46,7 +46,7 @@ def house(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     if metadata:
         x = np.array([0, -1, -1, 1, 1])
         y = np.array([2, 1, -1, -1, 1])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.position = np.vstack((x, y)).T
         graph.name = 'house'
@@ -55,7 +55,7 @@ def house(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return adjacency
 
 
-def bow_tie(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def bow_tie(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Bow tie graph.
 
     * Undirected graph
@@ -86,7 +86,7 @@ def bow_tie(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     if metadata:
         x = np.array([0, -1, 1, -1, 1])
         y = np.array([0, 1, 1, -1, -1])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.position = np.vstack((x, y)).T
         graph.name = 'bow_tie'
@@ -95,7 +95,7 @@ def bow_tie(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return adjacency
 
 
-def karate_club(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def karate_club(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Karate club graph.
 
     * Undirected graph
@@ -150,7 +150,7 @@ def karate_club(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
             [-0.33, -0.15, -0.01, -0.28, -0.64, -0.75, -0.76, -0.25,  0.09, 0.23, -0.62, -0.4, -0.53, -0.07,
              0.55,  0.64, -1., -0.42, 0.6, -0.01,  0.45, -0.34,  0.61,  0.41,  0.14,  0.28,  0.68, 0.21,
              0.12,  0.54,  0.19,  0.09,  0.38,  0.33])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.labels = labels
         graph.position = np.vstack((x, y)).T
@@ -160,7 +160,7 @@ def karate_club(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return adjacency
 
 
-def miserables(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def miserables(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Co-occurrence graph of the characters in the novel Les miserables by Victor Hugo.
 
     * Undirected graph
@@ -257,7 +257,7 @@ def miserables(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
              0.05, 0.12,  0.82,  0.44,  0.06, -0.2, -0.4, -0.28, -0.68, -0.79, -0.4, -0.07, -0.51, -0.17, -0.03,
              -0.09, -0.14, -0.04, -0.04, -0.07, -0.06, -0.11, -0.06, -0.35,  0.24,  0.19,  0.22,  0.29, -0.2,
              0.06,  0.14,  0.3, -0.1])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.names = np.array(names)
         graph.position = np.vstack((x, y)).T
@@ -267,7 +267,7 @@ def miserables(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return adjacency
 
 
-def painters(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def painters(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Graph of links between some famous painters on Wikipedia.
 
     * Directed graph
@@ -312,7 +312,7 @@ def painters(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         y = np.array(
             [0.53, 0.19, -0.71, 0.44, -0.48, -0.65, 0.69, -0.11, 0.01,
              -1., 0.49, 0.28, 0.06, 0.27])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.names = names
         graph.position = np.stack((x, y)).T
@@ -322,7 +322,7 @@ def painters(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return adjacency
 
 
-def hourglass(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def hourglass(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Hourglass graph.
 
     * Bipartite graph
@@ -342,14 +342,14 @@ def hourglass(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     """
     biadjacency = sparse.csr_matrix(np.ones((2, 2), dtype=bool))
     if metadata:
-        graph = Bunch()
+        graph = Dataset()
         graph.biadjacency = biadjacency
         return graph
     else:
         return biadjacency
 
 
-def star_wars(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def star_wars(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Bipartite graph connecting some Star Wars villains to the movies in which they appear.
 
     * Bipartite graph
@@ -380,7 +380,7 @@ def star_wars(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     if metadata:
         villains = np.array(['Jabba', 'Greedo', 'Vader', 'Boba'])
         movies = np.array(['A New Hope', 'The Empire Strikes Back', 'Return Of The Jedi'])
-        graph = Bunch()
+        graph = Dataset()
         graph.biadjacency = biadjacency
         graph.names = villains
         graph.names_row = villains
@@ -391,14 +391,12 @@ def star_wars(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
         return biadjacency
 
 
-def movie_actor(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def movie_actor(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Bipartite graph connecting movies to some actors starring in them.
 
     * Bipartite graph
-    * 31 nodes (15 movies, 16 actors), 42 edges
-    * 9 labels (rows)
+    * 32 nodes (15 movies, 17 actors), 43 edges
     * Names of movies (rows) and actors (columns)
-    * Names of movies production company (rows)
 
     Parameters
     ----------
@@ -407,53 +405,47 @@ def movie_actor(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
 
     Returns
     -------
-    biadjacency or graph : Union[sparse.csr_matrix, Dataset]
-        Biadjacency matrix or graph with metadata (names).
+    biadjacency or dataset : Union[sparse.csr_matrix, Dataset]
+        Biadjacency matrix or dataset with metadata (names of movies and actors).
 
     Example
     -------
     >>> from sknetwork.data import movie_actor
     >>> biadjacency = movie_actor()
     >>> biadjacency.shape
-    (15, 16)
+    (15, 17)
     """
     row = np.array(
         [0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6,
-         6, 6, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11,
+         6, 6, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11,
          12, 12, 12, 13, 13, 14, 14])
     col = np.array(
         [0, 1, 2, 1, 2, 3, 3, 4, 5, 8, 4, 6, 0, 6, 4, 7, 4,
-         7, 8, 3, 8, 9, 10, 11, 12, 15, 0, 11, 12, 9, 10, 13, 5, 9, 13,
-         1, 9, 15, 12, 14, 11, 14])
-    biadjacency = sparse.csr_matrix((np.ones(len(row), dtype=bool), (row, col)), shape=(15, 16))
+         7, 8, 3, 8, 9, 10, 11, 12, 15, 0, 11, 12, 9, 10, 13, 16, 5, 9, 13,
+         1, 9, 15, 12, 14, 14, 16])
+    biadjacency = sparse.csr_matrix((np.ones(len(row), dtype=bool), (row, col)), shape=(15, 17))
 
     if metadata:
         movies = np.array(
             ['Inception', 'The Dark Knight Rises', 'The Big Short', 'Drive', 'The Great Gatsby', 'La La Land',
              'Crazy Stupid Love', 'Vice', 'The Grand Budapest Hotel', 'Aviator', '007 Spectre', 'Inglourious Basterds',
-             'Midnight In Paris', 'Murder on the Orient Express', 'Fantastic Beasts 2'])
+             'Midnight In Paris', 'Murder on the Orient Express', "Pirates of the Caribbean: At World's End"])
         actors = np.array(
             ['Leonardo DiCaprio', 'Marion Cotillard', 'Joseph Gordon Lewitt', 'Christian Bale', 'Ryan Gosling',
              'Brad Pitt', 'Carey Mulligan', 'Emma Stone', 'Steve Carell', 'Lea Seydoux', 'Ralph Fiennes', 'Jude Law',
-             'Willem Dafoe', 'Christophe Waltz', 'Johnny Depp', 'Owen Wilson'])
-        graph = Bunch()
-        graph.biadjacency = biadjacency
-        graph.names = movies
-        graph.names_row = movies
-        graph.names_col = actors
-        graph.labels = np.array([0, 0, 1, 2, 3, 2, 4, 1, 5, 0, 6, 5, 7, 8, 0])
-        graph.labels_name = np.array(['Warner Bros', 'Plan B Entertainment', 'Marc Platt Productions', 'Bazmark Films',
-                                      'Carousel Productions', 'Babelsberg Studios', 'MGM', 'Gravier Productions',
-                                      'Genre Films'])
-        graph.labels_row = graph.labels
-        graph.labels_row_name = graph.labels_name
-        graph.name = 'movie_actor'
-        return graph
+             'Willem Dafoe', 'Christophe Waltz', 'Johnny Depp', 'Owen Wilson', 'Naomie Harris'])
+        dataset = Dataset()
+        dataset.biadjacency = biadjacency
+        dataset.names = movies
+        dataset.names_row = movies
+        dataset.names_col = actors
+        dataset.name = 'movie_actor'
+        return dataset
     else:
         return biadjacency
 
 
-def art_philo_science(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
+def art_philo_science(metadata: bool = False) -> Union[sparse.csr_matrix, Dataset]:
     """Wikipedia links between 30 articles (10 artists, 10 philosophers, 10 scientists).
 
     * Directed graph
@@ -605,7 +597,7 @@ def art_philo_science(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]
         words = np.array(
             ['contribution', 'theory', 'invention', 'time', 'modern',
              'century', 'study', 'logic', 'school', 'author', 'compose'])
-        graph = Bunch()
+        graph = Dataset()
         graph.adjacency = adjacency
         graph.names = names
         graph.position = position

sknetwork/embedding/__init__.py

@@ -2,7 +2,6 @@
 from sknetwork.embedding.base import BaseEmbedding
 from sknetwork.embedding.force_atlas import ForceAtlas
 from sknetwork.embedding.louvain_embedding import LouvainEmbedding
-from sknetwork.embedding.louvain_hierarchy import LouvainNE
 from sknetwork.embedding.random_projection import RandomProjection
 from sknetwork.embedding.spectral import Spectral
 from sknetwork.embedding.spring import Spring

sknetwork/embedding/base.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on Nov, 2019
+Created in November 2019
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 from abc import ABC
-from typing import Union
+from typing import Optional, Union
 
 import numpy as np
 from scipy import sparse
@@ -26,10 +26,19 @@ class BaseEmbedding(Algorithm, ABC):
     embedding_col_ : array, shape = (n_col, n_components)
         Embedding of the columns, for bipartite graphs.
     """
-
     def __init__(self):
         self._init_vars()
 
+    def transform(self) -> np.ndarray:
+        """Return the embedding.
+
+        Returns
+        -------
+        embedding : np.ndarray
+            Embedding.
+        """
+        return self.embedding_
+
     def fit_transform(self, *args, **kwargs) -> np.ndarray:
         """Fit to data and return the embedding. Same parameters as the ``fit`` method.
 
@@ -41,30 +50,22 @@ class BaseEmbedding(Algorithm, ABC):
         self.fit(*args, **kwargs)
         return self.embedding_
 
-    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
-        """Predict the embedding of new nodes.
-
-        Each new node is defined by its adjacency row vector.
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the embedding of nodes.
 
         Parameters
         ----------
-        adjacency_vectors :
-            Adjacency vectors of nodes.
-            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
+        columns : bool
+            If ``True``, return the prediction for columns.
 
         Returns
         -------
-        embedding_vectors : np.ndarray
+        embedding_ : np.ndarray
             Embedding of the nodes.
         """
-        raise NotImplementedError
-
-    def _check_fitted(self):
-        if self.embedding_ is None:
-            raise ValueError("This embedding instance is not fitted yet."
-                             " Call 'fit' with appropriate arguments before using this method.")
-        else:
-            return self
+        if columns:
+            return self.embedding_col_
+        return self.embedding_
 
     @staticmethod
     def _get_regularization(regularization: float, adjacency: sparse.csr_matrix) -> float:
@@ -81,6 +82,9 @@ class BaseEmbedding(Algorithm, ABC):
         self.embedding_row_ = None
         self.embedding_col_ = None
 
+    def _check_fitted(self):
+        return self.embedding_ is not None
+
     def _split_vars(self, shape):
         """Split labels_ into labels_row_ and labels_col_"""
         n_row = shape[0]

sknetwork/embedding/force_atlas.py

@@ -77,6 +77,7 @@ class ForceAtlas(BaseEmbedding):
         self.tolerance = tolerance
         self.speed = speed
         self.speed_max = speed_max
+        self.embedding_ = None
 
     def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray], pos_init: Optional[np.ndarray] = None,
             n_iter: Optional[int] = None) -> 'ForceAtlas':
@@ -155,7 +156,7 @@ class ForceAtlas(BaseEmbedding):
                 if tree is None:
                     neighbors = np.arange(n)
                 else:
-                    neighbors = tree.query_ball_point(position[i], self.approx_radius)
+                    neighbors = tree.query_ball_point(position[i], self.approx_radius, p=2)
 
                 grad: np.ndarray = (position[i] - position[neighbors])  # shape (n_neigh, n_components)
                 distance: np.ndarray = np.linalg.norm(grad, axis=1)  # shape (n_neigh,)
@@ -191,7 +192,7 @@ class ForceAtlas(BaseEmbedding):
 
             position += delta  # calculating displacement and final position of points after iteration
             if (swing_vector < 1).all():
-                break  # if the swing of all nodes is zero, then convergence is reached and we break.
+                break  # if the swing of all nodes is zero, then convergence is reached.
 
         self.embedding_ = position
         return self

sknetwork/embedding/louvain_embedding.py

@@ -12,7 +12,7 @@ from scipy import sparse
 
 from sknetwork.clustering.louvain import Louvain
 from sknetwork.embedding.base import BaseEmbedding
-from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.utils.check import check_random_state, check_adjacency_vector, check_nonnegative, is_square
 from sknetwork.utils.membership import get_membership
 
@@ -146,29 +146,3 @@ class LouvainEmbedding(BaseEmbedding):
             self.embedding_col_ = embedding_col.toarray()
 
         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 row vectors.
-            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
-
-        Returns
-        -------
-        embedding_vectors : np.ndarray
-            Embedding of the nodes.
-        """
-        self._check_fitted()
-        if self.embedding_col_ is not None:
-            n = len(self.embedding_col_)
-        else:
-            n = len(self.embedding_)
-
-        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
-        check_nonnegative(adjacency_vectors)
-        membership = get_membership(self.labels_)
-
-        return normalize(adjacency_vectors).dot(membership)

sknetwork/embedding/random_projection.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 # coding: utf-8
 """
-Created on January, 15 2021
+Created in January 2021
 @author: Thomas Bonald <bonald@enst.fr>
 """
+from abc import ABC
 from typing import Union
 
 import numpy as np
@@ -15,7 +16,7 @@ from sknetwork.utils.check import check_format, check_random_state
 from sknetwork.utils.format import get_adjacency
 
 
-class RandomProjection(BaseEmbedding):
+class RandomProjection(BaseEmbedding, ABC):
     """Embedding of graphs based the random projection of the adjacency matrix:
 
     :math:`(I + \\alpha A +... + (\\alpha A)^K)G`
@@ -71,6 +72,7 @@ class RandomProjection(BaseEmbedding):
                  regularization: float = -1, normalized: bool = True, random_state: int = None):
         super(RandomProjection, self).__init__()
 
+        self.embedding_ = None
         self.n_components = n_components
         self.alpha = alpha
         self.n_iter = n_iter
@@ -87,7 +89,7 @@ class RandomProjection(BaseEmbedding):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
               Adjacency matrix or biadjacency matrix of the graph.
         force_bipartite : bool (default = ``False``)
             If ``True``, force the input matrix to be considered as a biadjacency matrix.

sknetwork/embedding/spectral.py

@@ -139,76 +139,3 @@ class Spectral(BaseEmbedding):
             self._split_vars(input_matrix.shape)
 
         return self
-
-    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
-        """Predict the embedding of new nodes, when possible (otherwise return 0).
-
-        Each new node is defined by its adjacency row vector.
-
-        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.
-
-        Example
-        -------
-        >>> from sknetwork.embedding import Spectral
-        >>> from sknetwork.data import karate_club
-        >>> spectral = Spectral(n_components=3)
-        >>> adjacency = karate_club()
-        >>> adjacency_vector = np.arange(34) < 5
-        >>> _ = spectral.fit(adjacency)
-        >>> len(spectral.predict(adjacency_vector))
-        3
-        """
-        self._check_fitted()
-
-        # input
-        if self.bipartite:
-            n = len(self.embedding_col_)
-        else:
-            n = len(self.embedding_)
-        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
-        check_nonnegative(adjacency_vectors)
-
-        if self.bipartite:
-            shape = (adjacency_vectors.shape[0], self.embedding_row_.shape[0])
-            adjacency_vectors = sparse.csr_matrix(adjacency_vectors)
-            adjacency_vectors = sparse.hstack([sparse.csr_matrix(shape), adjacency_vectors], format='csr')
-        eigenvectors = self.eigenvectors_
-        eigenvalues = self.eigenvalues_
-
-        # regularization
-        if self.regularized:
-            regularization = np.abs(self.regularization)
-        else:
-            regularization = 0
-        normalizer = Normalizer(adjacency_vectors, regularization)
-
-        # prediction
-        embedding_vectors = normalizer.dot(eigenvectors)
-        normalized_laplacian = self.decomposition == 'rw'
-        if normalized_laplacian:
-            norm_vect = eigenvalues.copy()
-            norm_vect[norm_vect == 0] = 1
-            embedding_vectors /= norm_vect
-        else:
-            norm_matrix = sparse.csr_matrix(1 - np.outer(normalizer.norm_diag.data, eigenvalues))
-            norm_matrix.data = 1 / norm_matrix.data
-            embedding_vectors *= norm_matrix.toarray()
-
-        # normalization
-        if self.normalized:
-            embedding_vectors = normalize(embedding_vectors, p=2)
-
-        # shape
-        if len(embedding_vectors) == 1:
-            embedding_vectors = embedding_vectors.ravel()
-
-        return embedding_vectors

sknetwork/embedding/svd.py

@@ -277,10 +277,6 @@ class SVD(GSVD):
                                   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.

sknetwork/embedding/tests/test_API.py

@@ -13,7 +13,6 @@ 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()
@@ -22,44 +21,21 @@ class TestEmbeddings(unittest.TestCase):
         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):
+        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.bimethods:
+            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))
 
-                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)

sknetwork/embedding/tests/test_louvain_embedding.py

@@ -12,22 +12,22 @@ 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(test_graph())
+        louvain.fit(adjacency)
         self.assertEqual(louvain.embedding_.shape[0], 10)
-        louvain.fit(test_graph(), force_bipartite=True)
+        louvain.fit(adjacency, 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)
+        # 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']:
-            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)
-
-
+            louvain = LouvainEmbedding(isolated_nodes=method)
+            embedding = louvain.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[0], adjacency.shape[0])

sknetwork/embedding/tests/test_spectral.py

@@ -22,24 +22,21 @@ class TestEmbeddings(unittest.TestCase):
             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)
+            self.assertAlmostEqual(embedding.shape[0], adjacency.shape[0])
             # Laplacian
             spectral = Spectral(3, decomposition='laplacian', normalized=False)
-            embedding = spectral.fit_transform(adjacency)
+            spectral.fit(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_disconnected_graph()]:

sknetwork/embedding/tests/test_svd.py

@@ -24,13 +24,19 @@ class TestSVD(unittest.TestCase):
         self.assertEqual(gsvd.embedding_row_.shape, (n_row, min_dim))
         self.assertEqual(gsvd.embedding_col_.shape, (n_col, min_dim))
 
+        embedding = gsvd.predict(np.array([0, 1, 1]))
+        self.assertEqual(embedding.shape, (min_dim,))
+
         gsvd = GSVD(n_components=1, regularization=0.1, solver='lanczos')
         gsvd.fit(biadjacency)
-        gsvd.predict(np.random.rand(n_col))
+        self.assertEqual(gsvd.embedding_row_.shape, (n_row, 1))
 
         pca = PCA(n_components=min_dim, solver='lanczos')
         pca.fit(biadjacency)
         self.assertEqual(pca.embedding_row_.shape, (n_row, min_dim))
+        pca = PCA(n_components=min_dim, solver=LanczosSVD())
+        pca.fit(biadjacency)
+        self.assertEqual(pca.embedding_row_.shape, (n_row, min_dim))
 
         svd = SVD(n_components=min_dim, solver=LanczosSVD())
         svd.fit(biadjacency)