scikit-network 0.33.4__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

sknetwork/embedding/base.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from abc import ABC
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.topology.structure import is_connected
+from sknetwork.base import Algorithm
+
+
+class BaseEmbedding(Algorithm, ABC):
+    """Base class for embedding algorithms.
+
+    Attributes
+    ----------
+    embedding\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+    """
+    def __init__(self):
+        self._init_vars()
+
+    def transform(self) -> np.ndarray:
+        """Return the embedding.
+
+        Returns
+        -------
+        embedding : np.ndarray
+            Embedding.
+        """
+        return self.embedding_
+
+    def fit_transform(self, *args, **kwargs) -> np.ndarray:
+        """Fit to data and return the embedding. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        embedding : np.ndarray
+            Embedding.
+        """
+        self.fit(*args, **kwargs)
+        return self.embedding_
+
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the embedding of nodes.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
+
+        Returns
+        -------
+        embedding : np.ndarray
+            Embedding of the nodes.
+        """
+        if columns:
+            return self.embedding_col_
+        return self.embedding_
+
+    @staticmethod
+    def _get_regularization(regularization: float, adjacency: sparse.csr_matrix) -> float:
+        """Set proper regularization depending on graph connectivity."""
+        if regularization < 0:
+            if is_connected(adjacency, connection='strong'):
+                regularization = 0
+            else:
+                regularization = np.abs(regularization)
+        return regularization
+
+    def _init_vars(self):
+        self.embedding_ = None
+        self.embedding_row_ = None
+        self.embedding_col_ = None
+
+    def _check_fitted(self):
+        return self.embedding_ is not None
+
+    def _split_vars(self, shape):
+        """Split labels_ into labels_row_ and labels_col_"""
+        n_row = shape[0]
+        self.embedding_row_ = self.embedding_[:n_row]
+        self.embedding_col_ = self.embedding_[n_row:]
+        self.embedding_ = self.embedding_row_
+        return self

sknetwork/embedding/force_atlas.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on Jun 2020
+@author: Victor Manach <victor.manach@telecom-paris.fr>
+@author: Rémi Jaylet <remi.jaylet@telecom-paris.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+from scipy.spatial import cKDTree
+
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.utils.check import check_format, is_symmetric, check_square
+from sknetwork.utils.format import directed2undirected
+
+
+class ForceAtlas(BaseEmbedding):
+    """Force Atlas layout for displaying graphs.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the graph layout.
+    n_iter : int
+        Number of iterations to update positions.
+        If ``None``, use the value of self.n_iter.
+    approx_radius : float
+        If a positive value is provided, only the nodes within this distance a given node are used to compute
+        the repulsive force.
+    lin_log : bool
+        If ``True``, use lin-log mode.
+    gravity_factor : float
+        Gravity force scaling constant.
+    repulsive_factor : float
+        Repulsive force scaling constant.
+    tolerance : float
+        Tolerance defined in the swinging constant.
+    speed : float
+        Speed constant.
+    speed_max : float
+        Constant used to impose constrain on speed.
+
+    Attributes
+    ----------
+    embedding\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+
+    Example
+    -------
+    >>> from sknetwork.embedding.force_atlas import ForceAtlas
+    >>> from sknetwork.data import karate_club
+    >>> force_atlas = ForceAtlas()
+    >>> adjacency = karate_club()
+    >>> embedding = force_atlas.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    References
+    ----------
+    Jacomy M., Venturini T., Heymann S., Bastian M. (2014).
+    `ForceAtlas2, a Continuous Graph Layout Algorithm for Handy Network Visualization Designed for the Gephi Software.
+    <https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0098679>`_
+    Plos One.
+    """
+    def __init__(self, n_components: int = 2, n_iter: int = 50, approx_radius: float = -1, lin_log: bool = False,
+                 gravity_factor: float = 0.01, repulsive_factor: float = 0.1, tolerance: float = 0.1,
+                 speed: float = 0.1, speed_max: float = 10):
+        super(ForceAtlas, self).__init__()
+        self.n_components = n_components
+        self.n_iter = n_iter
+        self.approx_radius = approx_radius
+        self.lin_log = lin_log
+        self.gravity_factor = gravity_factor
+        self.repulsive_factor = repulsive_factor
+        self.tolerance = tolerance
+        self.speed = speed
+        self.speed_max = speed_max
+        self.embedding_ = None
+
+    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray], pos_init: Optional[np.ndarray] = None,
+            n_iter: Optional[int] = None) -> 'ForceAtlas':
+        """Compute layout.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph, treated as undirected.
+        pos_init :
+            Position to start with. Random if not provided.
+        n_iter : int
+            Number of iterations to update positions.
+            If ``None``, use the value of self.n_iter.
+
+        Returns
+        -------
+        self: :class:`ForceAtlas`
+        """
+        # verify the format of the adjacency matrix
+        adjacency = check_format(adjacency)
+        check_square(adjacency)
+        if not is_symmetric(adjacency):
+            adjacency = directed2undirected(adjacency)
+        n = adjacency.shape[0]
+
+        # setting of the tolerance according to the size of the graph
+        if n < 5000:
+            tolerance = 0.1
+        elif 5000 <= n < 50000:  # pragma: no cover
+            tolerance = 1
+        else:  # pragma: no cover
+            tolerance = 10
+
+        if n_iter is None:
+            n_iter = self.n_iter
+
+        # initial position of the nodes of the graph
+        if pos_init is None:
+            position: np.ndarray = np.random.randn(n, self.n_components)
+        else:
+            if pos_init.shape != (n, self.n_components):
+                raise ValueError('The initial position does not have valid dimensions.')
+            else:
+                position = pos_init
+        # compute the vector with the degree of each node
+        degree: np.ndarray = adjacency.dot(np.ones(adjacency.shape[1])) + 1
+
+        # initialization of variation of position of nodes
+        resultants = np.zeros(n)
+        delta: np.ndarray = np.zeros((n, self.n_components))
+        swing_vector: np.ndarray = np.zeros(n)
+        global_speed = 1
+
+        for iteration in range(n_iter):
+            delta *= 0
+            global_swing = 0
+            global_traction = 0
+
+            if self.approx_radius > 0:
+                tree = cKDTree(position)
+            else:
+                tree = None
+
+            for i in range(n):
+
+                # attraction
+                indices = adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i + 1]]
+                attraction = position[i] - position[indices]
+
+                if self.lin_log:
+                    attraction = np.sign(attraction) * np.log(1 + np.abs(10 * attraction))
+                attraction = attraction.sum(axis=0)
+
+                # repulsion
+                if tree is None:
+                    neighbors = np.arange(n)
+                else:
+                    neighbors = tree.query_ball_point(position[i], self.approx_radius, p=2)
+
+                grad: np.ndarray = (position[i] - position[neighbors])  # shape (n_neigh, n_components)
+                distance: np.ndarray = np.linalg.norm(grad, axis=1)  # shape (n_neigh,)
+                distance = np.where(distance < 0.01, 0.01, distance)
+                repulsion = grad * (degree[neighbors] / distance)[:, np.newaxis]
+
+                repulsion *= self.repulsive_factor * degree[i]
+                repulsion = repulsion.sum(axis=0)
+
+                # gravity
+                gravity = self.gravity_factor * degree[i] * grad
+                gravity = gravity.sum(axis=0)
+
+                # forces resultant applied on node i for traction, swing and speed computation
+                force = repulsion - attraction - gravity
+                resultant_new: float = np.linalg.norm(force)
+                resultant_old: float = resultants[i]
+
+                swing_node: float = np.abs(resultant_new - resultant_old)  # force variation applied on node i
+                swing_vector[i] = swing_node
+                global_swing += (degree[i] + 1) * swing_node
+
+                traction: float = np.abs(resultant_new + resultant_old) / 2  # traction force applied on node i
+                global_traction += (degree[i] + 1) * traction
+
+                node_speed = self.speed * global_speed / (1 + global_speed * np.sqrt(swing_node))
+                if node_speed > self.speed_max / resultant_new:  # pragma: no cover
+                    node_speed = self.speed_max / resultant_new
+
+                delta[i]: np.ndarray = node_speed * force
+                resultants[i] = resultant_new
+                global_speed = tolerance * global_traction / global_swing
+
+            position += delta  # calculating displacement and final position of points after iteration
+            if (swing_vector < 1).all():
+                break  # if the swing of all nodes is zero, then convergence is reached.
+
+        self.embedding_ = position
+        return self

sknetwork/embedding/louvain_embedding.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in September 2020
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.clustering.louvain import Louvain
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.utils.check import check_random_state, check_adjacency_vector, check_nonnegative, is_square
+from sknetwork.utils.membership import get_membership
+
+
+def reindex_labels(labels: np.ndarray, labels_secondary: Optional[np.ndarray] = None, which: str = 'remove'):
+    """Reindex labels, removing or merging labels of count 1."""
+    labels_unique, counts = np.unique(labels, return_counts=True)
+    n_labels = max(labels_unique) + 1
+    labels_keep = labels_unique[counts > 1]
+    if which == 'remove':
+        label_index = -np.ones(n_labels, dtype='int')
+        label_index[labels_keep] = np.arange(len(labels_keep))
+    elif which == 'merge':
+        label_index = len(labels_keep) * np.ones(n_labels, dtype='int')
+        label_index[labels_keep] = np.arange(len(labels_keep))
+    else:
+        label_index = np.arange(n_labels)
+    labels = label_index[labels]
+    if labels_secondary is not None:
+        labels_unique = np.unique(labels_secondary)
+        n_labels = max(labels_unique) + 1
+        label_index = -np.ones(n_labels, dtype='int')
+        label_index[labels_keep] = np.arange(len(labels_keep))
+        labels_secondary = label_index[labels_secondary]
+    return labels, labels_secondary
+
+
+class LouvainEmbedding(BaseEmbedding):
+    """Embedding of graphs induced by Louvain clustering. Each component of the embedding corresponds
+    to a cluster obtained by Louvain.
+
+    Parameters
+    ----------
+    resolution : float
+        Resolution parameter.
+    modularity : str
+        Which objective function to maximize. Can be ``'Dugue'``, ``'Newman'`` or ``'Potts'``.
+    tol_optimization :
+        Minimum increase in the objective function to enter a new optimization pass.
+    tol_aggregation :
+        Minimum increase in the objective function to enter a new aggregation pass.
+    n_aggregations :
+        Maximum number of aggregations.
+        A negative value is interpreted as no limit.
+    shuffle_nodes :
+        Enables node shuffling before optimization.
+    random_state :
+        Random number generator or random seed. If ``None``, numpy.random is used.
+    isolated_nodes : str
+        What to do with isolated column nodes. Can be ``'remove'`` (default), ``'merge'`` or ``'keep'``.
+
+    Attributes
+    ----------
+    embedding\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+    labels\_ : np.ndarray, shape = (n_nodes,)
+        Labels of the nodes, used for the embedding.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import LouvainEmbedding
+    >>> from sknetwork.data import house
+    >>> louvain = LouvainEmbedding()
+    >>> adjacency = house()
+    >>> embedding = louvain.fit_transform(adjacency)
+    >>> embedding.shape
+    (5, 2)
+    """
+    def __init__(self, resolution: float = 1, modularity: str = 'Dugue', tol_optimization: float = 1e-3,
+                 tol_aggregation: float = 1e-3, n_aggregations: int = -1, shuffle_nodes: bool = False,
+                 random_state: Optional[Union[np.random.RandomState, int]] = None, isolated_nodes: str = 'remove'):
+        super(LouvainEmbedding, self).__init__()
+        self.resolution = resolution
+        self.modularity = modularity.lower()
+        self.tol_optimization = tol_optimization
+        self.tol_aggregation = tol_aggregation
+        self.n_aggregations = n_aggregations
+        self.shuffle_nodes = shuffle_nodes
+        self.random_state = check_random_state(random_state)
+        self.isolated_nodes = isolated_nodes
+
+        self.labels_ = None
+        self.embedding_ = None
+        self.embedding_row_ = None
+        self.embedding_col_ = None
+
+    def fit(self, input_matrix: sparse.csr_matrix, force_bipartite: bool = False):
+        """Embedding of graphs from the clustering obtained with Louvain.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite : bool (default = ``False``)
+            If ``True``, force the input matrix to be considered as a biadjacency matrix.
+        Returns
+        -------
+        self: :class:`BiLouvainEmbedding`
+        """
+        louvain = Louvain(resolution=self.resolution, modularity=self.modularity,
+                          tol_optimization=self.tol_optimization, tol_aggregation=self.tol_aggregation,
+                          n_aggregations=self.n_aggregations, shuffle_nodes=self.shuffle_nodes, sort_clusters=False,
+                          return_probs=True, return_aggregate=True, random_state=self.random_state)
+        louvain.fit(input_matrix, force_bipartite=force_bipartite)
+
+        # isolated nodes
+        if is_square(input_matrix):
+            labels = louvain.labels_
+            labels_secondary = None
+        else:
+            labels = louvain.labels_col_
+            labels_secondary = louvain.labels_row_
+
+        self.labels_, labels_row = reindex_labels(labels, labels_secondary, self.isolated_nodes)
+
+        # embedding
+        probs = normalize(input_matrix)
+        embedding_ = probs.dot(get_membership(self.labels_))
+        self.embedding_ = embedding_.toarray()
+
+        if labels_row is not None:
+            probs = normalize(input_matrix.T)
+            embedding_col = probs.dot(get_membership(labels_row))
+            self.embedding_row_ = self.embedding_
+            self.embedding_col_ = embedding_col.toarray()
+
+        return self

sknetwork/embedding/random_projection.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in January 2021
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from abc import ABC
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg import Regularizer, Normalizer, normalize
+from sknetwork.utils.check import check_format, check_random_state
+from sknetwork.utils.format import get_adjacency
+
+
+class RandomProjection(BaseEmbedding, ABC):
+    """Embedding of graphs based the random projection of the adjacency matrix:
+
+    :math:`(I + \\alpha A +... + (\\alpha A)^K)G`
+
+    where :math:`A` is the adjacency matrix, :math:`G` is a random Gaussian matrix,
+    :math:`\\alpha` is some smoothing factor and :math:`K` some non-negative integer.
+
+    Parameters
+    ----------
+    n_components : int (default = 2)
+        Dimension of the embedding space.
+    alpha : float (default = 0.5)
+        Smoothing parameter.
+    n_iter : int (default = 3)
+        Number of power iterations of the adjacency matrix.
+    random_walk : bool (default = ``False``)
+        If ``True``, use the transition matrix of the random walk, :math:`P = D^{-1}A`, instead of the adjacency matrix.
+    regularization : float (default = ``-1``)
+        Regularization factor :math:`\\alpha` so that the matrix is :math:`A + \\alpha \\frac{11^T}{n}`.
+        If negative, regularization is applied only if the graph is disconnected (and then equal to the absolute value
+        of the parameter).
+    normalized : bool (default = ``True``)
+        If ``True``, normalize the embedding so that each vector has norm 1 in the embedding space, i.e.,
+        each vector lies on the unit sphere.
+    random_state : int, optional
+        Seed used by the random number generator.
+
+    Attributes
+    ----------
+    embedding\_ : array, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import RandomProjection
+    >>> from sknetwork.data import karate_club
+    >>> projection = RandomProjection()
+    >>> adjacency = karate_club()
+    >>> embedding = projection.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    References
+    ----------
+    Zhang, Z., Cui, P., Li, H., Wang, X., & Zhu, W. (2018).
+    Billion-scale network embedding with iterative random projection, ICDM.
+    """
+    def __init__(self, n_components: int = 2, alpha: float = 0.5, n_iter: int = 3, random_walk: bool = False,
+                 regularization: float = -1, normalized: bool = True, random_state: int = None):
+        super(RandomProjection, self).__init__()
+
+        self.embedding_ = None
+        self.n_components = n_components
+        self.alpha = alpha
+        self.n_iter = n_iter
+        self.random_walk = random_walk
+        self.regularization = regularization
+        self.normalized = normalized
+        self.random_state = random_state
+        self.bipartite = None
+        self.regularized = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) \
+            -> 'RandomProjection':
+        """Compute the graph embedding.
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+              Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite : bool (default = ``False``)
+            If ``True``, force the input matrix to be considered as a biadjacency matrix.
+        Returns
+        -------
+        self: :class:`RandomProjection`
+        """
+        # input
+        input_matrix = check_format(input_matrix)
+        adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+        n = adjacency.shape[0]
+
+        # regularization
+        regularization = self._get_regularization(self.regularization, adjacency)
+        self.regularized = regularization > 0
+
+        # multiplier
+        if self.random_walk:
+            multiplier = Normalizer(adjacency, regularization)
+        else:
+            multiplier = Regularizer(adjacency, regularization)
+
+        # random matrix
+        random_generator = check_random_state(self.random_state)
+        random_matrix = random_generator.normal(size=(n, self.n_components))
+        random_matrix, _ = np.linalg.qr(random_matrix)
+
+        # random projection
+        factor = random_matrix
+        embedding = factor.copy()
+        for t in range(self.n_iter):
+            factor = self.alpha * multiplier.dot(factor)
+            embedding += factor
+
+        # normalization
+        if self.normalized:
+            embedding = normalize(embedding, p=2)
+
+        # output
+        self.embedding_ = embedding
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+        return self

sknetwork/embedding/spectral.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on September 2018
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg import LanczosEig, Laplacian, Normalizer, normalize
+from sknetwork.utils.format import get_adjacency
+from sknetwork.utils.check import check_format, check_adjacency_vector, check_nonnegative, check_n_components
+
+
+class Spectral(BaseEmbedding):
+    """Spectral embedding of graphs, based the spectral decomposition of the Laplacian matrix :math:`L = D - A`
+    or the transition matrix of the random walk :math:`P = D^{-1}A` (default), where :math:`D` is the
+    diagonal matrix of degrees.
+
+    Eigenvectors are considered in increasing order (for the Laplacian matrix :math:`L`) or decreasing order
+    (for the transition matrix of the random walk :math:`P`) of eigenvalues, skipping the first.
+
+    Parameters
+    ----------
+    n_components : int (default = ``2``)
+        Dimension of the embedding space.
+    decomposition : str (``laplacian`` or ``rw``, default = ``rw``)
+        Matrix used for the spectral decomposition.
+    regularization : float (default = ``-1``)
+        Regularization factor :math:`\\alpha` so that the adjacency matrix is :math:`A + \\alpha \\frac{11^T}{n}`.
+        If negative, regularization is applied only if the graph is disconnected; the regularization factor
+        :math:`\\alpha` is then set to the absolute value of the parameter.
+    normalized : bool (default = ``True``)
+        If ``True``, normalized the embedding so that each vector has norm 1 in the embedding space, i.e.,
+        each vector lies on the unit sphere.
+    Attributes
+    ----------
+    embedding\_ : np.ndarray, shape = (n_nodes, n_components)
+        Embedding of the nodes.
+    eigenvalues\_ : np.ndarray, shape = (n_components)
+        Eigenvalues.
+    eigenvectors\_ : np.ndarray, shape = (n_nodes, n_components)
+        Eigenvectors.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import Spectral
+    >>> from sknetwork.data import karate_club
+    >>> spectral = Spectral(n_components=3)
+    >>> adjacency = karate_club()
+    >>> embedding = spectral.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 3)
+
+    References
+    ----------
+    Belkin, M. & Niyogi, P. (2003). Laplacian Eigenmaps for Dimensionality Reduction and Data Representation,
+    Neural computation.
+    """
+    def __init__(self, n_components: int = 2, decomposition: str = 'rw', regularization: float = -1,
+                 normalized: bool = True):
+        super(Spectral, self).__init__()
+
+        self.embedding_ = None
+        self.n_components = n_components
+        self.decomposition = decomposition
+        self.regularization = regularization
+        self.normalized = normalized
+        self.bipartite = None
+        self.regularized = None
+        self.eigenvalues_ = None
+        self.eigenvectors_ = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) -> 'Spectral':
+        """Compute the graph embedding.
+
+        If the input matrix :math:`B` is not square (e.g., biadjacency matrix of a bipartite graph) or not symmetric
+        (e.g., adjacency matrix of a directed graph), use the adjacency matrix
+
+        :math:`A  = \\begin{bmatrix} 0 & B \\\\ B^T & 0 \\end{bmatrix}`
+
+        and return the embedding for both rows and columns of the input matrix :math:`B`.
+
+        Parameters
+        ----------
+        input_matrix :
+              Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite : bool (default = ``False``)
+            If ``True``, force the input matrix to be considered as a biadjacency matrix.
+
+        Returns
+        -------
+        self: :class:`Spectral`
+        """
+        # input
+        input_matrix = check_format(input_matrix)
+        adjacency, self.bipartite = get_adjacency(input_matrix, allow_directed=False, force_bipartite=force_bipartite)
+        n = adjacency.shape[0]
+
+        # regularization
+        regularization = self._get_regularization(self.regularization, adjacency)
+        self.regularized = regularization > 0
+
+        # laplacian
+        normalized_laplacian = self.decomposition == 'rw'
+        laplacian = Laplacian(adjacency, regularization, normalized_laplacian)
+
+        # spectral decomposition
+        n_components = check_n_components(self.n_components, n - 2) + 1
+        solver = LanczosEig(which='SM')
+        solver.fit(matrix=laplacian, n_components=n_components)
+        index = np.argsort(solver.eigenvalues_)[1:]  # increasing order, skip first
+
+        eigenvalues = solver.eigenvalues_[index]
+        eigenvectors = solver.eigenvectors_[:, index]
+
+        if normalized_laplacian:
+            eigenvectors = laplacian.norm_diag.dot(eigenvectors)
+            eigenvalues = 1 - eigenvalues
+
+        # embedding
+        embedding = eigenvectors.copy()
+        if self.normalized:
+            embedding = normalize(embedding, p=2)
+
+        # output
+        self.embedding_ = embedding
+        self.eigenvalues_ = eigenvalues
+        self.eigenvectors_ = eigenvectors
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+        return self