scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/embedding/base.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Nov, 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 sknetwork.topology.structure import is_connected
+from sknetwork.utils.base import Algorithm
+
+
+class BaseEmbedding(Algorithm, ABC):
+    """Base class for embedding algorithms.
+
+    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.
+    """
+
+    def __init__(self):
+        self._init_vars()
+
+    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, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
+        """Predict the embedding of new nodes.
+
+        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.
+        """
+        raise NotImplementedError
+
+    def _check_fitted(self):
+        if self.embedding_ is None:
+            raise ValueError("This embedding instance is not fitted yet."
+                             " Call 'fit' with appropriate arguments before using this method.")
+        else:
+            return self
+
+    @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 _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,197 @@
+#!/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
+        Layout in given dimension.
+
+    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
+
+    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)
+
+                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 and we break.
+
+        self.embedding_ = position
+        return self

sknetwork/embedding/louvain_embedding.py

@@ -0,0 +1,174 @@
+#!/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.normalization 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_ : 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.
+    labels_row_ : np.ndarray
+        Labels of the rows (used to build the embedding of the columns).
+    labels_col_ : np.ndarray
+        Labels of the columns (used to build the embedding of the rows).
+
+    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_membership=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
+
+    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 row vectors.
+            Array of shape (n_col,) (single vector) or (n_vectors, n_col)
+
+        Returns
+        -------
+        embedding_vectors : np.ndarray
+            Embedding of the nodes.
+        """
+        self._check_fitted()
+        if self.embedding_col_ is not None:
+            n = len(self.embedding_col_)
+        else:
+            n = len(self.embedding_)
+
+        adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
+        check_nonnegative(adjacency_vectors)
+        membership = get_membership(self.labels_)
+
+        return normalize(adjacency_vectors).dot(membership)

sknetwork/embedding/louvain_hierarchy.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on Dec 2020
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import check_format, check_random_state
+from sknetwork.utils.format import get_adjacency
+from sknetwork.clustering.louvain import Louvain
+from sknetwork.embedding.base import BaseEmbedding
+
+
+class LouvainNE(BaseEmbedding):
+    """Embedding of graphs based on the hierarchical Louvain algorithm with random scattering per level.
+
+    Parameters
+    ----------
+    n_components : int
+        Dimension of the embedding.
+    scale : float
+        Dilution factor to be applied on the random vector to be added at each iteration of the clustering method.
+    resolution :
+        Resolution parameter.
+    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.
+
+    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 LouvainNE
+    >>> from sknetwork.data import karate_club
+    >>> louvain = LouvainNE(n_components=3)
+    >>> adjacency = karate_club()
+    >>> embedding = louvain.fit_transform(adjacency)
+    >>> embedding.shape
+    (34, 3)
+
+    References
+    ----------
+    Bhowmick, A. K., Meneni, K., Danisch, M., Guillaume, J. L., & Mitra, B. (2020, January).
+    `LouvainNE: Hierarchical Louvain Method for High Quality and Scalable Network Embedding.
+    <https://hal.archives-ouvertes.fr/hal-02999888/document>`_
+    In Proceedings of the 13th International Conference on Web Search and Data Mining (pp. 43-51).
+    """
+    def __init__(self, n_components: int = 2, scale: float = .1, resolution: float = 1, 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, verbose: bool = False):
+        super(LouvainNE, self).__init__()
+
+        self.n_components = n_components
+        self.scale = scale
+        self._clustering_method = Louvain(resolution=resolution, tol_optimization=tol_optimization,
+                                          tol_aggregation=tol_aggregation, n_aggregations=n_aggregations,
+                                          shuffle_nodes=shuffle_nodes, random_state=random_state, verbose=verbose)
+        self.random_state = check_random_state(random_state)
+        self.bipartite = None
+
+    def _recursive_louvain(self, adjacency: Union[sparse.csr_matrix, np.ndarray], depth: int,
+                           nodes: Optional[np.ndarray] = None):
+        """Recursive function for fit, modifies the embedding in place.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph.
+        depth :
+            Depth of the recursion.
+        nodes :
+            The indices of the current nodes in the original graph.
+        """
+        n = adjacency.shape[0]
+        if nodes is None:
+            nodes = np.arange(n)
+
+        if adjacency.nnz:
+            labels = self._clustering_method.fit_transform(adjacency)
+        else:
+            labels = np.zeros(n)
+
+        clusters = np.unique(labels)
+
+        if len(clusters) != 1:
+            random_vectors = (self.scale ** depth) * self.random_state.rand(self.n_components, len(clusters))
+            for index, cluster in enumerate(clusters):
+                mask = (labels == cluster)
+                nodes_cluster = nodes[mask]
+                self.embedding_[nodes_cluster, :] += random_vectors[:, index]
+                n_row = len(mask)
+                indptr = np.zeros(n_row + 1, dtype=int)
+                indptr[1:] = np.cumsum(mask)
+                n_col = indptr[-1]
+                combiner = sparse.csr_matrix((np.ones(n_col), np.arange(n_col, dtype=int), indptr),
+                                             shape=(n_row, n_col))
+                adjacency_cluster = adjacency[mask, :].dot(combiner)
+                self._recursive_louvain(adjacency_cluster, depth + 1, nodes_cluster)
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False):
+        """Embedding of graphs from a clustering obtained with Louvain.
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite :
+            If ``True``, force the input matrix to be considered as a biadjacency matrix even if square.
+        Returns
+        -------
+        self: :class:`LouvainNE`
+        """
+        # input
+        input_matrix = check_format(input_matrix)
+        adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+        n = adjacency.shape[0]
+
+        # embedding
+        self.embedding_ = np.zeros((n, self.n_components))
+        self._recursive_louvain(adjacency, 0)
+
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+        return self

sknetwork/embedding/metrics.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in November 2018
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+@author: Nathan De Lara <nathan.delara@polytechnique.org>
+"""
+import numpy as np
+
+from sknetwork.linalg import normalize
+from sknetwork.utils.check import check_format, check_square
+
+
+def get_cosine_similarity(input_matrix, embedding: np.ndarray, embedding_col=None):
+    """Average cosine similarity of an embedding :math:`x` defined by:
+
+    :math:`Q = \\sum_{ij}\\dfrac{A_{ij}}{w}\\cos(x_i, x_j)}`
+
+    where :math:`w = 1^TA1` is the total weight of the graph.
+
+    For bipartite graphs with column embedding :math:`y`, the metric is
+
+    :math:`Q = \\sum_{ij} \\dfrac{B_{ij}}{w} \\cos(x_i, y_j)`
+
+    where :math:`w = 1^TB1` is the total weight of the graph.
+
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    embedding :
+        Embedding of the nodes.
+    embedding_col :
+        Embedding of the columns (for bipartite graphs).
+
+    Returns
+    -------
+    cosine_similarity : float
+
+    Example
+    -------
+    >>> from sknetwork.embedding import get_cosine_similarity
+    >>> from sknetwork.data import karate_club
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> embedding = graph.position
+    >>> np.round(get_cosine_similarity(adjacency, embedding), 2)
+    0.7
+    """
+    input_matrix = check_format(input_matrix)
+    total_weight = input_matrix.data.sum()
+
+    if embedding_col is None:
+        check_square(input_matrix)
+        embedding_col = embedding.copy()
+
+    embedding_row_norm = normalize(embedding, p=2)
+    embedding_col_norm = normalize(embedding_col, p=2)
+
+    input_matrix_coo = input_matrix.tocoo()
+    row = input_matrix_coo.row
+    col = input_matrix_coo.col
+
+    cosine_similarity = np.multiply(embedding_row_norm[row], embedding_col_norm[col]).sum() / total_weight
+
+    return cosine_similarity