scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/linkpred/first_order_core.pyx

@@ -0,0 +1,315 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on July, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from libc.math cimport log, sqrt
+from libcpp.vector cimport vector
+
+ctypedef float (*int2float)(int)
+ctypedef float (*vectors2float)(vector[int], vector[int])
+
+
+cdef float inv(int a):
+    """Inverse function"""
+    return 1 / a
+
+
+cdef float inv_log(int a):
+    """Inverse of log function"""
+    return 1 / log(a)
+
+
+cdef vector[int] vector_intersection(vector[int] a, vector[int] b):
+    """Common elements in two sorted vectors. Each element is assumed unique in each vector."""
+    cdef vector[int] intersection
+    cdef int e_a, e_b
+    cdef int ix_a = 0
+    cdef int ix_b = 0
+    cdef int size_a = a.size()
+    cdef int size_b = b.size()
+
+    while ix_a < size_a and ix_b < size_b:
+        e_a = a[ix_a]
+        e_b = b[ix_b]
+
+        if e_a < e_b:
+            ix_a += 1
+        elif e_b < e_a:
+            ix_b += 1
+        else:
+            intersection.push_back(e_a)
+            ix_a += 1
+            ix_b += 1
+
+    return intersection
+
+
+cdef float size_intersection(vector[int] a, vector[int] b):
+    """Size of the intersection of two vectors"""
+    return vector_intersection(a, b).size()
+
+
+cdef float jaccard(vector[int] a, vector[int] b):
+    """Jaccard coefficient"""
+    cdef float size_inter = size_intersection(a, b)
+    cdef float size_union = a.size() + b.size() - size_inter
+    return size_inter / size_union
+
+
+cdef float salton(vector[int] a, vector[int] b):
+    """Salton coefficient"""
+    cdef float size_inter = size_intersection(a, b)
+    return size_inter / sqrt(a.size() * b.size())
+
+
+cdef float sorensen(vector[int] a, vector[int] b):
+    """Sorensen coefficient"""
+    cdef float size_inter = size_intersection(a, b)
+    return 2 * size_inter / (a.size() + b.size())
+
+
+cdef float hub_promoted(vector[int] a, vector[int] b):
+    """Hub promoted coefficient"""
+    cdef float size_inter = size_intersection(a, b)
+    return size_inter / min(a.size(), b.size())
+
+
+cdef float hub_depressed(vector[int] a, vector[int] b):
+    """Hub promoted coefficient"""
+    cdef float size_inter = size_intersection(a, b)
+    return size_inter / max(a.size(), b.size())
+
+
+cdef vector[int] neighbors(int[:] indptr, int[:] indices, int node):
+    """Neighbors of a given node"""
+    cdef int j1 = indptr[node]
+    cdef int j2 = indptr[node + 1]
+    cdef int j
+    cdef vector[int] neigh = ()
+
+    for j in range(j1, j2):
+        neigh.push_back(indices[j])
+
+    return neigh
+
+
+cdef vector[float] predict_node_core(int[:] indptr, int[:] indices, int source, int[:] targets,
+                                       vectors2float weight_func):
+    """Scores based on global information about common neighbors for a single source.
+
+    Parameters
+    ----------
+    indptr :
+        indptr array of the adjacency matrix
+    indices :
+        indices array of the adjacency matrix
+    source :
+        source index
+    targets :
+        array of target indices
+    weight_func :
+        scoring function to be used
+
+    Returns
+    -------
+    scores :
+        vector of node pair scores
+    """
+    cdef int target, i
+    cdef int n_targets = targets.shape[0]
+    cdef vector[float] preds
+
+    cdef vector[int] neigh_s = neighbors(indptr, indices, source)
+    cdef vector[int] neigh_t
+    for i in range(n_targets):
+        target = targets[i]
+        neigh_t = neighbors(indptr, indices, target)
+        preds.push_back(weight_func(neigh_s, neigh_t))
+
+    return preds
+
+
+cdef vector[float] predict_edges_core(int[:] indptr, int[:] indices, int[:, :] edges,
+                                       vectors2float weight_func):
+    """Scores based on global information about common neighbors for a list of edges.
+
+    Parameters
+    ----------
+    indptr :
+        indptr array of the adjacency matrix
+    indices :
+        indices array of the adjacency matrix
+    edges:
+        array of node pairs to be scored
+    weight_func :
+        scoring function to be used
+
+    Returns
+    -------
+    scores :
+        vector of node pair scores
+    """
+
+    cdef vector[float] preds
+    cdef int source, target, i
+
+    cdef int n_edges = edges.shape[0]
+    for i in range(n_edges):
+        source, target = edges[i, 0], edges[i, 1]
+        neigh_s = neighbors(indptr, indices, source)
+        neigh_t = neighbors(indptr, indices, target)
+        preds.push_back(weight_func(neigh_s, neigh_t))
+
+    return preds
+
+def common_neighbors_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Number of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, size_intersection)
+
+def common_neighbors_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Number of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, size_intersection)
+
+def jaccard_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Jaccard coefficient of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, jaccard)
+
+def jaccard_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Number of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, jaccard)
+
+def salton_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Salton coefficient of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, salton)
+
+def salton_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Salton coefficient of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, salton)
+
+def sorensen_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Sorensen coefficient of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, sorensen)
+
+def sorensen_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Sorensen coefficient of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, sorensen)
+
+def hub_promoted_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Hub promoted coefficient of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, hub_promoted)
+
+def hub_promoted_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Hub promoted coefficient of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, hub_promoted)
+
+def hub_depressed_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Hub depressed coefficient of common neighbors"""
+    return predict_node_core(indptr, indices, source, targets, hub_depressed)
+
+def hub_depressed_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Hub depressed coefficient of common neighbors"""
+    return predict_edges_core(indptr, indices, edges, hub_depressed)
+
+cdef vector[float] predict_node_weighted_core(int[:] indptr, int[:] indices, int source, int[:] targets,
+                                              int2float weight_func):
+    """Scores based on the degrees of common neighbors for a single source.
+
+    Parameters
+    ----------
+    indptr :
+        indptr array of the adjacency matrix
+    indices :
+        indices array of the adjacency matrix
+    source :
+        source index
+    targets :
+        array of target indices
+    weight_func :
+        scoring function to be used
+
+    Returns
+    -------
+    scores :
+        vector of node pair scores
+    """
+    cdef int target, i, j
+    cdef int n_targets = targets.shape[0]
+    cdef float weight
+    cdef vector[int] intersection
+    cdef vector[float] preds
+
+    cdef vector[int] neigh_s = neighbors(indptr, indices, source)
+    cdef vector[int] neigh_t
+    for i in range(n_targets):
+        target = targets[i]
+        neigh_t = neighbors(indptr, indices, target)
+        intersection = vector_intersection(neigh_s, neigh_t)
+
+        weight = 0
+        for j in intersection:
+            weight += weight_func(indptr[j+1] - indptr[j])
+        preds.push_back(weight)
+
+    return preds
+
+
+cdef vector[float] predict_edges_weighted_core(int[:] indptr, int[:] indices, int[:, :] edges,
+                                               int2float weight_func):
+    """Scores based on the degrees of common neighbors for a list of edges.
+
+    Parameters
+    ----------
+    indptr :
+        indptr array of the adjacency matrix
+    indices :
+        indices array of the adjacency matrix
+    edges:
+        array of node pairs to be scored
+    weight_func :
+        scoring function to be used
+
+    Returns
+    -------
+    scores :
+        vector of node pair scores
+    """
+    cdef vector[float] preds
+    cdef int source, target, i
+    cdef float weight
+    cdef vector[int] intersection
+
+    cdef int n_edges = edges.shape[0]
+    for i in range(n_edges):
+        source, target = edges[i][0], edges[i][1]
+        neigh_s = neighbors(indptr, indices, source)
+        neigh_t = neighbors(indptr, indices, target)
+
+        intersection = vector_intersection(neigh_s, neigh_t)
+
+        weight = 0
+        for j in intersection:
+            weight += weight_func(indptr[j+1] - indptr[j])
+        preds.push_back(weight)
+
+    return preds
+
+
+def adamic_adar_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Adamic Adar index"""
+    return predict_node_weighted_core(indptr, indices, source, targets, inv_log)
+
+def adamic_adar_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Adamic Adar index"""
+    return predict_edges_weighted_core(indptr, indices, edges, inv_log)
+
+def resource_allocation_node_core(int[:] indptr, int[:] indices, int source, int[:] targets):
+    """Resource Allocation index"""
+    return predict_node_weighted_core(indptr, indices, source, targets, inv)
+
+def resource_allocation_edges_core(int[:] indptr, int[:] indices, int[:, :] edges):
+    """Resource Allocation index"""
+    return predict_edges_weighted_core(indptr, indices, edges, inv)

sknetwork/linkpred/postprocessing.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union, Iterable, Tuple
+
+import numpy as np
+from scipy import sparse
+
+
+def is_edge(adjacency: sparse.csr_matrix, query: Union[int, Iterable, Tuple]) -> Union[bool, np.ndarray]:
+    """Given a query, return whether each edge is actually in the adjacency.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    query : int, Iterable or Tuple
+            * If int i, queries (i, j) for all j.
+            * If Iterable of integers, return queries (i, j) for i in query, for all j.
+            * If tuple (i, j), queries (i, j).
+            * If list of tuples or array of shape (n_queries, 2), queries (i, j) in for each line in query.
+
+    Returns
+    -------
+    labels_true : Union[bool, np.ndarray]
+        For each element in the query, returns ``True`` if the edge exists in the adjacency and ``False`` otherwise.
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> is_edge(adjacency, 0)
+    array([False,  True, False, False,  True])
+    >>> is_edge(adjacency, [0, 1])
+    array([[False,  True, False, False,  True],
+           [ True, False,  True, False,  True]])
+    >>> is_edge(adjacency, (0, 1))
+    True
+    >>> is_edge(adjacency, [(0, 1), (0, 2)])
+    array([ True, False])
+    """
+    if np.issubdtype(type(query), np.integer):
+        return adjacency[query].toarray().astype(bool).ravel()
+    if isinstance(query, Tuple):
+        source, target = query
+        neighbors = adjacency.indices[adjacency.indptr[source]:adjacency.indptr[source + 1]]
+        return bool(np.isin(target, neighbors, assume_unique=True))
+    if isinstance(query, list):
+        query = np.array(query)
+    if isinstance(query, np.ndarray):
+        if query.ndim == 1:
+            return adjacency[query].toarray().astype(bool)
+        elif query.ndim == 2 and query.shape[1] == 2:
+            y_true = []
+            for edge in query:
+                y_true.append(is_edge(adjacency, (edge[0], edge[1])))
+            return np.array(y_true)
+        else:
+            raise ValueError("Query not understood.")
+    else:
+        raise ValueError("Query not understood.")
+
+
+def whitened_sigmoid(scores: np.ndarray):
+    """Map the entries of a score array to probabilities through
+
+    :math:`\\dfrac{1}{1 + \\exp(-(x - \\mu)/\\sigma)}`,
+
+    where :math:`\\mu` and :math:`\\sigma` are respectively the mean and standard deviation of x.
+
+    Parameters
+    ----------
+    scores : np.ndarray
+        The input array
+
+    Returns
+    -------
+    probas : np.ndarray
+        Array with entries between 0 and 1.
+
+    Examples
+    --------
+    >>> probas = whitened_sigmoid(np.array([1, 5, 0.25]))
+    >>> probas.round(2)
+    array([0.37, 0.8 , 0.29])
+    >>> probas = whitened_sigmoid(np.array([2, 2, 2]))
+    >>> probas
+    array([1, 1, 1])
+    """
+    mu = scores.mean()
+    sigma = scores.std()
+    if sigma > 0:
+        return 1 / (1 + np.exp(-(scores - mu) / sigma))
+    else:
+        return np.ones_like(scores)

sknetwork/linkpred/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for link prediction"""

sknetwork/linkpred/tests/test_API.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for link prediction API"""
+import unittest
+from abc import ABC
+from typing import Iterable
+
+import numpy as np
+
+from sknetwork.data import house
+from sknetwork.linkpred.base import BaseLinkPred
+
+
+class Dummy(BaseLinkPred, ABC):
+    """Dummy algorithm for testing purposes"""
+    def __init__(self):
+        super(Dummy, self).__init__()
+
+    def fit(self, *args, **kwargs):
+        """Dummy fit method"""
+        return self
+
+    def _predict_base(self, source: int, targets: Iterable):
+        return np.array([1 for _ in targets])
+
+
+class TestLinkPred(unittest.TestCase):
+
+    def test_base(self):
+        algo = BaseLinkPred()
+        query = 0
+        with self.assertRaises(NotImplementedError):
+            algo.predict(query)
+        query = (0, 1)
+        with self.assertRaises(NotImplementedError):
+            algo.predict(query)
+
+    def test_query(self):
+        adjacency = house()
+        algo = Dummy().fit(adjacency)
+        query = 'toto'
+        with self.assertRaises(ValueError):
+            algo.predict(query)
+        query = np.ones((2, 3))
+        with self.assertRaises(ValueError):
+            algo.predict(query)
+        query = [(0, 1), (2, 3)]
+        pred = algo.predict(query)
+        self.assertEqual(pred.shape, (len(query),))

sknetwork/linkpred/tests/test_postprocessing.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for link prediction postprocessing"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house
+from sknetwork.linkpred import is_edge
+
+
+class TestLinkPredPostProcessing(unittest.TestCase):
+
+    def test_signature(self):
+        adjacency = house()
+
+        with self.assertRaises(ValueError):
+            is_edge(adjacency, 'toto')
+
+        with self.assertRaises(ValueError):
+            is_edge(adjacency, np.ones(8).reshape((2, 2, 2)))

sknetwork/path/__init__.py

@@ -0,0 +1,4 @@
+"""Path module"""
+from sknetwork.path.metrics import get_diameter, get_eccentricity, get_radius
+from sknetwork.path.search import breadth_first_search, depth_first_search
+from sknetwork.path.shortest_path import get_distances, get_shortest_path

sknetwork/path/metrics.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on May, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union, Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.path.shortest_path import get_distances
+
+
+def get_diameter(adjacency: Union[sparse.csr_matrix, np.ndarray],
+                 n_sources: Optional[Union[int, float]] = None,
+                 unweighted: bool = False, n_jobs: Optional[int] = None) -> int:
+    """Lower bound on the diameter of a graph which is the length of the longest
+    shortest path between two nodes.
+
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    n_sources :
+        Number of node sources to use for approximation.
+
+        * If None, compute exact diameter.
+        * If int, sample n_sample source nodes at random.
+        * If float, sample (n_samples * n) source nodes at random.
+    unweighted:
+        Whether or not the graph is unweighted.
+    n_jobs :
+        If an integer value is given, denotes the number of workers to use (-1
+        means the maximum number will be used).
+        If ``None``, no parallel computations are made.
+
+    Returns
+    -------
+    diameter : int
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> d_exact = get_diameter(adjacency)
+    >>> d_exact
+    2
+    >>> d_approx = get_diameter(adjacency, 2)
+    >>> d_approx <= d_exact
+    True
+    >>> d_approx = get_diameter(adjacency, 0.5)
+    >>> d_approx <= d_exact
+    True
+
+    Notes
+    -----
+    This is a basic implementation that computes distances between nodes and
+    returns the maximum.
+    """
+    n = adjacency.shape[0]
+    if n_sources is None or n_sources == n:
+        sources = np.arange(n)
+    else:
+        if np.issubdtype(type(n_sources), np.floating) and n_sources < 1.:
+            n_sources = int(n_sources * n)
+        if np.issubdtype(type(n_sources), np.integer) and n_sources <= n:
+            sources = np.random.choice(n, n_sources, replace=False)
+        else:
+            raise ValueError("n_sources must be either None, an integer smaller"
+                             "than the number of nodes or a float"
+                             "smaller than 1.")
+    dists = get_distances(adjacency, sources, method='D', return_predecessors=False,
+                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
+    return dists.max()
+
+
+def get_radius(adjacency: Union[sparse.csr_matrix, np.ndarray],
+               n_sources: Optional[Union[int, float]] = None,
+               unweighted: bool = False, n_jobs: Optional[int] = None) -> int:
+    """Computes the radius of the graph which. The radius of the graph is the
+    minimum eccentricity of the graph.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    n_sources :
+        Number of node sources to use for approximation.
+
+        * If None, compute exact diameter.
+        * If int, sample n_sample source nodes at random.
+        * If float, sample (n_samples * n) source nodes at random.
+    unweighted:
+        Whether the graph is unweighted.
+    n_jobs :
+        If an integer value is given, denotes the number of workers to use (-1
+        means the maximum number will be used).
+        If ``None``, no parallel computations are made.
+
+    Returns
+    -------
+    radius : int
+
+    Notes
+    -----
+    This is a basic implementation that computes distances between nodes and
+    returns the maximum.
+    """
+
+    # Get the nodes.
+    dists = get_distances(adjacency, sources=n_sources, method='D',
+                          return_predecessors=False,
+                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
+    # Get the eccentricities of each node.
+    eccentricities = dists.max(axis=1)
+
+    return eccentricities.min()
+
+
+def get_eccentricity(adjacency: Union[sparse.csr_matrix, np.ndarray], node: int,
+                     unweighted: bool = False,
+                     n_jobs: Optional[int] = None) -> int:
+    """Computes the eccentricity of a node. The eccentricity of a node, u, is the
+    maximum length of the shortest paths from u to the other nodes in the graph.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    node:
+        The node to compute the eccentricity for.
+    unweighted:
+        Whether or not the graph is unweighted.
+    n_jobs :
+        If an integer value is given, denotes the number of workers to use (-1
+        means the maximum number will be used).
+        If ``None``, no parallel computations are made.
+
+    Returns
+    -------
+    eccentricity : int
+    """
+
+    dists = get_distances(adjacency, node, method='D', return_predecessors=False,
+                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
+    return dists.max()