scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/data/tests/test_parse.py

@@ -20,6 +20,10 @@ class TestParser(unittest.TestCase):
         self.assertTrue((adjacency.indices == [2, 3, 0, 1, 5, 4]).all())
         self.assertTrue((adjacency.indptr == [0, 1, 2, 3, 4, 5, 6]).all())
         self.assertTrue((adjacency.data == [1, 1, 1, 1, 1, 1]).all())
+        adjacency = parse.from_csv(self.stub_data_1, shape=(7, 7))
+        self.assertTrue((adjacency.shape == (7, 7)))
+        biadjacency = parse.from_csv(self.stub_data_1, bipartite=True, shape=(7, 9))
+        self.assertTrue((biadjacency.shape == (7, 9)))
         remove(self.stub_data_1)
 
     def test_labeled_weighted(self):
@@ -33,13 +37,14 @@ class TestParser(unittest.TestCase):
         self.assertTrue((adjacency.indptr == [0, 1, 2, 3, 4, 5, 6]).all())
         self.assertTrue((adjacency.data == [1, 6, 5, 6, 1, 5]).all())
         self.assertTrue((names == [' b', ' d', ' e', 'a', 'c', 'f']).all())
+
         remove(self.stub_data_2)
 
     def test_auto_reindex(self):
         self.stub_data_4 = 'stub_4.txt'
         with open(self.stub_data_4, "w") as text_file:
             text_file.write('%stub\n14 31\n42 50\n0 12')
-        graph = parse.from_csv(self.stub_data_4)
+        graph = parse.from_csv(self.stub_data_4, reindex=True)
         adjacency = graph.adjacency
         names = graph.names
         self.assertTrue((adjacency.data == [1, 1, 1, 1, 1, 1]).all())
@@ -164,23 +169,15 @@ class TestParser(unittest.TestCase):
         self.stub_data_9 = 'stub_9.txt'
         with open(self.stub_data_9, "w") as text_file:
             text_file.write('#stub\n1 3\n4 5\n0 3')
-        graph = parse.from_csv(self.stub_data_9, bipartite=True)
+        graph = parse.from_csv(self.stub_data_9, bipartite=True, reindex=True)
         biadjacency = graph.biadjacency
         self.assertTrue((biadjacency.indices == [0, 0, 1]).all())
         self.assertTrue((biadjacency.indptr == [0, 1, 2, 3]).all())
         self.assertTrue((biadjacency.data == [1, 1, 1]).all())
+        biadjacency = parse.from_csv(self.stub_data_9, bipartite=True)
+        self.assertTrue(biadjacency.shape == (5, 6))
         remove(self.stub_data_9)
 
-    def test_csv_adjacency_bipartite(self):
-        self.stub_data_10 = 'stub_10.txt'
-        with open(self.stub_data_10, "w") as text_file:
-            text_file.write('%stub\n3\n3\n0')
-        graph = parse.from_csv(self.stub_data_10, bipartite=True)
-        biadjacency = graph.biadjacency
-        self.assertTupleEqual(biadjacency.shape, (3, 2))
-        self.assertTrue((biadjacency.data == [1, 1, 1]).all())
-        remove(self.stub_data_10)
-
     def test_edge_list(self):
         edge_list_1 = [('Alice', 'Bob'), ('Carol', 'Alice')]
         graph = parse.from_edge_list(edge_list_1)

sknetwork/data/tests/test_test_graphs.py

@@ -5,7 +5,6 @@
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 @author: Thomas Bonald <tbonald@enst.fr>
 """
-
 import unittest
 
 from sknetwork.data.test_graphs import *
@@ -16,7 +15,7 @@ class TestTestGraphs(unittest.TestCase):
     def test_undirected(self):
         adjacency = test_graph()
         self.assertEqual(adjacency.shape, (10, 10))
-        adjacency = test_graph_disconnect()
+        adjacency = test_disconnected_graph()
         self.assertEqual(adjacency.shape, (10, 10))
 
     def test_directed(self):

sknetwork/data/toy_graphs.py

@@ -11,7 +11,7 @@ from typing import Union
 import numpy as np
 from scipy import sparse
 
-from sknetwork.utils import Bunch
+from sknetwork.data.base import Bunch
 
 
 def house(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
@@ -23,11 +23,11 @@ def house(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (positions).
 
     Example
@@ -64,11 +64,11 @@ def bow_tie(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (positions).
 
     Example
@@ -105,11 +105,11 @@ def karate_club(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (labels, positions).
 
     Example
@@ -170,11 +170,11 @@ def miserables(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (names, positions).
 
     Example
@@ -277,11 +277,11 @@ def painters(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (names, positions).
 
     Example
@@ -330,7 +330,7 @@ def hourglass(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
 
     Returns
     -------
-    biadjacency or graph : Union[sparse.csr_matrix, Bunch]
+    biadjacency or graph : Union[sparse.csr_matrix, Dataset]
         Biadjacency matrix or graph.
 
     Example
@@ -359,11 +359,11 @@ def star_wars(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    biadjacency or graph : Union[sparse.csr_matrix, Bunch]
+    biadjacency or graph : Union[sparse.csr_matrix, Dataset]
         Biadjacency matrix or graph with metadata (names).
 
     Example
@@ -403,11 +403,11 @@ def movie_actor(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]:
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    biadjacency or graph : Union[sparse.csr_matrix, Bunch]
+    biadjacency or graph : Union[sparse.csr_matrix, Dataset]
         Biadjacency matrix or graph with metadata (names).
 
     Example
@@ -465,11 +465,11 @@ def art_philo_science(metadata: bool = False) -> Union[sparse.csr_matrix, Bunch]
     Parameters
     ----------
     metadata :
-        If ``True``, return a `Bunch` object with metadata.
+        If ``True``, return a `Dataset` object with metadata.
 
     Returns
     -------
-    adjacency or graph : Union[sparse.csr_matrix, Bunch]
+    adjacency or graph : Union[sparse.csr_matrix, Dataset]
         Adjacency matrix or graph with metadata (names, positions, labels, names_labels,
         biadjacency, names_col).
 

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,17 +1,17 @@
 #!/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
 
 from sknetwork.topology.structure import is_connected
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class BaseEmbedding(Algorithm, ABC):
@@ -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:

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
 
@@ -121,7 +121,7 @@ class LouvainEmbedding(BaseEmbedding):
         louvain = Louvain(resolution=self.resolution, modularity=self.modularity,
                           tol_optimization=self.tol_optimization, tol_aggregation=self.tol_aggregation,
                           n_aggregations=self.n_aggregations, shuffle_nodes=self.shuffle_nodes, sort_clusters=False,
-                          return_membership=True, return_aggregate=True, random_state=self.random_state)
+                          return_probs=True, return_aggregate=True, random_state=self.random_state)
         louvain.fit(input_matrix, force_bipartite=force_bipartite)
 
         # isolated nodes

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/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,17 @@ from sknetwork.embedding import LouvainEmbedding
 class TestLouvainEmbedding(unittest.TestCase):
 
     def test_predict(self):
+        adjacency = test_graph()
         louvain = LouvainEmbedding()
         louvain.fit(test_graph())
         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)
+            embedding = louvain.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[0], adjacency.shape[0])
 
-        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_random_projection.py

@@ -3,7 +3,7 @@
 """Tests for random projection"""
 import unittest
 
-from sknetwork.data.test_graphs import test_graph, test_bigraph, test_digraph, test_graph_disconnect
+from sknetwork.data.test_graphs import test_graph, test_bigraph, test_digraph, test_disconnected_graph
 from sknetwork.embedding import RandomProjection
 
 
@@ -19,7 +19,7 @@ class TestEmbeddings(unittest.TestCase):
             adjacency = test_digraph()
             embedding = algo.fit_transform(adjacency)
             self.assertEqual(embedding.shape[1], 2)
-            adjacency = test_graph_disconnect()
+            adjacency = test_disconnected_graph()
             embedding = algo.fit_transform(adjacency)
             self.assertEqual(embedding.shape[1], 2)
             biadjacency = test_bigraph()

sknetwork/embedding/tests/test_spectral.py

@@ -13,7 +13,7 @@ from sknetwork.utils.format import bipartite2undirected
 class TestEmbeddings(unittest.TestCase):
 
     def test_undirected(self):
-        for adjacency in [test_graph(), test_graph_disconnect()]:
+        for adjacency in [test_graph(), test_disconnected_graph()]:
             n = adjacency.shape[0]
             # random walk
             spectral = Spectral(3, normalized=False)
@@ -22,27 +22,24 @@ 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_graph_disconnect()]:
+        for adjacency in [test_graph(), test_disconnected_graph()]:
             n = adjacency.shape[0]
             # random walk
             regularization = 0.1
@@ -78,7 +75,7 @@ class TestEmbeddings(unittest.TestCase):
             self.assertAlmostEqual(np.linalg.norm(embedding_full.sum(axis=0)), 0)
 
     def test_normalization(self):
-        for adjacency in [test_graph(), test_graph_disconnect()]:
+        for adjacency in [test_graph(), test_disconnected_graph()]:
             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)

sknetwork/embedding/tests/test_svd.py

@@ -26,7 +26,7 @@ class TestSVD(unittest.TestCase):
 
         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)

sknetwork/gnn/base.py

@@ -15,11 +15,11 @@ from scipy import sparse
 
 from sknetwork.gnn.loss import BaseLoss, get_loss
 from sknetwork.gnn.optimizer import BaseOptimizer, get_optimizer
-from sknetwork.utils.verbose import VerboseMixin
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
+from sknetwork.log import Log
 
 
-class BaseGNN(Algorithm, ABC, VerboseMixin):
+class BaseGNN(ABC, Algorithm, Log):
     """Base class for GNNs.
 
     Parameters
@@ -47,7 +47,7 @@ class BaseGNN(Algorithm, ABC, VerboseMixin):
     """
     def __init__(self, loss: Union[BaseLoss, str] = 'CrossEntropy', optimizer: Union[BaseOptimizer, str] = 'Adam',
                  learning_rate: float = 0.01, verbose: bool = False):
-        VerboseMixin.__init__(self, verbose)
+        Log.__init__(self, verbose)
         self.optimizer = get_optimizer(optimizer, learning_rate)
         self.loss = get_loss(loss)
         self.layers = []

sknetwork/gnn/base_layer.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on July 2022
+Created in July 2022
 @author: Simon Delarue <sdelarue@enst.fr>
 """
 from typing import Optional, Union
@@ -73,10 +73,10 @@ class BaseLayer:
         in_channels: int
             Number of input channels.
         """
-        # Trainable parameters with He initialization
+        # He initialization
         self.weight = np.random.randn(in_channels, self.out_channels) * np.sqrt(2 / self.out_channels)
         if self.use_bias:
-            self.bias = np.zeros((self.out_channels, 1)).T
+            self.bias = np.zeros((1, self.out_channels))
         self.weights_initialized = True
 
     def forward(self, *args, **kwargs):