scikit-network 0.31.0__cp310-cp310-win_amd64.whl → 0.32.1__cp310-cp310-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/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:

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
 

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_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

@@ -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_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):

sknetwork/gnn/gnn_classifier.py

@@ -4,7 +4,7 @@
 Created in April 2022
 @author: Simon Delarue <sdelarue@enst.fr>
 """
-from typing import Optional, Union
+from typing import Iterable, Optional, Union
 from collections import defaultdict
 
 import numpy as np
@@ -26,35 +26,37 @@ class GNNClassifier(BaseGNN):
 
     Parameters
     ----------
-    dims : list or int
-        Dimensions of the output of each layer (in forward direction).
+    dims : iterable or int
+        Dimension of the output of each layer (in forward direction).
         If an integer, dimension of the output layer (no hidden layer).
         Optional if ``layers`` is specified.
-    layer_types : list or str
+    layer_types : iterable or str
         Layer types (in forward direction).
-        If a string, use the same type of layer for all layers.
+        If a string, the same type is used at each layer.
         Can be ``'Conv'``, graph convolutional layer (default) or ``'Sage'`` (GraphSage).
-    activations : list or str
+    activations : iterable or str
         Activation functions (in forward direction).
-        If a string, use the same activation function for all layers.
+        If a string, the same activation function is used at each layer.
         Can be either ``'Identity'``, ``'Relu'``, ``'Sigmoid'`` or ``'Softmax'`` (default = ``'Relu'``).
-    use_bias : list or bool
-        Whether to use a bias term at each layer.
-        If ``True``, use a bias term at all layers.
-    normalizations : list or str
-        Normalization of the adjacency matrix for message passing.
-        If a string, use the same normalization for all layers.
-        Can be either `'left'`` (left normalization by the degrees), ``'right'`` (right normalization by the degrees),
+    use_bias : iterable or bool
+        Whether to add a bias term at each layer (in forward direction).
+        If ``True``, use a bias term at each layer.
+    normalizations : iterable or str
+        Normalizations of the adjacency matrix for message passing (in forward direction).
+        If a string, the same type of normalization is used at each layer.
+        Can be either ``'left'`` (left normalization by the degrees), ``'right'`` (right normalization by the degrees),
         ``'both'`` (symmetric normalization by the square root of degrees, default) or ``None`` (no normalization).
-    self_embeddings : list or str
-        Whether to add a self embeddings to each node of the graph for message passing.
-        If ``True``, add self-embeddings at all layers.
-    sample_sizes : list or int
-        Size of neighborhood sampled for each node. Used only for ``'Sage'`` layer type.
+    self_embeddings : iterable or str
+        Whether to add the embedding to each node for message passing (in forward direction).
+        If ``True``, add a self-embedding at each layer.
+    sample_sizes : iterable or int
+        Sizes of neighborhood sampled for each node (in forward direction).
+        If an integer, the same sampling size is used at each layer.
+        Used only for ``'Sage'`` layer type.
     loss : str (default = ``'CrossEntropy'``) or BaseLoss
-        Loss function name or custom loss.
-    layers : list or None
-        Custom layers. If used, previous parameters are ignored.
+        Name of loss function or custom loss function.
+    layers : iterable or None
+        Custom layers (in forward directions). If used, previous parameters are ignored.
     optimizer : str or optimizer
         * ``'Adam'``, stochastic gradient-based optimizer (default).
         * ``'GD'``, gradient descent.
@@ -72,7 +74,7 @@ class GNNClassifier(BaseGNN):
     ----------
     conv2, ..., conv1: :class:'GCNConv'
         Graph convolutional layers.
-    output_ : array
+    output_ : np.ndarray
         Output of the GNN.
     labels_: np.ndarray
         Predicted node labels.
@@ -95,11 +97,11 @@ class GNNClassifier(BaseGNN):
     0.88
     """
 
-    def __init__(self, dims: Optional[Union[int, list]] = None, layer_types: Union[str, list] = 'Conv',
-                 activations: Union[str, list] = 'ReLu', use_bias: Union[bool, list] = True,
-                 normalizations: Union[str, list] = 'both', self_embeddings: Union[bool, list] = True,
+    def __init__(self, dims: Optional[Union[int, Iterable]] = None, layer_types: Union[str, Iterable] = 'Conv',
+                 activations: Union[str, Iterable] = 'ReLu', use_bias: Union[bool, list] = True,
+                 normalizations: Union[str, Iterable] = 'both', self_embeddings: Union[bool, Iterable] = True,
                  sample_sizes: Union[int, list] = 25, loss: Union[BaseLoss, str] = 'CrossEntropy',
-                 layers: Optional[list] = None, optimizer: Union[BaseOptimizer, str] = 'Adam',
+                 layers: Optional[Iterable] = None, optimizer: Union[BaseOptimizer, str] = 'Adam',
                  learning_rate: float = 0.01, early_stopping: bool = True, patience: int = 10, verbose: bool = False):
         super(GNNClassifier, self).__init__(loss, optimizer, learning_rate, verbose)
         if layers is not None:
@@ -159,7 +161,7 @@ class GNNClassifier(BaseGNN):
 
     def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray], features: Union[sparse.csr_matrix, np.ndarray],
             labels: np.ndarray, n_epochs: int = 100, validation: float = 0, reinit: bool = False,
-            random_state: Optional[int] = None, history: bool = False) -> 'GNNClassifier':
+            random_state: Optional[int] = None) -> 'GNNClassifier':
         """ Fit model to data and store trained parameters.
 
         Parameters
@@ -169,8 +171,8 @@ class GNNClassifier(BaseGNN):
         features : sparse.csr_matrix, np.ndarray
             Input feature of shape :math:`(n, d)` with :math:`n` the number of nodes in the graph and :math:`d`
             the size of feature space.
-        labels :
-            Known labels (dictionary or vector of int). Negative values ignored.
+        labels : dict, np.ndarray
+            Known labels. Negative values ignored.
         n_epochs : int (default = 100)
             Number of epochs (iterations over the whole graph).
         validation : float
@@ -179,18 +181,17 @@ class GNNClassifier(BaseGNN):
             If ``True``, reinit the trainable parameters of the GNN (weights and biases).
         random_state : int
             Random seed, used for reproducible results across multiple runs.
-        history : bool (default = ``False``)
-            If ``True``, save training history.
         """
         if reinit:
             for layer in self.layers:
                 layer.weights_initialized = False
+            self.history_ = defaultdict(list)
 
         if random_state is not None:
             np.random.seed(random_state)
 
-        check_format(adjacency)
-        check_format(features)
+        check_format(adjacency, allow_empty=True)
+        check_format(features, allow_empty=True)
 
         labels = get_values(adjacency.shape, labels)
         labels = labels.astype(int)
@@ -199,7 +200,7 @@ class GNNClassifier(BaseGNN):
         check_output(self.layers[-1].out_channels, labels)
 
         self.train_mask = labels >= 0
-        if 0 < validation < 1:
+        if self.val_mask is None and 0 < validation < 1:
             mask = np.random.random(size=len(labels)) < validation
             self.val_mask = self.train_mask & mask
             self.train_mask &= ~mask
@@ -237,12 +238,10 @@ class GNNClassifier(BaseGNN):
             self.optimizer.step(self)
 
             # Save results
-            if history:
-                self.history_['embedding'].append(self.layers[-1].embedding)
-                self.history_['loss'].append(loss_value)
-                self.history_['train_accuracy'].append(train_accuracy)
-                if val_accuracy is not None:
-                    self.history_['val_accuracy'].append(val_accuracy)
+            self.history_['loss'].append(loss_value)
+            self.history_['train_accuracy'].append(train_accuracy)
+            if val_accuracy is not None:
+                self.history_['val_accuracy'].append(val_accuracy)
 
             if n_epochs > 10 and epoch % int(n_epochs / 10) == 0:
                 if val_accuracy is not None:
@@ -304,48 +303,3 @@ class GNNClassifier(BaseGNN):
                 adjacencies.append(adjacency)
 
         return adjacencies
-
-    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray] = None,
-                feature_vectors: Union[sparse.csr_matrix, np.ndarray] = None) -> np.ndarray:
-        """Predict labels for new nodes. If called without parameters, labels are returned for all nodes.
-
-        Parameters
-        ----------
-        adjacency_vectors : np.ndarray
-            Square adjacency matrix. Array of shape (n, n).
-        feature_vectors : np.ndarray
-            Features row vectors. Array of shape (n, n_feat). The number of features n_feat must match with the one
-            used during training.
-
-        Returns
-        -------
-        labels : np.ndarray
-            Label of each node of the graph.
-        """
-        self._check_fitted()
-
-        if adjacency_vectors is None and feature_vectors is None:
-            return self.labels_
-        elif adjacency_vectors is not None and feature_vectors is None:
-            raise ValueError('Missing value: feature matrix is missing.')
-        elif adjacency_vectors is None:
-            adjacency_vectors = sparse.identity(feature_vectors.shape[0], format='csr')
-
-        check_square(adjacency_vectors)
-        check_nonnegative(adjacency_vectors)
-        feature_vectors = check_format(feature_vectors)
-
-        n_row, n_col = adjacency_vectors.shape
-        feat_row, feat_col = feature_vectors.shape
-
-        if n_col != feat_row:
-            raise ValueError(f'Dimension mismatch: dim0={n_col} != dim1={feat_row}.')
-        elif feat_col != self.layers[0].weight.shape[0]:
-            raise ValueError(f'Dimension mismatch: current number of features is {feat_col} whereas GNN has been '
-                             f'trained with '
-                             f'{self.layers[0].weight.shape[0]} features.')
-
-        h = self.forward(adjacency_vectors, feature_vectors)
-        labels = self._compute_predictions(h)
-
-        return labels

sknetwork/gnn/layer.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # coding: utf-8
 """
-Created on Thu Apr 21 2022
+Created in April 2022
 @author: Simon Delarue <sdelarue@enst.fr>
 """
 from typing import Optional, Union

sknetwork/gnn/loss.py

@@ -53,7 +53,7 @@ class CrossEntropy(BaseLoss, Softmax):
         probs = Softmax.output(signal)
 
         # for numerical stability
-        eps = 1e-15
+        eps = 1e-10
         probs = np.clip(probs, eps, 1 - eps)
 
         value = -np.log(probs[np.arange(n), labels]).sum()