scikit-network 0.33.3__cp313-cp313-win_amd64.whl

sknetwork/embedding/tests/test_API.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for embeddings"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral, SVD, GSVD, Spring
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def setUp(self):
+        """Algorithms by input types."""
+        self.methods = [Spectral(), GSVD(), SVD()]
+
+    def test_undirected(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+
+        method = Spring()
+        embedding = method.fit_transform(adjacency)
+        self.assertEqual(embedding.shape, (n, 2))
+
+        embedding = method.transform()
+        self.assertEqual(embedding.shape, (n, 2))
+
+    def test_bipartite(self):
+        for adjacency in [test_digraph(), test_bigraph()]:
+            n_row, n_col = adjacency.shape
+
+            for method in self.methods:
+                method.fit(adjacency)
+
+                self.assertEqual(method.embedding_.shape, (n_row, 2))
+                self.assertEqual(method.embedding_row_.shape, (n_row, 2))
+                self.assertEqual(method.embedding_col_.shape, (n_col, 2))
+
+    def test_disconnected(self):
+        n = 10
+        adjacency = np.eye(n)
+        for method in self.methods:
+            embedding = method.fit_transform(adjacency)
+            self.assertEqual(embedding.shape, (n, 2))
+
+    def test_regularization(self):
+        adjacency = test_graph()
+        method = Spectral()
+        self.assertEqual(method._get_regularization(-1, adjacency), 0)

sknetwork/embedding/tests/test_force_atlas.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for force atlas2 embeddings"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph, test_digraph
+from sknetwork.embedding.force_atlas import ForceAtlas
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_options(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+
+            force_atlas = ForceAtlas()
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas = ForceAtlas(lin_log=True)
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas = ForceAtlas(approx_radius=1.)
+            layout = force_atlas.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            force_atlas.fit(adjacency, pos_init=layout, n_iter=1)
+
+    def test_errors(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            ForceAtlas().fit(adjacency, pos_init=np.ones((5, 7)))

sknetwork/embedding/tests/test_louvain_embedding.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for Louvain embedding"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph, test_bigraph
+from sknetwork.embedding import LouvainEmbedding
+
+
+class TestLouvainEmbedding(unittest.TestCase):
+
+    def test_predict(self):
+        adjacency = test_graph()
+        adjacency_vector = np.zeros(10, dtype=int)
+        adjacency_vector[:5] = 1
+        louvain = LouvainEmbedding()
+        louvain.fit(adjacency)
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+        louvain.fit(adjacency, force_bipartite=True)
+        self.assertEqual(louvain.embedding_.shape[0], 10)
+
+        # bipartite
+        biadjacency = test_bigraph()
+        louvain.fit(biadjacency)
+        self.assertEqual(louvain.embedding_row_.shape[0], 6)
+        self.assertEqual(louvain.embedding_col_.shape[0], 8)
+
+        for method in ['remove', 'merge', 'keep']:
+            louvain = LouvainEmbedding(isolated_nodes=method)
+            embedding = louvain.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[0], adjacency.shape[0])

sknetwork/embedding/tests/test_random_projection.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for random projection"""
+import unittest
+
+from sknetwork.data.test_graphs import test_graph, test_bigraph, test_digraph, test_disconnected_graph
+from sknetwork.embedding import RandomProjection
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_random_projection(self):
+        for algo in [RandomProjection(), RandomProjection(random_walk=True)]:
+            adjacency = test_graph()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            embedding = algo.fit_transform(adjacency, force_bipartite=True)
+            self.assertEqual(embedding.shape[1], 2)
+            adjacency = test_digraph()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            adjacency = test_disconnected_graph()
+            embedding = algo.fit_transform(adjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            biadjacency = test_bigraph()
+            embedding = algo.fit_transform(biadjacency)
+            self.assertEqual(embedding.shape[1], 2)
+            self.assertEqual(algo.embedding_col_.shape[1], 2)

sknetwork/embedding/tests/test_spectral.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for spectral embedding."""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral
+from sknetwork.utils.check import is_weakly_connected
+from sknetwork.utils.format import bipartite2undirected
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_undirected(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n = adjacency.shape[0]
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            weights = adjacency.dot(np.ones(n))
+            if not is_weakly_connected(adjacency):
+                weights += 1
+            self.assertAlmostEqual(np.linalg.norm(embedding.T.dot(weights)), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+
+    def test_directed(self):
+        for adjacency in [test_digraph(), test_digraph().astype(bool)]:
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(embedding.shape[0], adjacency.shape[0])
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            spectral.fit(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(spectral.eigenvectors_.sum(axis=0)), 0)
+
+    def test_regularization(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n = adjacency.shape[0]
+            # random walk
+            regularization = 0.1
+            spectral = Spectral(3, regularization=regularization, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            weights = adjacency.dot(np.ones(n)) + regularization
+            self.assertAlmostEqual(np.linalg.norm(embedding.T.dot(weights)), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', regularization=1, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+            # without regularization
+            spectral = Spectral(3, decomposition='laplacian', regularization=-1, normalized=False)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(embedding.sum(axis=0)), 0)
+
+    def test_bipartite(self):
+        for biadjacency in [test_digraph(), test_bigraph(), test_bigraph_disconnect()]:
+            n_row, n_col = biadjacency.shape
+            adjacency = bipartite2undirected(biadjacency)
+            # random walk
+            spectral = Spectral(3, normalized=False)
+            spectral.fit(biadjacency)
+            embedding_full = np.vstack([spectral.embedding_row_, spectral.embedding_col_])
+            weights = adjacency.dot(np.ones(n_row + n_col))
+            if not is_weakly_connected(adjacency):
+                weights += 1
+            self.assertAlmostEqual(np.linalg.norm(embedding_full.T.dot(weights)), 0)
+            # Laplacian
+            spectral = Spectral(3, decomposition='laplacian', normalized=False)
+            spectral.fit(biadjacency)
+            embedding_full = np.vstack([spectral.embedding_row_, spectral.embedding_col_])
+            self.assertAlmostEqual(np.linalg.norm(embedding_full.sum(axis=0)), 0)
+
+    def test_normalization(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            spectral = Spectral(3)
+            embedding = spectral.fit_transform(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(np.linalg.norm(embedding, axis=1) - np.ones(adjacency.shape[0])), 0)

sknetwork/embedding/tests/test_spring.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for spring embeddings"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spring
+
+
+class TestEmbeddings(unittest.TestCase):
+
+    def test_shape(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+            spring = Spring()
+            layout = spring.fit_transform(adjacency)
+            self.assertEqual((n, 2), layout.shape)
+
+            spring = Spring(n_components=3)
+            layout = spring.fit_transform(adjacency)
+            self.assertEqual((n, 3), layout.shape)
+
+    def test_pos_init(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+
+        spring = Spring(strength=0.1, position_init='spectral', tol=1e3)
+        layout = spring.fit_transform(adjacency)
+        self.assertEqual((n, 2), layout.shape)
+        layout = spring.fit_transform(adjacency, position_init=layout)
+        self.assertEqual((n, 2), layout.shape)
+
+    def test_approx_radius(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+
+        spring = Spring(approx_radius=1.)
+        layout = spring.fit_transform(adjacency)
+        self.assertEqual((n, 2), layout.shape)
+
+    def test_errors(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            Spring(position_init='toto')
+        with self.assertRaises(ValueError):
+            Spring().fit(adjacency, position_init=np.ones((2, 2)))
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            Spring().fit(adjacency, position_init='toto')

sknetwork/embedding/tests/test_svd.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for svd"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import star_wars
+from sknetwork.embedding import GSVD, SVD, PCA
+from sknetwork.linalg import LanczosSVD
+
+
+class TestSVD(unittest.TestCase):
+
+    def test_options(self):
+        biadjacency = star_wars(metadata=False)
+        n_row, n_col = biadjacency.shape
+        min_dim = min(n_row, n_col) - 1
+        gsvd = GSVD(n_components=5, regularization=0., solver='halko')
+
+        with self.assertWarns(Warning):
+            gsvd.fit(biadjacency)
+        self.assertEqual(gsvd.embedding_row_.shape, (n_row, min_dim))
+        self.assertEqual(gsvd.embedding_col_.shape, (n_col, min_dim))
+
+        embedding = gsvd.predict(np.array([0, 1, 1]))
+        self.assertEqual(embedding.shape, (min_dim,))
+
+        gsvd = GSVD(n_components=1, regularization=0.1, solver='lanczos')
+        gsvd.fit(biadjacency)
+        self.assertEqual(gsvd.embedding_row_.shape, (n_row, 1))
+
+        pca = PCA(n_components=min_dim, solver='lanczos')
+        pca.fit(biadjacency)
+        self.assertEqual(pca.embedding_row_.shape, (n_row, min_dim))
+        pca = PCA(n_components=min_dim, solver=LanczosSVD())
+        pca.fit(biadjacency)
+        self.assertEqual(pca.embedding_row_.shape, (n_row, min_dim))
+
+        svd = SVD(n_components=min_dim, solver=LanczosSVD())
+        svd.fit(biadjacency)
+        self.assertEqual(svd.embedding_row_.shape, (n_row, min_dim))

sknetwork/gnn/__init__.py

@@ -0,0 +1,10 @@
+"""gnn module"""
+from sknetwork.gnn.base import BaseGNN
+from sknetwork.gnn.base_activation import BaseActivation, BaseLoss
+from sknetwork.gnn.base_layer import BaseLayer
+from sknetwork.gnn.gnn_classifier import GNNClassifier
+from sknetwork.gnn.layer import Convolution
+from sknetwork.gnn.neighbor_sampler import UniformNeighborSampler
+from sknetwork.gnn.activation import ReLu, Sigmoid, Softmax
+from sknetwork.gnn.loss import BinaryCrossEntropy, CrossEntropy
+from sknetwork.gnn.optimizer import BaseOptimizer, GD, ADAM

sknetwork/gnn/activation.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in April 2022
+@author: Simon Delarue <sdelarue@enst.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+from typing import Union
+
+import numpy as np
+from scipy import special
+
+from sknetwork.gnn.base_activation import BaseActivation
+
+
+class ReLu(BaseActivation):
+    """ReLu (Rectified Linear Unit) activation function:
+
+    :math:`\\sigma(x) = \\max(0, x)`
+    """
+    def __init__(self):
+        super(ReLu, self).__init__('ReLu')
+
+    @staticmethod
+    def output(signal: np.ndarray) -> np.ndarray:
+        """Output of the ReLu function."""
+        return np.maximum(signal, 0)
+
+    @staticmethod
+    def gradient(signal: np.ndarray, direction: np.ndarray) -> np.ndarray:
+        """Gradient of the ReLu function."""
+        return direction * (signal > 0)
+
+
+class Sigmoid(BaseActivation):
+    """Sigmoid activation function:
+
+    :math:`\\sigma(x) = \\frac{1}{1+e^{-x}}`
+    Also known as the logistic function.
+    """
+    def __init__(self):
+        super(Sigmoid, self).__init__('Sigmoid')
+
+    @staticmethod
+    def output(signal: np.ndarray) -> np.ndarray:
+        """Output of the sigmoid function."""
+        return special.expit(signal)
+
+    @staticmethod
+    def gradient(signal: np.ndarray, direction: np.ndarray) -> np.ndarray:
+        """Gradient of the sigmoid function."""
+        output = Sigmoid.output(signal)
+        return output * (1 - output) * direction
+
+
+class Softmax(BaseActivation):
+    """Softmax activation function:
+
+    :math:`\\sigma(x) =
+    (\\frac{e^{x_1}}{\\sum_{i=1}^N e^{x_i})},\\ldots,\\frac{e^{x_N}}{\\sum_{i=1}^N e^{x_i})})`
+
+    where :math:`N` is the number of channels.
+    """
+    def __init__(self):
+        super(Softmax, self).__init__('Softmax')
+
+    @staticmethod
+    def output(signal: np.ndarray) -> np.ndarray:
+        """Output of the softmax function (rows sum to 1)."""
+        return special.softmax(signal, axis=1)
+
+    @staticmethod
+    def gradient(signal: np.ndarray, direction: np.ndarray) -> np.ndarray:
+        """Gradient of the softmax function."""
+        output = Softmax.output(signal)
+        return output * (direction.T - (output * direction).sum(axis=1)).T
+
+
+def get_activation(activation: Union[BaseActivation, str] = 'identity') -> BaseActivation:
+    """Get the activation function.
+
+    Parameters
+    ----------
+    activation : Union[BaseActivation, str]
+        Activation function.
+        If a name is given, can be either ``'Identity'``, ``'Relu'``, ``'Sigmoid'`` or ``'Softmax'``.
+        If a custom activation function is given, must be of class BaseActivation.
+
+    Returns
+    -------
+    activation : BaseActivation
+        Activation function.
+
+    Raises
+    ------
+    TypeError
+        Error raised if the input not a string or an object of class BaseActivation.
+    ValueError
+        Error raised if the name of the activation function is unknown.
+    """
+    if issubclass(type(activation), BaseActivation):
+        return activation
+    elif type(activation) == str:
+        activation = activation.lower()
+        if activation in ['identity', '']:
+            return BaseActivation()
+        elif activation == 'relu':
+            return ReLu()
+        elif activation == 'sigmoid':
+            return Sigmoid()
+        elif activation == 'softmax':
+            return Softmax()
+        else:
+            raise ValueError("Activation must be either \"Identity\", \"ReLu\", \"Sigmoid\" or \"Softmax\".")
+    else:
+        raise TypeError("Activation must be a string or an object of type \"BaseActivation\".")

sknetwork/gnn/base.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 2022
+@author: Simon Delarue <sdelarue@enst.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from abc import ABC
+
+from typing import Union
+
+import numpy as np
+from collections import defaultdict
+from scipy import sparse
+
+from sknetwork.gnn.loss import BaseLoss, get_loss
+from sknetwork.gnn.optimizer import BaseOptimizer, get_optimizer
+from sknetwork.base import Algorithm
+from sknetwork.log import Log
+
+
+class BaseGNN(ABC, Algorithm, Log):
+    """Base class for GNNs.
+
+    Parameters
+    ----------
+    loss : str or custom loss (default = ``'Cross entropy'``)
+        Loss function.
+    optimizer : str or custom optimizer (default = ``'Adam'``)
+        Optimizer used for training.
+
+        * ``'Adam'``, a stochastic gradient-based optimizer.
+        * ``'GD'``, gradient descent.
+    learning_rate : float
+        Learning rate.
+    verbose : bool
+        Verbose mode
+
+    Attributes
+    ----------
+    layers: list
+        List of layers.
+    labels_: np.ndarray
+        Predicted labels.
+    history_: dict
+        Training history per epoch: {'embedding', 'loss', 'train_accuracy', 'test_accuracy'}.
+    """
+    def __init__(self, loss: Union[BaseLoss, str] = 'CrossEntropy', optimizer: Union[BaseOptimizer, str] = 'Adam',
+                 learning_rate: float = 0.01, verbose: bool = False):
+        Log.__init__(self, verbose)
+        self.optimizer = get_optimizer(optimizer, learning_rate)
+        self.loss = get_loss(loss)
+        self.layers = []
+        self.derivative_weight = []
+        self.derivative_bias = []
+        self.train_mask = None
+        self.test_mask = None
+        self.val_mask = None
+        self.embedding_ = None
+        self.output_ = None
+        self.labels_ = None
+        self.history_ = defaultdict(list)
+
+    def fit(self, *args, **kwargs):
+        """Fit Algorithm to the data."""
+        raise NotImplementedError
+
+    def predict(self):
+        """Return the predicted labels."""
+        return self.labels_
+
+    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the labels. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        labels : np.ndarray
+            Labels of the nodes.
+        """
+        self.fit(*args, **kwargs)
+        return self.predict()
+
+    def predict_proba(self):
+        """Return the probability distribution over labels."""
+        probs = self.output_
+        if probs is not None:
+            if probs.shape[1] == 1:
+                probs = np.vstack(1 - probs, probs)
+        return probs
+
+    def fit_predict_proba(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the distribution over labels. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        probs : np.ndarray
+            Probability distribution over labels.
+        """
+        self.fit(*args, **kwargs)
+        return self.predict_proba()
+
+    def transform(self):
+        """Return the embedding of nodes."""
+        return self.embedding_
+
+    def fit_transform(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to the data and return the embedding of the nodes. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        embedding : np.ndarray
+            Embedding of the nodes.
+        """
+        self.fit(*args, **kwargs)
+        return self.transform()
+
+    def backward(self, features: sparse.csr_matrix, labels: np.ndarray, mask: np.ndarray):
+        """Compute backpropagation.
+
+        Parameters
+        ----------
+        features : sparse.csr_matrix
+            Features, array of shape (n_nodes, n_features).
+        labels : np.ndarray
+            Labels, array of shape (n_nodes,).
+        mask: np.ndarray
+            Boolean mask, array of shape (n_nodes,).
+        """
+        derivative_weight = []
+        derivative_bias = []
+
+        # discard missing labels
+        mask = mask & (labels >= 0)
+        labels = labels[mask]
+
+        # backpropagation
+        n_layers = len(self.layers)
+        layers_reverse: list = list(reversed(self.layers))
+        signal = layers_reverse[0].embedding
+        signal = signal[mask]
+        gradient = layers_reverse[0].activation.loss_gradient(signal, labels)
+
+        for i in range(n_layers):
+            if i < n_layers - 1:
+                signal = layers_reverse[i + 1].output
+            else:
+                signal = features
+            signal = signal[mask]
+
+            derivative_weight.append(signal.T.dot(gradient))
+            derivative_bias.append(np.mean(gradient, axis=0, keepdims=True))
+
+            if i < n_layers - 1:
+                signal = layers_reverse[i + 1].embedding
+                signal = signal[mask]
+                direction = layers_reverse[i].weight.dot(gradient.T).T
+                gradient = layers_reverse[i + 1].activation.gradient(signal, direction)
+
+        self.derivative_weight = list(reversed(derivative_weight))
+        self.derivative_bias = list(reversed(derivative_bias))
+
+    def _check_fitted(self):
+        if self.output_ is None:
+            raise ValueError("This embedding instance is not fitted yet. "
+                             "Call 'fit' with appropriate arguments before using this method.")
+        else:
+            return self
+
+    def __repr__(self) -> str:
+        """String representation of the `GNN`, layers by layers.
+
+        Returns
+        -------
+        str
+            String representation of object.
+        """
+        string = f'{self.__class__.__name__}(\n'
+        for layer in self.layers:
+            string += f'  {layer}\n'
+        string += ')'
+        return string