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

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.
 

sknetwork/hierarchy/louvain_hierarchy.py

@@ -22,34 +22,34 @@ class LouvainIteration(BaseHierarchy):
 
     Parameters
     ----------
-    depth :
+    depth : int
         Depth of the tree.
         A negative value is interpreted as no limit (return a tree of maximum depth).
-    resolution :
+    resolution : float
         Resolution parameter.
-    tol_optimization :
+    tol_optimization : float
         Minimum increase in the objective function to enter a new optimization pass.
-    tol_aggregation :
+    tol_aggregation : float
         Minimum increase in the objective function to enter a new aggregation pass.
-    n_aggregations :
+    n_aggregations : int
         Maximum number of aggregations.
         A negative value is interpreted as no limit.
-    shuffle_nodes :
-        Enables node shuffling before optimization.
-    random_state :
+    shuffle_nodes : bool
+        If ``True``,  shuffle nodes before optimization.
+    random_state : int
         Random number generator or random seed. If ``None``, numpy.random is used.
-    verbose :
+    verbose : bool
         Verbose mode.
 
     Attributes
     ----------
-    dendrogram_ :
+    dendrogram_ : np.ndarray
         Dendrogram of the graph.
-    dendrogram_row_ :
+    dendrogram_row_ : np.ndarray
         Dendrogram for the rows, for bipartite graphs.
-    dendrogram_col_ :
+    dendrogram_col_ : np.ndarray
         Dendrogram for the columns, for bipartite graphs.
-    dendrogram_full_ :
+    dendrogram_full_ : np.ndarray
         Dendrogram for both rows and columns, indexed in this order, for bipartite graphs.
 
     Example
@@ -59,10 +59,10 @@ class LouvainIteration(BaseHierarchy):
     >>> louvain = LouvainIteration()
     >>> adjacency = house()
     >>> louvain.fit_predict(adjacency)
-    array([[3., 2., 0., 2.],
-           [4., 1., 0., 2.],
-           [6., 0., 0., 3.],
-           [5., 7., 1., 5.]])
+    array([[3., 2., 1., 2.],
+           [4., 1., 1., 2.],
+           [6., 0., 1., 3.],
+           [5., 7., 2., 5.]])
 
     Notes
     -----
@@ -71,6 +71,7 @@ class LouvainIteration(BaseHierarchy):
     See Also
     --------
     scipy.cluster.hierarchy.dendrogram
+    sknetwork.clustering.Louvain
     """
 
     def __init__(self, depth: int = 3, resolution: float = 1, tol_optimization: float = 1e-3,
@@ -91,11 +92,11 @@ class LouvainIteration(BaseHierarchy):
 
         Parameters
         ----------
-        adjacency :
+        adjacency : sparse.csr_matrix, np.ndarray
             Adjacency matrix of the graph.
-        depth :
+        depth : int
             Depth of the recursion.
-        nodes :
+        nodes : np.ndarray
             The indices of the current nodes in the original graph.
 
         Returns
@@ -132,7 +133,7 @@ class LouvainIteration(BaseHierarchy):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
 
         Returns
@@ -145,7 +146,7 @@ class LouvainIteration(BaseHierarchy):
         tree = self._recursive_louvain(adjacency, self.depth)
         dendrogram, _ = get_dendrogram(tree)
         dendrogram = np.array(dendrogram)
-        dendrogram[:, 2] -= min(dendrogram[:, 2])
+        dendrogram[:, 2] += 1 - min(dendrogram[:, 2])
         self.dendrogram_ = reorder_dendrogram(dendrogram)
         if self.bipartite:
             self._split_vars(input_matrix.shape)
@@ -155,30 +156,32 @@ class LouvainIteration(BaseHierarchy):
 class LouvainHierarchy(BaseHierarchy):
     """Hierarchical clustering by Louvain (bottom-up).
 
+    Each level corresponds to an aggregation step of the Louvain algorithm.
+
     Parameters
     ----------
-    resolution :
+    resolution : float
         Resolution parameter.
-    tol_optimization :
+    tol_optimization : float
         Minimum increase in the objective function to enter a new optimization pass.
-    tol_aggregation :
+    tol_aggregation : float
         Minimum increase in the objective function to enter a new aggregation pass.
-    shuffle_nodes :
-        Enables node shuffling before optimization.
-    random_state :
+    shuffle_nodes : bool
+        If ``True``, shuffle nodes before optimization.
+    random_state : int
         Random number generator or random seed. If ``None``, numpy.random is used.
-    verbose :
+    verbose : bool
         Verbose mode.
 
     Attributes
     ----------
-    dendrogram_ :
+    dendrogram_ : np.ndarray
         Dendrogram of the graph.
-    dendrogram_row_ :
+    dendrogram_row_ : np.ndarray
         Dendrogram for the rows, for bipartite graphs.
-    dendrogram_col_ :
+    dendrogram_col_ : np.ndarray
         Dendrogram for the columns, for bipartite graphs.
-    dendrogram_full_ :
+    dendrogram_full_ : np.ndarray
         Dendrogram for both rows and columns, indexed in this order, for bipartite graphs.
 
     Example
@@ -188,10 +191,10 @@ class LouvainHierarchy(BaseHierarchy):
     >>> louvain = LouvainHierarchy()
     >>> adjacency = house()
     >>> louvain.fit_predict(adjacency)
-    array([[3., 2., 0., 2.],
-           [4., 1., 0., 2.],
-           [6., 0., 0., 3.],
-           [5., 7., 1., 5.]])
+    array([[3., 2., 1., 2.],
+           [4., 1., 1., 2.],
+           [6., 0., 1., 3.],
+           [5., 7., 2., 5.]])
 
     Notes
     -----
@@ -200,6 +203,7 @@ class LouvainHierarchy(BaseHierarchy):
     See Also
     --------
     scipy.cluster.hierarchy.dendrogram
+    sknetwork.clustering.Louvain
     """
 
     def __init__(self, resolution: float = 1, tol_optimization: float = 1e-3,
@@ -218,7 +222,7 @@ class LouvainHierarchy(BaseHierarchy):
 
         Parameters
         ----------
-        adjacency :
+        adjacency : sparse.csr_matrix, np.ndarray
             Adjacency matrix of the graph.
 
         Returns
@@ -244,12 +248,12 @@ class LouvainHierarchy(BaseHierarchy):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
 
         Returns
         -------
-        self: :class:`LouvainIteration`
+        self: :class:`LouvainHierarchy`
         """
         self._init_vars()
         input_matrix = check_format(input_matrix)
@@ -257,7 +261,7 @@ class LouvainHierarchy(BaseHierarchy):
         tree = self._get_hierarchy(adjacency)
         dendrogram, _ = get_dendrogram(tree)
         dendrogram = np.array(dendrogram)
-        dendrogram[:, 2] -= min(dendrogram[:, 2])
+        dendrogram[:, 2] += 1 - min(dendrogram[:, 2])
         self.dendrogram_ = reorder_dendrogram(dendrogram)
         if self.bipartite:
             self._split_vars(input_matrix.shape)