scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/gnn/tests/test_activation.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for activation"""
+
+import unittest
+
+from sknetwork.gnn.activation import *
+
+
+class TestActivation(unittest.TestCase):
+
+    def test_get_activation(self):
+        self.assertTrue(isinstance(get_activation('Identity'), BaseActivation))
+        self.assertTrue(isinstance(get_activation('Relu'), ReLu))
+        self.assertTrue(isinstance(get_activation('Sigmoid'), Sigmoid))
+        self.assertTrue(isinstance(get_activation('Softmax'), Softmax))
+        with self.assertRaises(ValueError):
+            get_activation('foo')
+
+        base_act = BaseActivation()
+        self.assertTrue(base_act == get_activation(base_act))
+        with self.assertRaises(TypeError):
+            get_activation(0)
+
+    def test_activation_identity(self):
+        activation = get_activation('Identity')
+        signal = np.arange(5)
+        self.assertTrue((activation.output(signal) == signal).all())
+        direction = np.arange(5)
+        self.assertTrue((activation.gradient(signal, direction) == direction).all())
+
+    def test_activation_relu(self):
+        activation = get_activation('ReLu')
+        signal = np.linspace(-2, 2, 5)
+        self.assertTrue((activation.output(signal) == [0., 0., 0., 1., 2.]).all())
+        direction = np.arange(5)
+        self.assertTrue((activation.gradient(signal, direction) == direction * (signal > 0)).all())
+
+    def test_activation_sigmoid(self):
+        activation = get_activation('Sigmoid')
+        signal = np.array([-np.inf, -1.5, 0, 1.5, np.inf])
+        self.assertTrue(np.allclose(activation.output(signal), np.array([0., 0.18242552, 0.5, 0.81757448, 1.])))
+        signal = np.array([[-1000, 1000, 1000]])
+        direction = np.arange(3)
+        self.assertTrue(np.allclose(activation.output(signal), np.array([[0., 1., 1.]])))
+        self.assertTrue(np.allclose(activation.gradient(signal, direction), np.array([[0., 0., 0.]])))
+
+    def test_activation_softmax(self):
+        activation = get_activation('Softmax')
+        signal = np.array([[-1, 0, 3, 5]])
+        output = activation.output(signal)
+        self.assertTrue(np.allclose(output, np.array([[0.0021657, 0.00588697, 0.11824302, 0.87370431]])))
+        signal = np.array([[-1000, 1000, 1000]])
+        direction = np.arange(3)
+        self.assertTrue(np.allclose(activation.output(signal), np.array([[0., 0.5, 0.5]])))
+        self.assertTrue(np.allclose(activation.gradient(signal, direction), np.array([[0., -0.25, 0.25]])))

sknetwork/gnn/tests/test_base.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for base gnn"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.base import BaseGNN
+from sknetwork.gnn.gnn_classifier import GNNClassifier
+from sknetwork.gnn.layer import Convolution
+from sknetwork.gnn.optimizer import ADAM
+
+
+class TestBaseGNN(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([0]*5 + [1]*5)
+
+    def test_base_gnn_fit(self):
+        gnn = BaseGNN()
+        with self.assertRaises(NotImplementedError):
+            gnn.fit(self.adjacency, self.features, self.labels, test_size=0.2)
+
+    def test_gnn_fit_transform(self):
+        gnn = GNNClassifier(dims=2, layer_types='Conv', activations='Relu', optimizer='GD', verbose=False)
+        embedding = gnn.fit_transform(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        self.assertTrue(len(embedding) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+
+    def test_gnn_custom_optimizer(self):
+        gnn = GNNClassifier(dims=2, layer_types='Conv', activations='Relu', optimizer=ADAM(beta1=0.5), verbose=False)
+        embedding = gnn.fit_transform(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        self.assertTrue(len(embedding) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+
+    def test_gnn_custom_layers(self):
+        gnn = GNNClassifier(layers=[Convolution('Conv', 2, loss='CrossEntropy')], optimizer=ADAM(beta1=0.5), verbose=False)
+        embedding = gnn.fit_transform(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        self.assertTrue(len(embedding) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+
+        gnn = GNNClassifier(layers=[Convolution('SAGEConv', 2, sample_size=5, loss='CrossEntropy')], optimizer=ADAM(beta1=0.5),
+                            verbose=False)
+        embedding = gnn.fit_transform(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        self.assertTrue(len(embedding) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+
+    def test_gnn_custom(self):
+        gnn = GNNClassifier(dims=[20, 8, 2], layer_types='conv',
+                            activations=['Relu', 'Sigmoid', 'Softmax'], optimizer='Adam', verbose=False)
+        self.assertTrue(isinstance(gnn, GNNClassifier))
+        self.assertTrue(gnn.layers[-1].activation.name == 'Cross entropy')
+        y_pred = gnn.fit_predict(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        self.assertTrue(len(y_pred) == self.n)
+
+    def test_check_fitted(self):
+        gnn = BaseGNN()
+        with self.assertRaises(ValueError):
+            gnn._check_fitted()
+        gnn = GNNClassifier(dims=2, layer_types='conv', activations='Relu', optimizer='GD', verbose=False)
+        gnn.fit_transform(self.adjacency, self.features, labels=self.labels, n_epochs=1, val_size=0.2)
+        fit_gnn = gnn._check_fitted()
+        self.assertTrue(isinstance(fit_gnn, GNNClassifier))
+        self.assertTrue(fit_gnn.embedding_ is not None)
+
+    def test_base_gnn_repr(self):
+        gnn = GNNClassifier(dims=[8, 2], layer_types='conv', activations=['Relu', 'Softmax'], optimizer='Adam')
+        self.assertTrue(gnn.__repr__().startswith("GNNClassifier"))
+
+    def test_gnn_predict(self):
+        gnn = BaseGNN()
+        with self.assertRaises(NotImplementedError):
+            gnn.predict()

sknetwork/gnn/tests/test_base_layer.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for base layer gnn"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.gnn.base_layer import BaseLayer
+
+
+class TestBaseLayer(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([0]*5 + [1]*5)
+        self.base_layer = BaseLayer('Conv', len(self.labels))
+
+    def test_base_layer_init(self):
+        with self.assertRaises(NotImplementedError):
+            self.base_layer.forward(self.adjacency, self.features)
+
+    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.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__())

sknetwork/gnn/tests/test_gnn_classifier.py

@@ -0,0 +1,192 @@
+#!/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([0]*5 + [1]*5)
+
+    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, val_size=0.2)
+        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, val_size=0.2)
+
+        # features in numpy array
+        features = np.array(self.adjacency.todense())
+        gnn = GNNClassifier(2, 'Conv')
+        y_pred = gnn.fit_predict(self.adjacency, features, self.labels, val_size=0.2)
+        embedding = gnn.embedding_
+        self.assertTrue(len(y_pred) == self.n)
+        self.assertTrue(embedding.shape == (self.n, 2))
+
+    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, val_size=0.2)
+            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, val_size=0.2)
+        self.assertTrue(len(labels_pred) == self.n)
+
+    def test_gnn_classifier_masks(self):
+        gnn = GNNClassifier(2, 'Conv', 'Softmax', early_stopping=False)
+        train_mask = np.array([True, True, True, True, True, True, False, False, False, False])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_mask=train_mask, n_epochs=5)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+        train_mask = np.array([True, True, True, True, True, True, False, False, False, False])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_mask=train_mask, resample=True,
+                            n_epochs=10)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+        val_mask = np.array([False, False, False, False, False, False, True, False, False, False])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_mask=train_mask, val_mask=val_mask)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+        test_mask = np.array([False, False, False, False, False, False, False, True, True, True])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_mask=train_mask, val_mask=val_mask,
+                            test_mask=test_mask)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+    def test_gnn_classifier_val_size(self):
+        gnn = GNNClassifier(2)
+        with self.assertRaises(ValueError):
+            gnn.fit_predict(self.adjacency, self.features, self.labels, train_size=None, val_size=None, test_size=None)
+        with self.assertRaises(ValueError):
+            gnn.fit_predict(self.adjacency, self.features, self.labels, val_size=-1)
+        with self.assertRaises(ValueError):
+            gnn.fit_predict(self.adjacency, self.features, self.labels, val_size=1.5)
+
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_size=0.6)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_size=0.7, val_size=0.1, test_size=0.2)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+        labels = self.labels.copy()
+        labels[:2] = -1  # missing labels
+        _ = gnn.fit_predict(self.adjacency, self.features, labels, train_size=0.8, val_size=0.1)
+        self.assertTrue(sum(gnn.test_mask) != 0)
+        self.assertTrue(sum(gnn.train_mask) + sum(gnn.val_mask) + sum(gnn.test_mask) == self.adjacency.shape[0])
+
+    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_random_state(self):
+        gnn = GNNClassifier(2)
+        labels_pred = gnn.fit_predict(self.adjacency, self.features, self.labels, val_size=0.2, random_state=42)
+        embedding = gnn.embedding_
+        self.assertTrue(len(labels_pred) == self.adjacency.shape[0])
+        self.assertTrue(embedding.shape == (self.adjacency.shape[0], 2))
+
+    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)
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, n_epochs=100, history=True)
+        self.assertTrue(len(gnn.history_['val_accuracy']) < 100)
+
+        gnn = GNNClassifier(2, early_stopping=False)
+        train_mask = np.array([True, True, True, True, True, True, False, False, False, False])
+        val_mask = np.array([False, False, False, False, False, False, True, True, False, False])
+        _ = gnn.fit_predict(self.adjacency, self.features, self.labels, train_mask=train_mask, val_mask=val_mask,
+                            n_epochs=100, history=True)
+        self.assertTrue(len(gnn.history_['val_accuracy']) == 100)
+
+    def test_gnn_classifier_reinit(self):
+        gnn = GNNClassifier([4, 2])
+        n_layers = len(gnn.layers)
+        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, n_epochs=1, reinit=True)
+        self.assertTrue(all([(weights[i] != gnn.layers[i].weight).all() for i in range(n_layers)]))
+        self.assertTrue(all([(biases[i] != gnn.layers[i].bias).all() for i in range(n_layers)]))
+
+    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, val_size=0.2, random_state=42)
+        preds = gnn.predict()
+        self.assertTrue(all(labels_pred == gnn.labels_))
+        self.assertTrue(all(labels_pred == preds))
+
+        # Predict same nodes
+        predictions = gnn.predict(self.adjacency, self.features)
+        self.assertTrue(all(predictions == 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)))
+        preds = gnn.predict(adjacency, features)
+        self.assertTrue(len(preds) == n)
+
+        # No adj matrix
+        preds = gnn.predict(None, features)
+        self.assertTrue(len(preds) == features.shape[0])

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('Sageconv', 4, normalization='left', self_embeddings=True)
+        conv2 = Convolution('Sageconv', 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([0] * 5 + [1] * 5)
+
+    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, val_size=0.2)
+            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,93 @@
+#!/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_mask_similarity(self):
+        m1 = np.array([True, True, False])
+        m2 = np.array([True, False, False])
+        with self.assertWarns(Warning):
+            check_mask_similarity(m1, m2)
+
+    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_check_existing_masks(self):
+        # Check invalid entries
+        labels = np.array([1, 1, 0])
+        with self.assertRaises(ValueError):
+            check_existing_masks(labels)
+        # Check valid size parameters
+        self.assertFalse(check_existing_masks(labels, None, None, None, 0.1, 0.2, 0.7)[0])
+
+        # Check valid pre-computed masks
+        mask_exists, train_mask, val_mask, test_mask = check_existing_masks(labels, np.array([False, True, False]))
+        self.assertTrue(mask_exists)
+        self.assertTrue(all(train_mask == np.array([False, True, False])))
+        self.assertTrue(all(val_mask == np.array([False, False, False])))
+        self.assertTrue(all(test_mask == np.array([True, False, True])))
+
+        mask_exists, train_mask, val_mask, test_mask = check_existing_masks(labels, np.array([True, False, False]),
+                                                                            np.array([False, True, False]))
+        self.assertTrue(mask_exists)
+        self.assertTrue(all(train_mask == np.array([True, False, False])))
+        self.assertTrue(all(val_mask == np.array([False, True, False])))
+        self.assertTrue(all(test_mask == np.array([False, False, True])))
+
+        mask_exists, train_mask, val_mask, test_mask = check_existing_masks(labels, np.array([True, True, False]),
+                                                                            None, np.array([False, False, True]))
+        self.assertTrue(mask_exists)
+        self.assertTrue(all(train_mask == np.array([True, True, False])))
+        self.assertTrue(all(val_mask == np.array([False, False, False])))
+        self.assertTrue(all(test_mask == np.array([False, False, True])))
+
+        mask_exists, train_mask, val_mask, test_mask = check_existing_masks(labels, np.array([True, False, False]),
+                                                                            np.array([False, False, True]),
+                                                                            np.array([False, True, False]))
+        self.assertTrue(mask_exists)
+        self.assertTrue(all(train_mask == np.array([True, False, False])))
+        self.assertTrue(all(val_mask == np.array([False, False, True])))
+        self.assertTrue(all(test_mask == np.array([False, True, False])))
+
+        # Check negative labels
+        labels = np.array([1, -1, 0])
+        mask_exists, train_mask, val_mask, test_mask = check_existing_masks(labels, np.array([True, True, False]))
+        self.assertTrue(mask_exists)
+        self.assertTrue(all(train_mask == np.array([True, False, False])))
+        print(val_mask)
+        self.assertTrue(all(val_mask == np.array([False, False, False])))
+        self.assertTrue(all(test_mask == np.array([False, True, True])))
+
+    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])