scikit-network 0.33.3__cp312-cp312-macosx_10_13_x86_64.whl

sknetwork/gnn/tests/test_gnn_classifier.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for gnn classifier"""
+
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.gnn_classifier import GNNClassifier
+
+
+class TestGNNClassifier(unittest.TestCase):
+
+    def setUp(self) -> None:
+        """Test graph for tests."""
+        self.adjacency = test_graph()
+        self.n = self.adjacency.shape[0]
+        self.features = self.adjacency
+        self.labels = np.array(4 * [0, 1] + 2 * [-1])
+
+    def test_gnn_classifier_sparse_feat(self):
+        gnn = GNNClassifier([3, 2], 'Conv', 'Softmax')
+        self.assertTrue(gnn.layers[0].activation.name == 'Softmax')
+        self.assertTrue(gnn.layers[1].activation.name == 'Cross entropy')
+        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))
+
+    def test_gnn_classifier_dense_feat(self):
+        # features not in nparray
+        features = self.adjacency.todense()
+        gnn = GNNClassifier(2)
+        with self.assertRaises(TypeError):
+            gnn.fit_predict(self.adjacency, features, self.labels)
+
+        # features in numpy array
+        features = np.array(self.adjacency.todense())
+        gnn = GNNClassifier(2, 'Conv')
+        y_pred = gnn.fit_predict(self.adjacency, features, self.labels, validation=0.2)
+        embedding = gnn.embedding_
+        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:
+            gnn = GNNClassifier(2, 'Conv', optimizer=optimizer)
+            y_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+            embedding = gnn.embedding_
+            self.assertTrue(len(y_pred) == self.n)
+            self.assertTrue(embedding.shape == (self.n, 2))
+
+    def test_gnn_classifier_binary(self):
+        gnn = GNNClassifier([5, 1], 'Conv', 'Softmax')
+        self.assertTrue(gnn.layers[1].activation.name == 'Binary cross entropy')
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+        self.assertTrue(len(labels_pred) == self.n)
+
+    def test_gnn_classifier_norm(self):
+        n_labels = len(set(self.labels))
+        gnn = GNNClassifier([5, n_labels], 'Conv', normalizations=['left', 'both'])
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+        self.assertTrue(len(labels_pred) == self.n)
+
+    def test_gnn_classifier_1label(self):
+        gnn = GNNClassifier(1, 'Conv', 'Relu')
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+        self.assertTrue(len(labels_pred) == self.n)
+
+    def test_gnn_classifier_validation(self):
+        gnn = GNNClassifier(2, 'Conv', 'Softmax', early_stopping=False)
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels, validation=0.5, random_state=42)
+        self.assertTrue(len(labels_pred) == self.n)
+
+    def test_gnn_classifier_dim_output(self):
+        gnn = GNNClassifier(2)
+        labels = np.arange(len(self.labels))
+        with self.assertRaises(ValueError):
+            gnn.fit(self.adjacency, self.features, labels)
+
+    def test_gnn_classifier_verbose(self):
+        gnn = GNNClassifier(2, verbose=True)
+        self.assertTrue(isinstance(gnn, GNNClassifier))
+
+    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, 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, 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)
+        gnn.fit(self.adjacency, self.features, self.labels, n_epochs=1, reinit=True)
+        self.assertTrue(gnn.embedding_.shape == (self.n, 2))
+
+    def test_gnn_classifier_sageconv(self):
+        gnn = GNNClassifier([4, 2], ['SAGEConv', 'SAGEConv'], sample_sizes=[5, 3])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, n_epochs=100)
+        self.assertTrue(gnn.layers[0].sample_size == 5 and gnn.layers[0].normalization == 'left')
+        self.assertTrue(gnn.layers[1].sample_size == 3 and gnn.layers[1].normalization == 'left')
+
+    def test_gnn_classifier_predict(self):
+        gnn = GNNClassifier([4, 2])
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels)
+        labels_pred_ = gnn.predict()
+        self.assertTrue(all(labels_pred == gnn.labels_))
+        self.assertTrue(all(labels_pred == labels_pred_))
+
+    def test_gnn_classifier_predict_proba(self):
+        gnn = GNNClassifier([4, 2])
+        probs = gnn.fit_predict_proba(self.adjacency, self.features, self.labels)
+        self.assertTrue(probs.shape[1] == 2)

sknetwork/gnn/tests/test_layers.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for layers"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.layer import Convolution, get_layer
+
+
+class TestLayer(unittest.TestCase):
+
+    def setUp(self) -> None:
+        """Test graph for tests."""
+        self.adjacency = test_graph()
+        self.features = self.adjacency
+        self.labels = np.array([0] * 5 + [1] * 5)
+
+    def test_graph_conv_shapes(self):
+        conv1 = Convolution('Conv', 4)
+        conv1._initialize_weights(self.features.shape[1])
+        conv2 = Convolution('Conv', 2)
+        conv2._initialize_weights(4)
+
+        self.assertTrue(conv1.weight.shape == (self.features.shape[1], 4))
+        self.assertTrue(conv1.bias.shape == (1, 4))
+        self.assertTrue(conv1.weights_initialized)
+        self.assertTrue(conv2.weight.shape == (4, 2))
+        self.assertTrue(conv2.bias.shape == (1, 2))
+        self.assertTrue(conv2.weights_initialized)
+
+        h = conv1.forward(self.adjacency, self.features)
+        self.assertTrue(h.shape == (self.adjacency.shape[0], 4))
+        emb = conv2.forward(self.adjacency, h)
+        self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_graph_conv_bias_use(self):
+        conv1 = Convolution('Conv', 4, use_bias=False)
+        conv2 = Convolution('Conv', 2, use_bias=False)
+        h = conv1.forward(self.adjacency, self.features)
+        emb = conv2.forward(self.adjacency, h)
+        self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_graph_conv_self_embeddings(self):
+        conv1 = Convolution('Conv', 4, self_embeddings=False)
+        conv2 = Convolution('Conv', 2, self_embeddings=False)
+        h = conv1.forward(self.adjacency, self.features)
+        emb = conv2.forward(self.adjacency, h)
+        self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_graph_conv_norm(self):
+        conv1 = Convolution('Conv', 4, normalization='left')
+        conv2 = Convolution('Conv', 2, normalization='right')
+        h = conv1.forward(self.adjacency, self.features)
+        emb = conv2.forward(self.adjacency, h)
+        self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_graph_conv_activation(self):
+        activations = ['Relu', 'Sigmoid']
+        for a in activations:
+            conv1 = Convolution('Conv', 4, activation=a)
+            conv2 = Convolution('Conv', 2)
+            h = conv1.forward(self.adjacency, self.features)
+            emb = conv2.forward(self.adjacency, h)
+            self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_graph_sage(self):
+        conv1 = Convolution('Sage', 4, normalization='left', self_embeddings=True)
+        conv2 = Convolution('Sage', 2, normalization='right', self_embeddings=True)
+        h = conv1.forward(self.adjacency, self.features)
+        emb = conv2.forward(self.adjacency, h)
+        self.assertTrue(emb.shape == (self.adjacency.shape[0], 2))
+
+    def test_get_layer(self):
+        with self.assertRaises(ValueError):
+            get_layer('toto')
+        with self.assertRaises(TypeError):
+            get_layer(Convolution)

sknetwork/gnn/tests/test_loss.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for loss"""
+
+import unittest
+
+from sknetwork.gnn.loss import *
+
+
+class TestLoss(unittest.TestCase):
+
+    def test_get_loss(self):
+        self.assertTrue(isinstance(get_loss('CrossEntropy'), CrossEntropy))
+        self.assertTrue(isinstance(get_loss('BinaryCrossEntropy'), BinaryCrossEntropy))
+        with self.assertRaises(ValueError):
+            get_loss('foo')
+
+        base_loss = BaseLoss()
+        self.assertTrue(base_loss == get_loss(base_loss))
+        with self.assertRaises(TypeError):
+            get_loss(0)
+
+    def test_ce_loss(self):
+        cross_entropy = CrossEntropy()
+        signal = np.array([[0, 5]])
+        labels = np.array([1])
+        self.assertAlmostEqual(cross_entropy.loss(signal, labels), 0.00671534848911828)
+
+    def test_bce_loss(self):
+        binary_cross_entropy = BinaryCrossEntropy()
+        signal = np.array([[0, 5]])
+        labels = np.array([1])
+        self.assertAlmostEqual(binary_cross_entropy.loss(signal, labels), 0.6998625290490632)

sknetwork/gnn/tests/test_neigh_sampler.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for neighbor sampler"""
+
+import unittest
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.neighbor_sampler import *
+from sknetwork.utils import get_degrees
+
+
+class TestNeighSampler(unittest.TestCase):
+
+    def setUp(self) -> None:
+        """Test graph for tests."""
+        self.adjacency = test_graph()
+        self.n = self.adjacency.shape[0]
+
+    def test_uni_node_sampler(self):
+        uni_sampler = UniformNeighborSampler(sample_size=2)
+        sampled_adj = uni_sampler(self.adjacency)
+        self.assertTrue(sampled_adj.shape == self.adjacency.shape)
+        self.assertTrue(all(get_degrees(sampled_adj) <= 2))

sknetwork/gnn/tests/test_optimizer.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for optimizer"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.gnn_classifier import GNNClassifier
+from sknetwork.gnn.optimizer import get_optimizer
+
+
+class TestOptimizer(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.adjacency = test_graph()
+        self.features = self.adjacency
+        self.labels = np.array(4 * [0, 1] + 2 * [-1])
+
+    def test_get_optimizer(self):
+        with self.assertRaises(ValueError):
+            get_optimizer('foo')
+        with self.assertRaises(TypeError):
+            get_optimizer(GNNClassifier())
+
+    def test_optimizer(self):
+        for optimizer in ['Adam', 'GD']:
+            gnn = GNNClassifier([4, 2], 'Conv',  ['Relu', 'Softmax'], optimizer=optimizer)
+            _ = gnn.fit_predict(self.adjacency, self.features, self.labels, n_epochs=1)
+            conv0_weight, conv1_weight = gnn.layers[0].weight.copy(), gnn.layers[1].weight.copy()
+            conv0_b, conv1_b = gnn.layers[0].bias.copy(), gnn.layers[1].bias.copy()
+            gnn.optimizer.step(gnn)
+            # Test weight matrix
+            self.assertTrue(gnn.layers[0].weight.shape == conv0_weight.shape)
+            self.assertTrue(gnn.layers[1].weight.shape == conv1_weight.shape)
+            self.assertTrue((gnn.layers[0].weight != conv0_weight).any())
+            self.assertTrue((gnn.layers[1].weight != conv1_weight).any())
+            # Test bias vector
+            self.assertTrue(gnn.layers[0].bias.shape == conv0_b.shape)
+            self.assertTrue(gnn.layers[1].bias.shape == conv1_b.shape)
+            self.assertTrue((gnn.layers[0].bias != conv0_b).any())
+            self.assertTrue((gnn.layers[1].bias != conv1_b).any())

sknetwork/gnn/tests/test_utils.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for gnn utils"""
+
+import unittest
+
+from sknetwork.gnn.utils import *
+
+
+class TestUtils(unittest.TestCase):
+
+    def test_check_norm(self):
+        with self.assertRaises(ValueError):
+            check_normalizations('foo')
+        with self.assertRaises(ValueError):
+            check_normalizations(['foo', 'bar'])
+
+    def test_early_stopping(self):
+        self.assertTrue(check_early_stopping(True, np.array([True, False]), 2))
+        self.assertFalse(check_early_stopping(True, None, 2))
+        self.assertFalse(check_early_stopping(True, np.array([True, False, True]), None))
+        self.assertFalse(check_early_stopping(True, np.array([False, False, False]), 5))
+
+    def test_get_layers(self):
+        with self.assertRaises(ValueError):
+            get_layers([4, 2], 'Conv',  activations=['Relu', 'Sigmoid', 'Relu'], use_bias=True, normalizations='Both',
+                       self_embeddings=True, sample_sizes=5, loss=None)
+        # Type compatibility
+        layers = get_layers([4], 'Conv', activations=['Relu'], use_bias=[True], normalizations=['Both'],
+                            self_embeddings=[True], sample_sizes=[5], loss='Cross entropy')
+        self.assertTrue(len(np.ravel(layers)) == 1)
+        # Broadcasting parameters
+        layers = get_layers([4, 2], ['Conv', 'Conv'], activations='Relu', use_bias=True, normalizations='Both',
+                            self_embeddings=True, sample_sizes=5, loss='Cross entropy')
+        self.assertTrue(len(layers) == 2)
+
+    def test_check_loss(self):
+        layer = get_layers([4], 'Conv', activations=['Relu'], use_bias=[True], normalizations=['Both'],
+                           self_embeddings=[True], sample_sizes=[5], loss=None)
+        with self.assertRaises(ValueError):
+            check_loss(layer[0])

sknetwork/gnn/utils.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in April 2022
+@author: Simon Delarue <sdelarue@enst.fr>
+"""
+from typing import Iterable, Union
+
+import numpy as np
+
+from sknetwork.gnn.base_activation import BaseActivation, BaseLoss
+from sknetwork.gnn.base_layer import BaseLayer
+from sknetwork.gnn.layer import get_layer
+from sknetwork.gnn.loss import BinaryCrossEntropy, CrossEntropy
+
+
+def check_early_stopping(early_stopping: bool, val_mask: np.ndarray, patience: int):
+    """Check early stopping parameters."""
+    if val_mask is None or patience is None or not any(val_mask):
+        return False
+    else:
+        return early_stopping
+
+
+def check_normalizations(normalizations: Union[str, Iterable]):
+    """Check if normalization is known."""
+    available_norms = ['left', 'right', 'both']
+    if isinstance(normalizations, list):
+        for normalization in normalizations:
+            if normalization.lower() not in available_norms:
+                raise ValueError("Normalization must be 'left', 'right' or 'both'.")
+    elif normalizations.lower() not in available_norms:
+        raise ValueError("Normalization must be 'left', 'right' or 'both'.")
+
+
+def check_output(n_channels: int, labels: np.ndarray):
+    """Check the output of the GNN.
+
+    Parameters
+    ----------
+    n_channels : int
+        Number of output channels
+    labels : np.ndarray
+        Vector of labels
+    """
+    n_labels = len(set(labels[labels >= 0]))
+    if n_labels > 2 and n_labels > n_channels:
+        raise ValueError("The dimension of the output is too small for the number of labels. "
+                         "Please check the `dims` parameter of your GNN or the `labels` parameter.")
+
+
+def check_param(param, length):
+    """Check the length of a parameter if a list.
+    """
+    if not isinstance(param, list):
+        param = length * [param]
+    elif len(param) != length:
+        raise ValueError('The number of parameters must be equal to the number of layers.')
+    return param
+
+
+def check_loss(layer: BaseLayer):
+    """Check the length of a parameter if a list.
+    """
+    if not issubclass(type(layer.activation), BaseLoss):
+        raise ValueError('No loss specified for the last layer.')
+    if isinstance(layer.activation, CrossEntropy) and layer.out_channels == 1:
+        layer.activation = BinaryCrossEntropy()
+    return layer.activation
+
+
+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
+    ----------
+    dims :
+        Dimensions of layers (in forward direction).
+    layer_types :
+        Layer types.
+    activations :
+        Activation functions.
+    use_bias :
+        ``True`` if a bias vector is added.
+    normalizations :
+        Normalizations of adjacency matrix.
+    self_embeddings :
+        ``True`` if self embeddings are added. Allowed input are booleans and lists.
+    sample_sizes
+        Size of neighborhood sampled for each node.
+    loss :
+        Loss function.
+
+    Returns
+    -------
+    list
+        List of layers.
+    """
+    check_normalizations(normalizations)
+
+    if isinstance(dims, int):
+        dims = [dims]
+    n_layers = len(dims)
+
+    layer_types = check_param(layer_types, n_layers)
+    activations = check_param(activations, n_layers)
+    use_bias = check_param(use_bias, n_layers)
+    normalizations = check_param(normalizations, n_layers)
+    self_embeddings = check_param(self_embeddings, n_layers)
+    sample_sizes = check_param(sample_sizes, n_layers)
+
+    layers = []
+    names_params = ['layer', 'out_channels', 'activation', 'use_bias', 'normalization', 'self_embeddings',
+                    'sample_size']
+    for i in range(n_layers):
+        params = [layer_types[i], dims[i], activations[i], use_bias[i], normalizations[i], self_embeddings[i],
+                  sample_sizes[i]]
+        if i == n_layers - 1:
+            params.append(loss)
+            names_params.append('loss')
+        dict_params = dict(zip(names_params, params))
+        layers.append(get_layer(**dict_params))
+
+    return layers

sknetwork/hierarchy/__init__.py

@@ -0,0 +1,6 @@
+"""hierarchy module"""
+from sknetwork.hierarchy.paris import Paris
+from sknetwork.hierarchy.base import BaseHierarchy
+from sknetwork.hierarchy.louvain_hierarchy import LouvainIteration, LouvainHierarchy
+from sknetwork.hierarchy.metrics import dasgupta_cost, dasgupta_score, tree_sampling_divergence
+from sknetwork.hierarchy.postprocess import cut_straight, cut_balanced, aggregate_dendrogram, reorder_dendrogram

sknetwork/hierarchy/base.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from abc import ABC
+
+import numpy as np
+
+from sknetwork.hierarchy.postprocess import split_dendrogram
+from sknetwork.base import Algorithm
+
+
+class BaseHierarchy(Algorithm, ABC):
+    """Base class for hierarchical clustering algorithms.
+    Attributes
+    ----------
+    dendrogram_ :
+        Dendrogram of the graph.
+    dendrogram_row_ :
+        Dendrogram for the rows, for bipartite graphs.
+    dendrogram_col_ :
+        Dendrogram for the columns, for bipartite graphs.
+    dendrogram_full_ :
+        Dendrogram for both rows and columns, indexed in this order, for bipartite graphs.
+    """
+
+    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.
+
+        Returns
+        -------
+        dendrogram : np.ndarray
+            Dendrogram.
+        """
+        self.fit(*args, **kwargs)
+        return self.dendrogram_
+
+    def fit_transform(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to data and return the dendrogram. Alias for ``fit_predict``.
+        Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        dendrogram : np.ndarray
+            Dendrogram.
+        """
+        self.fit(*args, **kwargs)
+        return self.dendrogram_
+
+    def _init_vars(self):
+        """Init variables."""
+        self.dendrogram_ = None
+        self.dendrogram_row_ = None
+        self.dendrogram_col_ = None
+        self.dendrogram_full_ = None
+
+    def _split_vars(self, shape):
+        """Split variables."""
+        dendrogram_row, dendrogram_col = split_dendrogram(self.dendrogram_, shape)
+        self.dendrogram_full_ = self.dendrogram_
+        self.dendrogram_ = dendrogram_row
+        self.dendrogram_row_ = dendrogram_row
+        self.dendrogram_col_ = dendrogram_col
+        return self