scikit-network 0.30.0__cp310-cp310-win_amd64.whl → 0.32.1__cp310-cp310-win_amd64.whl

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,28 +238,26 @@ 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:
-                    self.log.print(
+                    self.print_log(
                         f'In epoch {epoch:>3}, loss: {loss_value:.3f}, train accuracy: {train_accuracy:.3f}, '
                         f'val accuracy: {val_accuracy:.3f}')
                 else:
-                    self.log.print(
+                    self.print_log(
                         f'In epoch {epoch:>3}, loss: {loss_value:.3f}, train accuracy: {train_accuracy:.3f}')
             elif n_epochs <= 10:
                 if val_accuracy is not None:
-                    self.log.print(
+                    self.print_log(
                         f'In epoch {epoch:>3}, loss: {loss_value:.3f}, train accuracy: {train_accuracy:.3f}, '
                         f'val accuracy: {val_accuracy:.3f}')
                 else:
-                    self.log.print(
+                    self.print_log(
                         f'In epoch {epoch:>3}, loss: {loss_value:.3f}, train accuracy: {train_accuracy:.3f}')
 
             # Early stopping
@@ -269,7 +268,7 @@ class GNNClassifier(BaseGNN):
                 else:
                     count += 1
                     if count >= self.patience:
-                        self.log.print('Early stopping.')
+                        self.print_log('Early stopping.')
                         break
 
         output = self.forward(adjacencies, features)
@@ -304,46 +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 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,34 +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])
-
     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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on November 2019
+Created in November 2019
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 from abc import ABC
@@ -9,7 +9,7 @@ from abc import ABC
 import numpy as np
 
 from sknetwork.hierarchy.postprocess import split_dendrogram
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class BaseHierarchy(Algorithm, ABC):
@@ -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)