scikit-network 0.31.0__cp311-cp311-win_amd64.whl → 0.33.0__cp311-cp311-win_amd64.whl

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.
@@ -91,15 +93,15 @@ class GNNClassifier(BaseGNN):
     >>> features = adjacency.copy()
     >>> gnn = GNNClassifier(dims=1, early_stopping=False)
     >>> labels_pred = gnn.fit_predict(adjacency, features, labels, random_state=42)
-    >>> np.round(np.mean(labels_pred == labels_true), 2)
+    >>> round(np.mean(labels_pred == labels_true), 2)
     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()

sknetwork/gnn/optimizer.py

@@ -130,9 +130,10 @@ class ADAM(BaseOptimizer):
             layer.weight = \
                 layer.weight - (self.learning_rate * m_derivative_weight_corr) / (np.sqrt(v_derivative_weight_corr)
                                                                                   + self.eps)
-            layer.bias = \
-                layer.bias - (self.learning_rate * m_derivative_bias_corr) / (np.sqrt(v_derivative_bias_corr)
-                                                                              + self.eps)
+            if layer.use_bias:
+                layer.bias = \
+                    layer.bias - (self.learning_rate * m_derivative_bias_corr) / (np.sqrt(v_derivative_bias_corr)
+                                                                                  + self.eps)
 
 
 def get_optimizer(optimizer: Union[BaseOptimizer, str] = 'Adam', learning_rate: float = 0.01) -> BaseOptimizer:

sknetwork/gnn/tests/test_base_layer.py

@@ -27,11 +27,11 @@ class TestBaseLayer(unittest.TestCase):
     def test_base_layer_initialize_weights(self):
         self.base_layer._initialize_weights(10)
         self.assertTrue(self.base_layer.weight.shape == (10, len(self.labels)))
-        self.assertTrue(all(self.base_layer.bias[0] == np.zeros((len(self.labels), 1)).T[0]))
+        self.assertTrue(self.base_layer.bias.shape == (1, len(self.labels)))
         self.assertTrue(self.base_layer.weights_initialized)
 
     def test_base_layer_repr(self):
         self.assertTrue(self.base_layer.__repr__().startswith("  BaseLayer(layer_type: Conv, out_channels: 10"))
-        sagelayer = BaseLayer(layer_type='sageconv', out_channels=len(self.labels))
-        self.assertTrue('sample_size' in sagelayer.__repr__())
-        self.assertTrue('sageconv' in sagelayer.__repr__())
+        sage_layer = BaseLayer(layer_type='sageconv', out_channels=len(self.labels))
+        self.assertTrue('sample_size' in sage_layer.__repr__())
+        self.assertTrue('sageconv' in sage_layer.__repr__())

sknetwork/gnn/tests/test_gnn_classifier.py

@@ -44,6 +44,14 @@ class TestGNNClassifier(unittest.TestCase):
         self.assertTrue(len(y_pred) == self.n)
         self.assertTrue(embedding.shape == (self.n, 2))
 
+    def test_gnn_classifier_no_bias(self):
+        gnn = GNNClassifier([3, 2], 'Conv', 'Softmax', use_bias=[True, False])
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+        embedding = gnn.embedding_
+        self.assertTrue(len(labels_pred) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+        self.assertTrue(gnn.layers[1].bias is None)
+
     def test_gnn_classifier_optimizer(self):
         optimizers = ['GD', 'Adam']
         for optimizer in optimizers:
@@ -88,23 +96,20 @@ class TestGNNClassifier(unittest.TestCase):
     def test_gnn_classifier_early_stopping(self):
         gnn = GNNClassifier(2, patience=2)
         labels = {0: 0, 1: 1}
-        _ = gnn.fit_predict(self.adjacency, self.features, labels, n_epochs=100, history=True, validation=0.5,
+        _ = gnn.fit_predict(self.adjacency, self.features, labels, n_epochs=100, validation=0.5,
                             random_state=42)
         self.assertTrue(len(gnn.history_['val_accuracy']) < 100)
 
         gnn = GNNClassifier(2, early_stopping=False)
-        _ = gnn.fit_predict(self.adjacency, self.features, labels, n_epochs=100, history=True, validation=0.5,
+        _ = gnn.fit_predict(self.adjacency, self.features, labels, n_epochs=100, validation=0.5,
                             random_state=42)
         self.assertTrue(len(gnn.history_['val_accuracy']) == 100)
 
     def test_gnn_classifier_reinit(self):
         gnn = GNNClassifier([4, 2])
-        gnn.fit(self.adjacency, self.features, self.labels, reinit=False)
-        weights = [layer.weight for layer in gnn.layers]
-        biases = [layer.bias for layer in gnn.layers]
+        gnn.fit(self.adjacency, self.features, self.labels)
         gnn.fit(self.adjacency, self.features, self.labels, n_epochs=1, reinit=True)
-        self.assertTrue(all([np.all(weight != layer.weight) for weight, layer in zip(weights, gnn.layers)]))
-        self.assertTrue(all([np.all(bias != layer.bias) for bias, layer in zip(biases, gnn.layers)]))
+        self.assertTrue(gnn.embedding_.shape == (self.n, 2))
 
     def test_gnn_classifier_sageconv(self):
         gnn = GNNClassifier([4, 2], ['SAGEConv', 'SAGEConv'], sample_sizes=[5, 3])
@@ -119,38 +124,6 @@ class TestGNNClassifier(unittest.TestCase):
         self.assertTrue(all(labels_pred == gnn.labels_))
         self.assertTrue(all(labels_pred == labels_pred_))
 
-        # Predict same nodes
-        labels_pred_ = gnn.predict(self.adjacency, self.features)
-        self.assertTrue(all(labels_pred_ == gnn.labels_))
-
-        # Incorrect shapes
-        new_n = sparse.csr_matrix(np.random.randint(2, size=self.features.shape[1]))
-        new_feat = sparse.csr_matrix(np.random.randint(3, size=self.features.shape[1]))
-        with self.assertRaises(ValueError):
-            gnn.predict(new_n, self.features)
-        with self.assertRaises(ValueError):
-            gnn.predict(self.adjacency, new_feat)
-
-        new_feat = sparse.csr_matrix(np.random.rand(self.adjacency.shape[0], self.features.shape[1] - 1))
-        with self.assertRaises(ValueError):
-            gnn.predict(self.adjacency, new_feat)
-
-        # Predict new graph
-        n = 4
-        n_feat = self.features.shape[1]
-        adjacency = sparse.csr_matrix(np.random.randint(2, size=(n, n)))
-        features = sparse.csr_matrix(np.random.randint(2, size=(n, n_feat)))
-        labels_pred = gnn.predict(adjacency, features)
-        self.assertTrue(len(labels_pred) == n)
-
-        # No adj matrix
-        labels_pred = gnn.predict(None, features)
-        self.assertTrue(len(labels_pred) == features.shape[0])
-
-        # No feature matrix
-        with self.assertRaises(ValueError):
-            gnn.predict(new_n)
-
     def test_gnn_classifier_predict_proba(self):
         gnn = GNNClassifier([4, 2])
         probs = gnn.fit_predict_proba(self.adjacency, self.features, self.labels)

sknetwork/gnn/utils.py

@@ -1,10 +1,10 @@
 #!/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 Union
+from typing import Iterable, Union
 
 import numpy as np
 
@@ -22,7 +22,7 @@ def check_early_stopping(early_stopping: bool, val_mask: np.ndarray, patience: i
         return early_stopping
 
 
-def check_normalizations(normalizations: Union[str, list]):
+def check_normalizations(normalizations: Union[str, Iterable]):
     """Check if normalization is known."""
     available_norms = ['left', 'right', 'both']
     if isinstance(normalizations, list):
@@ -69,10 +69,10 @@ def check_loss(layer: BaseLayer):
     return layer.activation
 
 
-def get_layers(dims: Union[int, list], layer_types: Union[str, BaseLayer, list],
-               activations: Union[str, BaseActivation, list], use_bias: Union[bool, list],
-               normalizations: Union[str, list], self_embeddings: Union[bool, list], sample_sizes: Union[int, list],
-               loss: Union[str, BaseLoss]) -> list:
+def get_layers(dims: Union[int, Iterable], layer_types: Union[str, BaseLayer, Iterable],
+               activations: Union[str, BaseActivation, list], use_bias: Union[bool, Iterable],
+               normalizations: Union[str, Iterable], self_embeddings: Union[bool, Iterable],
+               sample_sizes: Union[int, Iterable], loss: Union[str, BaseLoss]) -> list:
     """Get the list of layers.
 
     Parameters
@@ -101,7 +101,7 @@ def get_layers(dims: Union[int, list], layer_types: Union[str, BaseLayer, list],
     """
     check_normalizations(normalizations)
 
-    if not isinstance(dims, list):
+    if isinstance(dims, int):
         dims = [dims]
     n_layers = len(dims)
 

sknetwork/hierarchy/base.py

@@ -29,6 +29,33 @@ class BaseHierarchy(Algorithm, ABC):
     def __init__(self):
         self._init_vars()
 
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the dendrogram predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        dendrogram : np.ndarray
+            Dendrogram.
+        """
+        if columns:
+            return self.dendrogram_col_
+        return self.dendrogram_
+
+    def transform(self) -> np.ndarray:
+        """Return the dendrogram predicted by the algorithm.
+
+        Returns
+        -------
+        dendrogram : np.ndarray
+            Dendrogram.
+        """
+        return self.dendrogram_
+
     def fit_predict(self, *args, **kwargs) -> np.ndarray:
         """Fit algorithm to data and return the dendrogram. Same parameters as the ``fit`` method.