scikit-network 0.33.0__cp312-cp312-macosx_11_0_arm64.whl

sknetwork/hierarchy/tests/test_algos.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2020
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.hierarchy import LouvainIteration, LouvainHierarchy, Paris
+
+
+class TestLouvainHierarchy(unittest.TestCase):
+
+    def test(self):
+        louvain_iteration = LouvainIteration()
+        louvain_iteration_ = LouvainIteration(resolution=2, depth=1)
+        louvain_hierarchy = LouvainHierarchy()
+        louvain_hierarchy_ = LouvainHierarchy(tol_aggregation=0.1)
+        paris = Paris()
+        paris_ = Paris(weights='uniform', reorder=False)
+        for algo in [louvain_iteration, louvain_iteration_, louvain_hierarchy, louvain_hierarchy_, paris, paris_]:
+            for input_matrix in [test_graph(), test_digraph(), test_bigraph()]:
+                dendrogram = algo.fit_predict(input_matrix)
+                self.assertEqual(dendrogram.shape, (input_matrix.shape[0] - 1, 4))
+                if algo.bipartite:
+                    self.assertEqual(algo.dendrogram_full_.shape, (sum(input_matrix.shape) - 1, 4))
+        adjacency = test_graph()
+        algo = Paris()
+        dendrogram = algo.fit_predict(adjacency)
+        dendrogram_ = algo.predict()
+        self.assertAlmostEqual(np.linalg.norm(dendrogram - dendrogram_), 0)

sknetwork/hierarchy/tests/test_metrics.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on March 2019
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.data import cyclic_graph
+from sknetwork.hierarchy import Paris, LouvainIteration, dasgupta_cost, dasgupta_score, tree_sampling_divergence
+
+
+# noinspection PyMissingOrEmptyDocstring
+class TestMetrics(unittest.TestCase):
+
+    def setUp(self):
+        self.paris = Paris()
+        self.louvain_iteration = LouvainIteration()
+
+    def test_undirected(self):
+        adjacency = cyclic_graph(3)
+        dendrogram = self.paris.fit_predict(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 2.666, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.111, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.0632, 3)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, normalized=False), 0.0256, 3)
+        adjacency = test_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 4.26, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.573, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.304, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 4.43, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.555, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.286, 2)
+
+    def test_directed(self):
+        adjacency = test_digraph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.566, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.318, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.55, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.313, 2)
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.682, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.464, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.670, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.594, 2)
+
+    def test_options(self):
+        adjacency = test_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram, weights='degree'), 0.573, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, weights='uniform'), 0.271, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, normalized=False), 0.367, 2)

sknetwork/hierarchy/tests/test_postprocess.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on March 2019
+@author: Thomas Bonald <bonald@enst.fr>
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data import karate_club
+from sknetwork.hierarchy import Paris, cut_straight, cut_balanced, aggregate_dendrogram
+
+
+# noinspection PyMissingOrEmptyDocstring
+class TestCuts(unittest.TestCase):
+
+    def setUp(self):
+        paris = Paris()
+        self.adjacency = karate_club()
+        self.dendrogram = paris.fit_transform(self.adjacency)
+
+    def test_cuts(self):
+        labels = cut_straight(self.dendrogram)
+        self.assertEqual(len(set(labels)), 2)
+        labels = cut_straight(self.dendrogram, n_clusters=5)
+        self.assertEqual(len(set(labels)), 5)
+        labels = cut_balanced(self.dendrogram, 2)
+        self.assertEqual(len(set(labels)), 21)
+        labels, new_dendrogram = cut_balanced(self.dendrogram, max_cluster_size=4, return_dendrogram=True)
+        self.assertEqual(len(set(labels)), 12)
+        self.assertTupleEqual(new_dendrogram.shape, (11, 4))
+        paris = Paris(reorder=False)
+        dendrogram = paris.fit_predict(self.adjacency)
+        labels = cut_balanced(dendrogram, 4)
+        self.assertEqual(len(set(labels)), 12)
+
+    def test_options(self):
+        labels = cut_straight(self.dendrogram, threshold=0.5)
+        self.assertEqual(len(set(labels)), 7)
+        labels = cut_straight(self.dendrogram, n_clusters=3, threshold=0.5)
+        self.assertEqual(len(set(labels)), 3)
+        labels = cut_straight(self.dendrogram, sort_clusters=False)
+        self.assertEqual(len(set(labels)), 2)
+        labels = cut_balanced(self.dendrogram, max_cluster_size=2, sort_clusters=False)
+        self.assertEqual(len(set(labels)), 21)
+        labels = cut_balanced(self.dendrogram, max_cluster_size=10)
+        self.assertEqual(len(set(labels)), 5)
+
+    def test_aggregation(self):
+        aggregated = aggregate_dendrogram(self.dendrogram, n_clusters=3)
+        self.assertEqual(len(aggregated), 2)
+
+        aggregated, counts = aggregate_dendrogram(self.dendrogram, n_clusters=3, return_counts=True)
+        self.assertEqual(len(aggregated), 2)
+        self.assertEqual(len(counts), 3)
+

sknetwork/linalg/__init__.py

@@ -0,0 +1,9 @@
+"""Module of linear algebra."""
+from sknetwork.linalg.basics import safe_sparse_dot
+from sknetwork.linalg.eig_solver import EigSolver, LanczosEig
+from sknetwork.linalg.laplacian import get_laplacian
+from sknetwork.linalg.normalizer import diagonal_pseudo_inverse, get_norms, normalize
+from sknetwork.linalg.operators import Regularizer, Laplacian, Normalizer, CoNeighbor
+from sknetwork.linalg.polynome import Polynome
+from sknetwork.linalg.sparse_lowrank import SparseLR
+from sknetwork.linalg.svd_solver import SVDSolver, LanczosSVD

sknetwork/linalg/basics.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+
+def safe_sparse_dot(a, b):
+    """Dot product with proper use of the sparse matrix format.
+    Use BLAS instead of numpy.dot when possible to avoid unnecessary copies.
+
+    Parameters
+    ----------
+    a : array, sparse matrix or LinearOperator
+    b : array, sparse matrix or LinearOperator
+    Returns
+    -------
+    dot_product : array or sparse matrix
+        sparse if ``a`` or ``b`` is sparse.
+    """
+    if type(a) == np.ndarray:
+        return b.T.dot(a.T).T
+    if isinstance(a, LinearOperator) and isinstance(b, LinearOperator):
+        raise NotImplementedError
+    if hasattr(a, 'right_sparse_dot') and type(b) == sparse.csr_matrix:
+        if callable(a.right_sparse_dot):
+            return a.right_sparse_dot(b)
+    if hasattr(b, 'left_sparse_dot') and type(a) == sparse.csr_matrix:
+        if callable(b.left_sparse_dot):
+            return b.left_sparse_dot(a)
+    else:
+        return a.dot(b)

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