scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

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,37 @@
+#!/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))
+
+        gsvd = GSVD(n_components=1, regularization=0.1, solver='lanczos')
+        gsvd.fit(biadjacency)
+        gsvd.predict(np.random.rand(n_col))
+
+        pca = PCA(n_components=min_dim, solver='lanczos')
+        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/flow/__init__.py

@@ -0,0 +1,3 @@
+"""flow module"""
+from sknetwork.flow.utils import get_residual_graph, flow_is_feasible, find_excess
+from sknetwork.flow.push_relabel import get_max_flow

sknetwork/flow/flow.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 7, 2022.
+@author: Henry L. Carscadden <hcarscad@gmail.com>
+"""
+from scipy import sparse
+import numpy as np
+
+from sknetwork.flow.utils import get_residual_graph
+from sknetwork.flow.flow_core import push
+
+
+def residual_to_flow(adjacency: sparse.csr_matrix, residual: sparse.csr_matrix, preflow: sparse.csr_matrix):
+    rows, cols = adjacency.nonzero()
+    for i in range(rows.size):
+        row, col = rows[i], cols[i]
+        preflow[row, col] = residual[col, row]
+    return preflow
+
+
+def push_relabel(adjacency: sparse.csr_matrix, src: int, sink: int):
+    """ This algorithm finds a maximum flow following the classic push-relabel algorithm.
+
+    Parameters
+    ----------
+    adjacency : sparse.csr_matrix
+        The adjacency matrix of the graph with weights containing the edge capacities.
+    src : int
+        The node with the flow source.
+    sink : int
+        The node with that receives the flow.
+
+    Returns
+    -------
+    flow : sparse.csr_matrix
+        A maximum flow for the graph.
+
+    Reference
+    ---------
+    Goldberg, A V; Tarjan, R E (1986). A new approach to the maximum flow problem.
+    Proceedings of the eighteenth annual ACM symposium on Theory of computing – STOC 86.
+    """
+    # Initialize preflow.
+    preflow_vals = np.zeros(dtype=np.int32, shape=(adjacency.nnz,))
+    preflow = sparse.csr_matrix((preflow_vals, adjacency.indices, adjacency.indptr), shape=adjacency.shape)
+    # Initialize the heights to 0.
+    heights = np.zeros(shape=(adjacency.shape[0],), dtype=np.int32)
+    # Set the height of the src to n.
+    heights[src] = adjacency.shape[0]
+    # Create the excess flow array.
+    excess_flow = np.zeros(shape=(adjacency.shape[0],), dtype=np.int32)
+    # Send all the possible flow out of the source.
+    for dest_node in adjacency.indices[adjacency.indptr[src]:adjacency.indptr[src + 1]]:
+        edge_capacity = adjacency[src, dest_node]
+        preflow[src, dest_node] = edge_capacity
+        if edge_capacity > 0:
+            excess_flow[dest_node] = edge_capacity
+    # Initialize the residual graph.
+    residual = get_residual_graph(adjacency, preflow)
+    non_zero_indices = excess_flow.nonzero()[0]
+    # While there are nodes with excess, push or relabel.
+    while non_zero_indices.size > 0:
+        # while nodes have excess
+        # Get nodes from active nodes (excess > 0)
+        for curr_node in non_zero_indices:
+            pushed = push(residual, curr_node, src, sink, heights, excess_flow)
+            # Relabel step
+            if not pushed:
+                heights[curr_node] = heights[curr_node] + 1
+        non_zero_indices = excess_flow.nonzero()[0]
+
+    return residual_to_flow(adjacency, residual, preflow)

sknetwork/flow/tests/__init__.py

@@ -0,0 +1 @@
+"Tests for flow"

sknetwork/flow/tests/test_flow.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for push_relabel.py"""
+import unittest
+
+from sknetwork.flow import get_max_flow, find_excess
+from scipy import sparse
+
+class TestFlow(unittest.TestCase):
+    def test_push_relabel_1(self):
+        adj = sparse.csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+        [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+        [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = get_max_flow(adj, 0, 6)
+        self.assertEqual(3, flow[:, 6].sum())
+        for i in range(1, 6):
+            self.assertEqual(0, find_excess(flow, i))

sknetwork/flow/tests/test_utils.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for utils.py"""
+import unittest
+
+from sknetwork.flow import get_residual_graph, flow_is_feasible, find_excess
+from scipy.sparse import csr_matrix
+
+class TestUtils(unittest.TestCase):
+    def test_get_residual_graph(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+        [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+        [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+        [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        residual = csr_matrix([[0, 1, 3, 0, 0, 0, 0], [1, 0, 0, 2, 0, 0, 0],
+        [0, 0, 0, 2, 0, 0, 0], [0, 1, 0, 0, 0, 3, 0], [0, 0, 0, 1, 0, 0, 1],
+        [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        res_out = get_residual_graph(adjacency, flow, 0, 6)
+        rows, cols = residual.nonzero()
+        for i in range(len(rows)):
+            row, col = rows[i], cols[i]
+            self.assertEquals(residual[row, col], res_out[row, col])
+    def test_flow_is_feasible_1(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+        [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+        [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+        [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        self.assertFalse(flow_is_feasible(adjacency, flow, 0, 6))
+    def test_flow_is_feasible_2(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+            [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+            [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 2, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        self.assertFalse(flow_is_feasible(adjacency, flow, 0, 6))
+    def test_flow_is_feasible_3(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+                [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+                [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        self.assertTrue(flow_is_feasible(adjacency, flow, 0, 6))
+    def test_flow_is_feasible_4(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+                [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+                [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 0]])
+        self.assertRaises(ValueError, flow_is_feasible, adjacency, flow, 0, 6)
+    def test_flow_is_feasible_3(self):
+        adjacency = csr_matrix([[0, 2, 3, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0],
+                [0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 1, 3, 0], [0, 0, 0, 0, 0, 0, 2],
+                [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0]])
+        flow = csr_matrix([[0, 10, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        self.assertFalse(flow_is_feasible(adjacency, flow, 0, 6))
+    def test_find_excess(self):
+        flow = csr_matrix([[0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
+        self.assertEquals(0, find_excess(flow, 1))

sknetwork/flow/utils.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 4, 2022.
+@author: Henry L. Carscadden <hcarscad@gmail.com>
+"""
+from scipy import sparse
+import numpy as np
+
+
+def find_excess(flow: sparse.csr_matrix, node: int):
+    """
+    This function computes the excess flow for a node in a preflow.
+    Parameters
+    ----------
+    flow: sparse.csr_matrix
+        The matrix showing the flows in the proposed solution.
+    node : int
+        Node to compute the excess on.
+
+    Returns
+    -------
+    excess: int
+        The amount of excess flow.
+    """
+    return flow[:, node].sum() - flow[node, :].sum()
+
+
+def flow_is_feasible(adjacency: sparse.csr_matrix, flow: sparse.csr_matrix, src: int, sink: int):
+    """ This utility is used to check if a provided flow satisfies the capacity and flow conservation constraints.
+
+    Parameters
+    ----------
+    adjacency : sparse.csr_matrix
+        The adjacency matrix of the graph with weights containing the edge capacities.
+    flow: sparse.csr_matrix
+        The matrix showing the flows in the proposed solution.
+    src : int
+        The node with the flow source.
+    sink : int
+        The node with that receives the flow.
+
+
+    Returns
+    -------
+    feasible: bool
+        Whether the follow is feasible, i.e., both the capacity and flow constraints are satisfied.
+    """
+    if adjacency.shape != flow.shape:
+        raise ValueError("The flow has the incorrect shape.")
+
+    rows, cols = adjacency.nonzero()
+    for row in rows:
+        if row != src and row != sink:
+            if flow[row, :].sum() != flow[:, row].sum():
+                return False
+    for i in range(rows.size):
+        row, col = rows[i], cols[i]
+        if adjacency[row, col] < flow[row, col]:
+            return False
+    return True
+
+
+def get_residual_graph(adjacency: sparse.csr_matrix, flow: sparse.csr_matrix):
+    """ This utility is used for maximum flow algorithms to find the residual graph given a flow.
+
+    Parameters
+    ----------
+    adjacency : sparse.csr_matrix
+        The adjacency matrix of the graph with weights containing the edge capacities.
+    flow: sparse.csr_matrix
+        The matrix showing the flows in the proposed solution.
+
+    Returns
+    -------
+    residual: sparse.csr_matrix
+        The adjacency matrix of the residual graph.
+    """
+    rows, cols = adjacency.nonzero()
+    row_ind = np.zeros(shape=(adjacency.nnz * 2), dtype=np.int)
+    col_ind = np.zeros(shape=(adjacency.nnz * 2), dtype=np.int)
+    data = np.zeros(shape=(adjacency.nnz * 2), dtype=np.int)
+    for i in range(rows.size):
+        row, col = rows[i], cols[i]
+        curr_ind = i * 2
+        row_ind[curr_ind], col_ind[curr_ind] = row, col
+        row_ind[curr_ind + 1], col_ind[curr_ind + 1] = col, row
+        data[curr_ind] = adjacency[row, col] - flow[row, col]
+        data[curr_ind + 1] = flow[row, col]
+    residual = sparse.csr_matrix((data, (row_ind, col_ind)), shape=adjacency.shape)
+    return residual

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,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 2022
+@author: Simon Delarue <sdelarue@enst.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+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.utils.verbose import VerboseMixin
+
+
+class BaseGNN(VerboseMixin):
+    """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):
+        VerboseMixin.__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, *args, **kwargs):
+        """Predict labels."""
+        raise NotImplementedError
+
+    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 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.embedding_
+
+    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