scikit-network 0.33.3__cp313-cp313-macosx_10_13_x86_64.whl

sknetwork/linalg/diteration.pyx

@@ -0,0 +1,47 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+cimport cython
+from cython.parallel import prange
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def diffusion(int[:] indptr, int[:] indices, float[:] data, float[:] scores, float[:] fluid,
+              float damping_factor, int n_iter, float tol):
+    """One loop of fluid diffusion."""
+    cdef int n = fluid.shape[0]
+    cdef int i
+    cdef int j
+    cdef int j1
+    cdef int j2
+    cdef int jj
+    cdef float sent
+    cdef float tmp
+    cdef float removed
+    cdef float restart_prob = 1 - damping_factor
+    cdef float residu = restart_prob
+
+    for k in range(n_iter):
+        for i in prange(n, nogil=True, schedule='guided'):
+            sent = fluid[i]
+            if sent > 0:
+                scores[i] += sent
+                fluid[i] = 0
+                j1 = indptr[i]
+                j2 = indptr[i+1]
+                tmp = sent * damping_factor
+                if j2 != j1:
+                    for jj in range(j1, j2):
+                        j = indices[jj]
+                        fluid[j] += tmp * data[jj]
+                    removed = sent * restart_prob
+                else:
+                    removed = sent
+                residu -= removed
+        if residu < tol * restart_prob:
+            return
+    return

sknetwork/linalg/eig_solver.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on July 9 2019
+@author: Nathan De Lara <nathan.delara@polytechnique.org>
+"""
+from abc import ABC
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import eigsh
+from sknetwork.base import Algorithm
+
+
+class EigSolver(Algorithm, ABC):
+    """Generic class for eigensolvers.
+
+    Parameters
+    ----------
+    which: str
+        Which eigenvectors and eigenvalues to find:
+
+        * ``'LM'`` : Largest (in magnitude) eigenvalues.
+        * ``'SM'` : Smallest (in magnitude) eigenvalues.
+
+    Attributes
+    ----------
+    eigenvectors_: np.ndarray
+        Two-dimensional array, each column is an eigenvector of the input.
+    eigenvalues_: np.ndarray
+        Eigenvalues associated to each eigenvector.
+    """
+    def __init__(self, which='LM'):
+        self.which = which
+
+        self.eigenvectors_ = None
+        self.eigenvalues_ = None
+
+
+class LanczosEig(EigSolver):
+    """Eigenvalue solver using Lanczos method.
+
+    Parameters
+    ----------
+    which : str
+        Which eigenvectors and eigenvalues to find:
+
+        * ``'LM'`` : Largest (in modulus) eigenvalues.
+        * ``'SM'`` : Smallest (in modulus) eigenvalues.
+        * ``'LA'`` : Largest (algebraic) eigenvalues.
+        * ``'SA'`` : Smallest (algebraic) eigenvalues.
+
+    n_iter : int
+        Maximum number of Arnoldi update iterations allowed.
+        Default = 10 * nb of rows.
+    tol : float
+        Relative accuracy for eigenvalues (stopping criterion).
+        Default = 0 (machine precision).
+    Attributes
+    ----------
+    eigenvectors_: np.ndarray
+        Two-dimensional array, each column is an eigenvector of the input.
+    eigenvalues_: np.ndarray
+        Eigenvalues associated to each eigenvector.
+
+    See Also
+    --------
+    scipy.sparse.linalg.eigsh
+    """
+    def __init__(self, which='LM', n_iter: int = None, tol: float = 0.):
+        super(LanczosEig, self).__init__(which=which)
+        self.n_iter = n_iter
+        self.tol = tol
+
+    def fit(self, matrix: Union[sparse.csr_matrix, sparse.linalg.LinearOperator], n_components: int = 2):
+        """Perform spectral decomposition on symmetric input matrix.
+
+        Parameters
+        ----------
+        matrix : sparse.csr_matrix or linear operator
+            Matrix to decompose.
+        n_components : int
+            Number of eigenvectors to compute
+
+        Returns
+        -------
+        self: :class:`EigSolver`
+        """
+        self.eigenvalues_, self.eigenvectors_ = eigsh(matrix.astype(float), n_components, which=self.which,
+                                                      maxiter=self.n_iter, tol=self.tol)
+
+        return self

sknetwork/linalg/laplacian.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2022
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+
+import numpy as np
+from scipy import sparse
+
+
+def get_laplacian(adjacency: sparse.csr_matrix) -> sparse.csr_matrix:
+    """Return the Laplacian matrix of a graph."""
+    weights = adjacency.dot(np.ones(adjacency.shape[0]))
+    return sparse.diags(weights) - adjacency

sknetwork/linalg/normalizer.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+
+def diagonal_pseudo_inverse(weights: np.ndarray) -> sparse.csr_matrix:
+    """Compute :math:`\\text{diag}(w)^+`, the pseudo-inverse of the diagonal matrix
+    with diagonal elements given by the weights :math:`w`.
+
+    Parameters
+    ----------
+    weights:
+        The weights to invert.
+
+    Returns
+    -------
+    sparse.csr_matrix
+
+    """
+    diag: sparse.csr_matrix = sparse.diags(weights, format='csr')
+    diag.data = 1 / diag.data
+    return diag
+
+
+def get_norms(matrix: Union[sparse.csr_matrix, np.ndarray, LinearOperator], p=1):
+    """Get the norms of rows of a matrix.
+
+    Parameters
+    ----------
+    matrix : numpy array or sparse CSR matrix or LinearOperator, shape (n_rows, n_cols)
+        Input matrix.
+    p :
+        Order of the norm (1 or 2).
+    Returns
+    -------
+    norms : np.array, shape (n_rows,)
+        Vector norms
+    """
+    n_row, n_col = matrix.shape
+    if isinstance(matrix, np.ndarray):
+        input_matrix = sparse.csr_matrix(matrix)
+    elif isinstance(matrix, sparse.csr_matrix):
+        input_matrix = matrix.copy()
+    else:
+        input_matrix = matrix
+    if p == 1:
+        if not isinstance(matrix, LinearOperator):
+            input_matrix.data = np.abs(input_matrix.data)
+        return input_matrix.dot(np.ones(n_col))
+    elif p == 2:
+        if isinstance(matrix, LinearOperator):
+            raise ValueError('Only norm 1 is available for linear operators.')
+        input_matrix.data = input_matrix.data**2
+        return np.sqrt(input_matrix.dot(np.ones(n_col)))
+    else:
+        raise ValueError('Only norms 1 and 2 are available.')
+
+
+def normalize(matrix: Union[sparse.csr_matrix, np.ndarray, LinearOperator], p=1):
+    """Normalize the rows of a matrix so that all have norm 1 (or 0; null rows remain null).
+
+    Parameters
+    ----------
+    matrix :
+        Input matrix.
+    p :
+        Order of the norm.
+
+    Returns
+    -------
+    normalized matrix :
+        Normalized matrix (same format as input matrix).
+    """
+    norms = get_norms(matrix, p)
+    diag = diagonal_pseudo_inverse(norms)
+    if hasattr(matrix, 'left_sparse_dot') and callable(matrix.left_sparse_dot):
+        return matrix.left_sparse_dot(diag)
+    return diag.dot(matrix)

sknetwork/linalg/operators.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created in April 2020
+@author: Thomas Bonald <bonald@enst.fr>
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+from sknetwork.linalg import diagonal_pseudo_inverse
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.linalg.sparse_lowrank import SparseLR
+from sknetwork.utils.check import check_format
+
+
+class Regularizer(SparseLR):
+    """Regularized matrix as a Scipy LinearOperator.
+
+    Defined by :math:`A + \\alpha \\frac{11^T}n` where :math:`A` is the input matrix
+    and :math:`\\alpha` the regularization factor.
+
+    Parameters
+    ----------
+    input_matrix :
+        Input matrix.
+    regularization : float
+        Regularization factor.
+        Default value = 1.
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> regularizer = Regularizer(adjacency)
+    >>> regularizer.dot(np.ones(5))
+    array([3., 4., 3., 3., 4.])
+    """
+    def __init__(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], regularization: float = 1):
+        n_row, n_col = input_matrix.shape
+        u = regularization * np.ones(n_row)
+        v = np.ones(n_col) / n_col
+        super(Regularizer, self).__init__(input_matrix, (u, v))
+
+
+class Normalizer(LinearOperator):
+    """Normalized matrix as a Scipy LinearOperator.
+
+    Defined by :math:`D^{-1}A` where :math:`A` is the regularized adjacency matrix and :math:`D` the corresponding
+    diagonal matrix of degrees (sums over rows).
+
+    Parameters
+    ----------
+    adjacency :
+        :term:`Adjacency <adjacency>` matrix of the graph.
+    regularization : float
+        Regularization factor.
+        Default value = 0.
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> normalizer = Normalizer(adjacency)
+    >>> normalizer.dot(np.ones(5))
+    array([1., 1., 1., 1., 1.])
+    """
+    def __init__(self, adjacency: Union[sparse.csr_matrix, np.ndarray], regularization: float = 0):
+        if adjacency.ndim == 1:
+            adjacency = adjacency.reshape(1, -1)
+        super(Normalizer, self).__init__(dtype=float, shape=adjacency.shape)
+        n_col = adjacency.shape[1]
+        self.regularization = regularization
+        self.adjacency = adjacency
+        self.norm_diag = diagonal_pseudo_inverse(adjacency.dot(np.ones(n_col)) + regularization)
+
+    def _matvec(self, matrix: np.ndarray):
+        prod = self.adjacency.dot(matrix)
+        if self.regularization > 0:
+            n_row = self.shape[0]
+            if matrix.ndim == 2:
+                prod += self.regularization * np.outer(np.ones(n_row), matrix.mean(axis=0))
+            else:
+                prod += self.regularization * matrix.mean() * np.ones(n_row)
+        return self.norm_diag.dot(prod)
+
+    def _transpose(self):
+        return self
+
+
+class Laplacian(LinearOperator):
+    """Laplacian matrix as a Scipy LinearOperator.
+
+    Defined by :math:`L = D - A` where :math:`A` is the regularized adjacency matrix and :math:`D` the corresponding
+    diagonal matrix of degrees.
+
+    If normalized, defined by :math:`L = I - D^{-1/2}AD^{-1/2}`.
+
+    Parameters
+    ----------
+    adjacency :
+        :term:`Adjacency <adjacency>` matrix of the graph.
+    regularization : float
+        Regularization factor.
+        Default value = 0.
+    normalized_laplacian : bool
+        If ``True``, use normalized Laplacian.
+        Default value = ``False``.
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> laplacian = Laplacian(adjacency)
+    >>> laplacian.dot(np.ones(5))
+    array([0., 0., 0., 0., 0.])
+    """
+    def __init__(self, adjacency: Union[sparse.csr_matrix, np.ndarray], regularization: float = 0,
+                 normalized_laplacian: bool = False):
+        super(Laplacian, self).__init__(dtype=float, shape=adjacency.shape)
+        n = adjacency.shape[0]
+        self.regularization = regularization
+        self.normalized_laplacian = normalized_laplacian
+        self.weights = adjacency.dot(np.ones(n))
+        self.laplacian = sparse.diags(self.weights, format='csr') - adjacency
+        if self.normalized_laplacian:
+            self.norm_diag = diagonal_pseudo_inverse(np.sqrt(self.weights + regularization))
+
+    def _matvec(self, matrix: np.ndarray):
+        if self.normalized_laplacian:
+            matrix = self.norm_diag.dot(matrix)
+        prod = self.laplacian.dot(matrix)
+        if self.regularization > 0:
+            n = self.shape[0]
+            if matrix.ndim == 2:
+                prod += self.regularization * (matrix - np.outer(np.ones(n), matrix.mean(axis=0)))
+            else:
+                prod += self.regularization * (matrix - matrix.mean())
+        if self.normalized_laplacian:
+            prod = self.norm_diag.dot(prod)
+        return prod
+
+    def _transpose(self):
+        return self
+
+    def astype(self, dtype: Union[str, np.dtype]):
+        """Change dtype of the object."""
+        self.dtype = np.dtype(dtype)
+        self.laplacian = self.laplacian.astype(self.dtype)
+        return self
+
+
+class CoNeighbor(LinearOperator):
+    """Co-neighborhood adjacency as a LinearOperator.
+
+    :math:`\\tilde{A} = AF^{-1}A^T`, or :math:`\\tilde{B} = BF^{-1}B^T`.
+
+    where F is a weight matrix.
+
+    Parameters
+    ----------
+    adjacency:
+        Adjacency or biadjacency of the input graph.
+    normalized:
+        If ``True``, F is the diagonal in-degree matrix :math:`F = \\text{diag}(A^T1)`.
+        Otherwise, F is the identity matrix.
+
+    Examples
+    --------
+    >>> from sknetwork.data import star_wars
+    >>> biadjacency = star_wars(metadata=False)
+    >>> d_out = biadjacency.dot(np.ones(3))
+    >>> coneighbor = CoNeighbor(biadjacency)
+    >>> np.allclose(d_out, coneighbor.dot(np.ones(4)))
+    True
+    """
+    def __init__(self, adjacency: Union[sparse.csr_matrix, np.ndarray], normalized: bool = True):
+        adjacency = check_format(adjacency).astype(float)
+        n = adjacency.shape[0]
+        super(CoNeighbor, self).__init__(dtype=float, shape=(n, n))
+
+        if normalized:
+            self.forward = normalize(adjacency.T).tocsr()
+        else:
+            self.forward = adjacency.T
+
+        self.backward = adjacency
+
+    def __neg__(self):
+        self.backward *= -1
+        return self
+
+    def __mul__(self, other):
+        self.backward *= other
+        return self
+
+    def _matvec(self, matrix: np.ndarray):
+        return self.backward.dot(self.forward.dot(matrix))
+
+    def _transpose(self):
+        """Transposed operator"""
+        operator = CoNeighbor(self.backward)
+        operator.backward = self.forward.T.tocsr()
+        operator.forward = self.backward.T.tocsr()
+        return operator
+
+    def left_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Left dot product with a sparse matrix"""
+        self.backward = matrix.dot(self.backward)
+        return self
+
+    def right_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Right dot product with a sparse matrix"""
+        self.forward = self.forward.dot(matrix)
+        return self
+
+    def astype(self, dtype: Union[str, np.dtype]):
+        """Change dtype of the object."""
+        self.backward.astype(dtype)
+        self.forward.astype(dtype)
+        self.dtype = dtype
+        return self

sknetwork/linalg/polynome.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+from sknetwork.utils.check import check_format, check_square
+
+
+class Polynome(LinearOperator):
+    """Polynome of a matrix as a linear operator
+
+    :math:`P(A) = \\alpha_k A^k + ... + \\alpha_1 A + \\alpha_0`.
+
+    Parameters
+    ----------
+    matrix :
+        Square matrix
+    coeffs : np.ndarray
+        Coefficients of the polynome by increasing order of power.
+
+    Examples
+    --------
+    >>> from scipy import sparse
+    >>> from sknetwork.linalg import Polynome
+    >>> matrix = sparse.eye(2, format='csr')
+    >>> polynome = Polynome(matrix, np.arange(3))
+    >>> x = np.ones(2)
+    >>> polynome.dot(x)
+    array([3., 3.])
+    >>> polynome.T.dot(x)
+    array([3., 3.])
+
+    Notes
+    -----
+    The polynome is evaluated using the `Ruffini-Horner method
+    <https://en.wikipedia.org/wiki/Horner%27s_method>`_.
+    """
+
+    def __init__(self, matrix: Union[sparse.csr_matrix, np.ndarray], coeffs: np.ndarray):
+        if coeffs.shape[0] == 0:
+            raise ValueError('A polynome requires at least one coefficient.')
+        if not isinstance(matrix, LinearOperator):
+            matrix = check_format(matrix)
+        check_square(matrix)
+        shape = matrix.shape
+        dtype = matrix.dtype
+        super(Polynome, self).__init__(dtype=dtype, shape=shape)
+
+        self.matrix = matrix
+        self.coeffs = coeffs
+
+    def __neg__(self):
+        return Polynome(self.matrix, -self.coeffs)
+
+    def __mul__(self, other):
+        return Polynome(self.matrix, other * self.coeffs)
+
+    def _matvec(self, matrix: np.ndarray):
+        """Right dot product with a dense matrix.
+        """
+        y = self.coeffs[-1] * matrix
+        for a in self.coeffs[::-1][1:]:
+            y = self.matrix.dot(y) + a * matrix
+        return y
+
+    def _transpose(self):
+        """Transposed operator."""
+        return Polynome(self.matrix.T.tocsr(), self.coeffs)