scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/embedding/random_projection.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on January, 15 2021
+@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 Regularizer, Normalizer, normalize
+from sknetwork.utils.check import check_format, check_random_state
+from sknetwork.utils.format import get_adjacency
+
+
+class RandomProjection(BaseEmbedding):
+    """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, n_components)
+        Embedding of the nodes.
+    embedding_row_ : array, shape = (n_row, n_components)
+        Embedding of the rows, for bipartite graphs.
+    embedding_col_ : array, shape = (n_col, n_components)
+        Embedding of the columns, for bipartite graphs.
+
+    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.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 :
+              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,214 @@
+#!/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_ : array, shape = (n, n_components)
+        Embedding of the nodes.
+    embedding_row_ : array, shape = (n_row, n_components)
+        Embedding of the rows, for bipartite graphs.
+    embedding_col_ : array, shape = (n_col, n_components)
+        Embedding of the columns, for bipartite graphs.
+    eigenvalues_ : array, shape = (n_components)
+        Eigenvalues.
+    eigenvectors_ : array, shape = (n, 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
+
+    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
+        """Predict the embedding of new nodes, when possible (otherwise return 0).
+
+        Each new node is defined by its adjacency row vector.
+
+        Parameters
+        ----------
+        adjacency_vectors :
+            Adjacency vectors of nodes.
+            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
+
+        Returns
+        -------
+        embedding_vectors : np.ndarray
+            Embedding of the nodes.
+
+        Example
+        -------
+        >>> from sknetwork.embedding import Spectral
+        >>> from sknetwork.data import karate_club
+        >>> spectral = Spectral(n_components=3)
+        >>> adjacency = karate_club()
+        >>> adjacency_vector = np.arange(34) < 5
+        >>> _ = spectral.fit(adjacency)
+        >>> len(spectral.predict(adjacency_vector))
+        3
+        """
+        self._check_fitted()
+
+        # input
+        if self.bipartite:
+            n = len(self.embedding_col_)
+        else:
+            n = len(self.embedding_)
+        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
+        check_nonnegative(adjacency_vectors)
+
+        if self.bipartite:
+            shape = (adjacency_vectors.shape[0], self.embedding_row_.shape[0])
+            adjacency_vectors = sparse.csr_matrix(adjacency_vectors)
+            adjacency_vectors = sparse.hstack([sparse.csr_matrix(shape), adjacency_vectors], format='csr')
+        eigenvectors = self.eigenvectors_
+        eigenvalues = self.eigenvalues_
+
+        # regularization
+        if self.regularized:
+            regularization = np.abs(self.regularization)
+        else:
+            regularization = 0
+        normalizer = Normalizer(adjacency_vectors, regularization)
+
+        # prediction
+        embedding_vectors = normalizer.dot(eigenvectors)
+        normalized_laplacian = self.decomposition == 'rw'
+        if normalized_laplacian:
+            norm_vect = eigenvalues.copy()
+            norm_vect[norm_vect == 0] = 1
+            embedding_vectors /= norm_vect
+        else:
+            norm_matrix = sparse.csr_matrix(1 - np.outer(normalizer.norm_diag.data, eigenvalues))
+            norm_matrix.data = 1 / norm_matrix.data
+            embedding_vectors *= norm_matrix.toarray()
+
+        # normalization
+        if self.normalized:
+            embedding_vectors = normalize(embedding_vectors, p=2)
+
+        # shape
+        if len(embedding_vectors) == 1:
+            embedding_vectors = embedding_vectors.ravel()
+
+        return embedding_vectors

sknetwork/embedding/spring.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+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.embedding.spectral import Spectral
+from sknetwork.linalg import normalize
+from sknetwork.utils.check import check_adjacency_vector, check_format, check_square, is_symmetric
+from sknetwork.utils.format import directed2undirected
+
+
+class Spring(BaseEmbedding):
+    """Spring layout for displaying small graphs.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the graph layout.
+    strength : float
+        Intensity of the force that moves the nodes.
+    n_iter : int
+        Number of iterations to update positions.
+    tol : float
+        Minimum relative change in positions to continue updating.
+    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.
+    position_init : str
+        How to initialize the layout. If 'spectral', use Spectral embedding in dimension 2,
+        otherwise, use random initialization.
+
+    Attributes
+    ----------
+    embedding_ : np.ndarray
+        Layout.
+
+    Example
+    -------
+    >>> from sknetwork.embedding import Spring
+    >>> from sknetwork.data import karate_club
+    >>> spring = Spring()
+    >>> adjacency = karate_club()
+    >>> embedding = spring.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 2)
+
+    Notes
+    -----
+    Simple implementation designed to display small graphs.
+
+    References
+    ----------
+    Fruchterman, T. M. J.,  Reingold, E. M. (1991).
+    `Graph Drawing by Force-Directed Placement.
+    <https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.4380211102>`_
+    Software – Practice & Experience.
+    """
+    def __init__(self, n_components: int = 2, strength: float = None, n_iter: int = 50, tol: float = 1e-4,
+                 approx_radius: float = -1, position_init: str = 'random'):
+        super(Spring, self).__init__()
+        self.n_components = n_components
+        self.strength = strength
+        self.n_iter = n_iter
+        self.tol = tol
+        self.approx_radius = approx_radius
+        if position_init not in ['random', 'spectral']:
+            raise ValueError('Unknown initial position, try "spectral" or "random".')
+        else:
+            self.position_init = position_init
+
+    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray], position_init: Optional[np.ndarray] = None,
+            n_iter: Optional[int] = None) -> 'Spring':
+        """Compute layout.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph, treated as undirected.
+        position_init : np.ndarray
+            Custom initial positions of the nodes. Shape must be (n, 2).
+            If ``None``, use the value of self.pos_init.
+        n_iter : int
+            Number of iterations to update positions.
+            If ``None``, use the value of self.n_iter.
+
+        Returns
+        -------
+        self: :class:`Spring`
+        """
+        adjacency = check_format(adjacency)
+        check_square(adjacency)
+        if not is_symmetric(adjacency):
+            adjacency = directed2undirected(adjacency)
+        n = adjacency.shape[0]
+
+        position = np.zeros((n, self.n_components))
+        if position_init is None:
+            if self.position_init == 'random':
+                position = np.random.randn(n, self.n_components)
+            elif self.position_init == 'spectral':
+                position = Spectral(n_components=self.n_components).fit_transform(adjacency)
+        elif isinstance(position_init, np.ndarray):
+            if position_init.shape == (n, self.n_components):
+                position = position_init.copy()
+            else:
+                raise ValueError('Initial position has invalid shape.')
+        else:
+            raise TypeError('Initial position must be a numpy array.')
+
+        if n_iter is None:
+            n_iter = self.n_iter
+
+        if self.strength is None:
+            strength = np.sqrt((1 / n))
+        else:
+            strength = self.strength
+
+        pos_max = position.max(axis=0)
+        pos_min = position.min(axis=0)
+        step_max: float = 0.1 * (pos_max - pos_min).max()
+        step: float = step_max / (n_iter + 1)
+        tree = None
+
+        delta = np.zeros((n, self.n_components))
+        for iteration in range(n_iter):
+            delta *= 0
+            if self.approx_radius > 0:
+                tree = cKDTree(position)
+
+            for i in range(n):
+                # attraction
+                indices = adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]
+                attraction = adjacency.data[adjacency.indptr[i]:adjacency.indptr[i+1]] / strength
+
+                grad = position[i] - position[indices]
+                attraction *= np.linalg.norm(grad, axis=1)
+                attraction = (grad * attraction[:, np.newaxis]).sum(axis=0)
+
+                # repulsion
+                if tree is None:
+                    grad: np.ndarray = (position[i] - position)  # shape (n, n_components)
+                    distance: np.ndarray = np.linalg.norm(grad, axis=1)  # shape (n,)
+                else:
+                    neighbors = tree.query_ball_point(position[i], self.approx_radius)
+                    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 * (strength / distance)[:, np.newaxis] ** 2).sum(axis=0)
+
+                # total force
+                delta[i]: np.ndarray = repulsion - attraction
+
+            length = np.linalg.norm(delta, axis=0)
+            length = np.where(length < 0.01, 0.1, length)
+            delta = delta * step_max / length
+            position += delta
+            step_max -= step
+            err: float = np.linalg.norm(delta) / n
+            if err < self.tol:
+                break
+
+        self.embedding_ = position
+        return self
+
+    def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
+        """Predict the embedding of new rows, defined by their adjacency vectors.
+
+        Parameters
+        ----------
+        adjacency_vectors :
+            Adjacency vectors of nodes.
+            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
+
+        Returns
+        -------
+        embedding_vectors : np.ndarray
+            Embedding of the nodes.
+        """
+        self._check_fitted()
+        embedding = self.embedding_
+        n = embedding.shape[0]
+
+        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
+        embedding_vectors = normalize(adjacency_vectors).dot(embedding)
+
+        if embedding_vectors.shape[0] == 1:
+            embedding_vectors = embedding_vectors.ravel()
+
+        return embedding_vectors