scikit-network 0.30.0__cp38-cp38-win_amd64.whl → 0.32.1__cp38-cp38-win_amd64.whl

sknetwork/topology/triangles.pyx

@@ -1,54 +1,53 @@
-# distutils: language = c++
+# distutils: language=c++
 # cython: language_level=3
-# cython: linetrace=True
-# distutils: define_macros=CYTHON_TRACE_NOGIL=1
 """
-Created on Jun 3, 2020
+Created in June 2020
 @author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
 @author: Yohann Robert <yohann.robert@etu.upmc.fr>
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
 """
 from libcpp.vector cimport vector
 from scipy import sparse
-from scipy.special import comb
 from cython.parallel import prange
 
-from sknetwork.topology.dag import DAG
-from sknetwork.utils.base import Algorithm
+from sknetwork.path.dag import get_dag
+from sknetwork.utils.check import check_square
+from sknetwork.utils.format import directed2undirected
+from sknetwork.utils.neighbors import get_degrees
 
 cimport cython
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef long count_local_triangles(int source, vector[int] indptr, vector[int] indices) nogil:
-    """Counts the number of nodes in the intersection of a node and its neighbors in a DAG.
+cdef long count_local_triangles_from_dag(int node, vector[int] indptr, vector[int] indices) nogil:
+    """Count the number of triangles from a given node in a directed acyclic graph.
 
     Parameters
     ----------
-    source :
-        Index of the node to study.
+    node :
+        Node.
     indptr :
-        CSR format index pointer array of the normalized adjacency matrix of a DAG.
+        CSR format index pointer array of the adjacency matrix of the graph.
     indices :
-        CSR format index array of the normalized adjacency matrix of a DAG.
+        CSR format index array of the adjacency matrix of the graph.
 
     Returns
     -------
     n_triangles :
-        Number of nodes in the intersection
+        Number of triangles.
     """
     cdef int i, j, k
-    cdef int v
-    cdef long n_triangles = 0		# number of nodes in the intersection
+    cdef int neighbor
+    cdef long n_triangles = 0
 
-    for k in range(indptr[source], indptr[source+1]):
-        v = indices[k]
-        i = indptr[source]
-        j = indptr[v]
+    for k in range(indptr[node], indptr[node + 1]):
+        neighbor = indices[k]
+        i = indptr[node]
+        j = indptr[neighbor]
 
-        # calculates the intersection of the neighbors of u and v
-        while (i < indptr[source+1]) and (j < indptr[v+1]):
+        while (i < indptr[node + 1]) and (j < indptr[neighbor + 1]):
             if indices[i] == indices[j]:
                 i += 1
                 j += 1
@@ -61,18 +60,17 @@ cdef long count_local_triangles(int source, vector[int] indptr, vector[int] indi
 
     return n_triangles
 
-
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef long fit_core(vector[int] indptr, vector[int] indices, bint parallelize):
-    """Counts the number of triangles directly without exporting the graph.
+cdef long count_triangles_from_dag(vector[int] indptr, vector[int] indices, bint parallelize):
+    """Count the number of triangles in a directed acyclic graph.
 
     Parameters
     ----------
     indptr :
-        CSR format index pointer array of the normalized adjacency matrix of a DAG.
+        CSR format index pointer array of the adjacency matrix of the graph.
     indices :
-        CSR format index array of the normalized adjacency matrix of a DAG.
+        CSR format index array of the adjacency matrix of the graph.
     parallelize :
         If ``True``, use a parallel range to count triangles.
 
@@ -81,86 +79,73 @@ cdef long fit_core(vector[int] indptr, vector[int] indices, bint parallelize):
     n_triangles :
         Number of triangles in the graph
     """
-    cdef int n = indptr.size() - 1
-    cdef int u
+    cdef int n_nodes = indptr.size() - 1
+    cdef int node
     cdef long n_triangles = 0
 
     if parallelize:
-        for u in prange(n, nogil=True):
-            n_triangles += count_local_triangles(u, indptr, indices)
+        for node in prange(n_nodes, nogil=True):
+            n_triangles += count_local_triangles_from_dag(node, indptr, indices)
     else:
-        for u in range(n):
-            n_triangles += count_local_triangles(u, indptr, indices)
+        for node in range(n_nodes):
+            n_triangles += count_local_triangles_from_dag(node, indptr, indices)
 
     return n_triangles
 
-
-class Triangles(Algorithm):
-    """Count the number of triangles in a graph, and evaluate the clustering coefficient.
-
-    * Graphs
+def count_triangles(adjacency: sparse.csr_matrix, parallelize: bool = False) -> int:
+    """Count the number of triangles in a graph. The graph is considered undirected.
 
     Parameters
     ----------
+    adjacency :
+        Adjacency matrix of the graph.
     parallelize :
         If ``True``, use a parallel range while listing the triangles.
 
-    Attributes
-    ----------
-    n_triangles_ : int
+    Returns
+    -------
+    n_triangles : int
         Number of triangles.
-    clustering_coef_ : float
-        Global clustering coefficient of the graph.
 
     Example
     -------
     >>> from sknetwork.data import karate_club
-    >>> triangles = Triangles()
     >>> adjacency = karate_club()
-    >>> triangles.fit_transform(adjacency)
+    >>> count_triangles(adjacency)
     45
     """
-    def __init__(self, parallelize : bool = False):
-        super(Triangles, self).__init__()
-        self.parallelize = parallelize
-        self.n_triangles_ = None
-        self.clustering_coef_ = None
-
-    def fit(self, adjacency: sparse.csr_matrix) -> 'Triangles':
-        """Count triangles.
-
-        Parameters
-        ----------
-        adjacency :
-            Adjacency matrix of the graph.
-
-        Returns
-        -------
-         self: :class:`Triangles`
-        """
-        degrees = adjacency.indptr[1:] - adjacency.indptr[:-1]
-        edge_pairs = comb(degrees, 2).sum()
-
-        dag = DAG(ordering='degree')
-        dag.fit(adjacency)
-        indptr = dag.indptr_
-        indices = dag.indices_
-
-        self.n_triangles_ = fit_core(indptr, indices, self.parallelize)
-        if edge_pairs > 0:
-            self.clustering_coef_ = 3 * self.n_triangles_ / edge_pairs
-        else:
-            self.clustering_coef_ = 0.
-
-        return self
-
-    def fit_transform(self, adjacency: sparse.csr_matrix) -> int:
-        """ Fit algorithm to the data and return the number of triangles. Same parameters as the ``fit`` method.
-
-        Returns
-        -------
-        n_triangles_ : int
-            Number of triangles.
-        """
-        self.fit(adjacency)
-        return self.n_triangles_
+    check_square(adjacency)
+    dag = get_dag(directed2undirected(adjacency))
+    indptr = dag.indptr
+    indices = dag.indices
+    n_triangles = count_triangles_from_dag(indptr, indices, parallelize)
+    return n_triangles
+
+def get_clustering_coefficient(adjacency: sparse.csr_matrix, parallelize: bool = False) -> float:
+    """Get the clustering coefficient of a graph.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    parallelize :
+        If ``True``, use a parallel range while listing the triangles.
+
+    Returns
+    -------
+    coefficient : float
+        Clustering coefficient.
+
+    Example
+    -------
+    >>> from sknetwork.data import karate_club
+    >>> adjacency = karate_club()
+    >>> np.round(get_clustering_coefficient(adjacency), 2)
+    0.26
+    """
+    n_triangles = count_triangles(adjacency, parallelize)
+    degrees = get_degrees(directed2undirected(adjacency))
+    degrees = degrees[degrees > 1]
+    n_edge_pairs = (degrees * (degrees - 1)).sum() / 2
+    coefficient = 3  * n_triangles / n_edge_pairs
+    return coefficient

sknetwork/topology/weisfeiler_lehman.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on July 2, 2020
+Created in July 2020
 @author: Pierre Pebereau <pierre.pebereau@telecom-paris.fr>
 @author: Alexis Barreaux <alexis.barreaux@telecom-paris.fr>
 """
@@ -9,33 +9,33 @@ from typing import Union
 
 import numpy as np
 from scipy import sparse
-from sknetwork.topology.weisfeiler_lehman_core import weisfeiler_lehman_coloring
 
-from sknetwork.utils.base import Algorithm
+from sknetwork.topology.weisfeiler_lehman_core import weisfeiler_lehman_coloring
+from sknetwork.utils.check import check_format, check_square
 
 
-class WeisfeilerLehman(Algorithm):
-    """Weisfeiler-Lehman algorithm for coloring/labeling graphs in order to check similarity.
+def color_weisfeiler_lehman(adjacency: Union[sparse.csr_matrix, np.ndarray], max_iter: int = -1) -> np.ndarray:
+    """Color nodes using Weisfeiler-Lehman algorithm.
 
     Parameters
     ----------
+    adjacency : sparse.csr_matrix
+        Adjacency matrix of the graph
     max_iter : int
-        Maximum number of iterations. Negative value  means until convergence.
+        Maximum number of iterations. Negative value means no limit (until convergence).
 
-    Attributes
-    ----------
-    labels_ : np.ndarray
+    Returns
+    -------
+    labels : np.ndarray
         Label of each node.
 
     Example
     -------
-    >>> from sknetwork.topology import WeisfeilerLehman
     >>> from sknetwork.data import house
-    >>> weisfeiler_lehman = WeisfeilerLehman()
     >>> adjacency = house()
-    >>> labels = weisfeiler_lehman.fit_transform(adjacency)
-    >>> labels
-    array([0, 2, 1, 1, 2], dtype=int32)
+    >>> labels = color_weisfeiler_lehman(adjacency)
+    >>> print(labels)
+    [0 2 1 1 2]
 
     References
     ----------
@@ -45,57 +45,26 @@ class WeisfeilerLehman(Algorithm):
 
     * Shervashidze, N., Schweitzer, P., van Leeuwen, E. J., Melhorn, K., Borgwardt, K. M. (2011)
       `Weisfeiler-Lehman graph kernels.
-      <http://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf>`_
+      <https://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf>`_
       Journal of Machine Learning Research 12, 2011.
     """
-    def __init__(self, max_iter: int = -1):
-        super(WeisfeilerLehman, self).__init__()
-        self.max_iter = max_iter
-        self.labels_ = None
-
-    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray]) -> 'WeisfeilerLehman':
-        """Fit algorithm to the data.
-
-        Parameters
-        ----------
-        adjacency : Union[sparse.csr_matrix, np.ndarray]
-            Adjacency matrix of the graph.
-
-        Returns
-        -------
-        self: :class:`WeisfeilerLehman`
-        """
-        n: int = adjacency.shape[0]
-        if self.max_iter < 0 or self.max_iter > n:
-            max_iter = np.int32(n)
-        else:
-            max_iter = np.int32(self.max_iter)
-
-        labels = np.zeros(n, dtype=np.int32)
-        powers = (-np.pi / 3.15) ** np.arange(n, dtype=np.double)
-        indptr = adjacency.indptr.astype(np.int32)
-        indices = adjacency.indices.astype(np.int32)
-
-        labels, _ = weisfeiler_lehman_coloring(indptr, indices, labels, powers, max_iter)
-        self.labels_ = np.asarray(labels).astype(np.int32)
-        return self
-
-    def fit_transform(self, adjacency: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
-        """Fit algorithm to the data and return the labels. Same parameters as the ``fit`` method.
-
-        Returns
-        -------
-        labels : np.ndarray
-            Labels.
-        """
-        self.fit(adjacency)
-        return self.labels_
-
-
-def are_isomorphic(adjacency1: sparse.csr_matrix,
-                   adjacency2: sparse.csr_matrix, max_iter: int = -1) -> bool:
-    """Weisfeiler-Lehman isomorphism test. If the test is False, the graphs cannot be isomorphic,
-    otherwise, they might be.
+
+    adjacency = check_format(adjacency, allow_empty=True)
+    check_square(adjacency)
+    n_nodes = adjacency.shape[0]
+    if max_iter < 0 or max_iter > n_nodes:
+        max_iter = n_nodes
+
+    labels = np.zeros(n_nodes, dtype=np.int32)
+    powers = (-np.pi / 3.15) ** np.arange(n_nodes, dtype=np.double)
+    indptr = adjacency.indptr
+    indices = adjacency.indices
+    labels, _ = weisfeiler_lehman_coloring(indptr, indices, labels, powers, max_iter)
+    return np.array(labels)
+
+
+def are_isomorphic(adjacency1: sparse.csr_matrix, adjacency2: sparse.csr_matrix, max_iter: int = -1) -> bool:
+    """Weisfeiler-Lehman isomorphism test. If the test is False, the graphs cannot be isomorphic.
 
     Parameters
     -----------
@@ -104,7 +73,7 @@ def are_isomorphic(adjacency1: sparse.csr_matrix,
     adjacency2 :
         Second adjacency matrix.
     max_iter : int
-        Maximum number of coloring iterations. Negative value means until convergence.
+        Maximum number of iterations. Negative value means no limit (until convergence).
 
     Returns
     -------
@@ -112,7 +81,6 @@ def are_isomorphic(adjacency1: sparse.csr_matrix,
 
     Example
     -------
-    >>> from sknetwork.topology import are_isomorphic
     >>> from sknetwork.data import house, bow_tie
     >>> are_isomorphic(house(), bow_tie())
     False
@@ -125,39 +93,41 @@ def are_isomorphic(adjacency1: sparse.csr_matrix,
 
     * Shervashidze, N., Schweitzer, P., van Leeuwen, E. J., Melhorn, K., Borgwardt, K. M. (2011)
       `Weisfeiler-Lehman graph kernels.
-      <http://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf>`_
+      <https://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf>`_
       Journal of Machine Learning Research 12, 2011.
     """
+    adjacency1 = check_format(adjacency1)
+    check_square(adjacency1)
+    adjacency2 = check_format(adjacency2)
+    check_square(adjacency2)
+
     if (adjacency1.shape != adjacency2.shape) or (adjacency1.nnz != adjacency2.nnz):
         return False
 
-    n = adjacency1.shape[0]
+    n_nodes = adjacency1.shape[0]
 
-    if max_iter < 0 or max_iter > n:
-        max_iter = n
+    if max_iter < 0 or max_iter > n_nodes:
+        max_iter = n_nodes
 
-    indptr1 = adjacency1.indptr.astype(np.int32)
-    indptr2 = adjacency2.indptr.astype(np.int32)
-    indices1 = adjacency1.indices.astype(np.int32)
-    indices2 = adjacency2.indices.astype(np.int32)
+    indptr1 = adjacency1.indptr
+    indptr2 = adjacency2.indptr
+    indices1 = adjacency1.indices
+    indices2 = adjacency2.indices
 
-    labels_1 = np.zeros(n, dtype=np.int32)
-    labels_2 = np.zeros(n, dtype=np.int32)
+    labels1 = np.zeros(n_nodes, dtype=np.int32)
+    labels2 = np.zeros(n_nodes, dtype=np.int32)
 
-    powers = (- np.pi / 3.15) ** np.arange(n, dtype=np.double)
+    powers = (-np.pi / 3.15) ** np.arange(n_nodes, dtype=np.double)
 
     iteration = 0
-    has_changed_1, has_changed_2 = True, True
-    while iteration < max_iter and (has_changed_1 or has_changed_2):
-        labels_1, has_changed_1 = weisfeiler_lehman_coloring(indptr1, indices1, labels_1, powers, max_iter=1)
-        labels_2, has_changed_2 = weisfeiler_lehman_coloring(indptr2, indices2, labels_2, powers, max_iter=1)
-
-        colors_1, counts_1 = np.unique(np.asarray(labels_1), return_counts=True)
-        colors_2, counts_2 = np.unique(np.asarray(labels_2), return_counts=True)
-
-        if (colors_1.shape != colors_2.shape) or (counts_1 != counts_2).any():
+    has_changed1, has_changed2 = True, True
+    while iteration < max_iter and (has_changed1 or has_changed2):
+        labels1, has_changed1 = weisfeiler_lehman_coloring(indptr1, indices1, labels1, powers, max_iter=1)
+        labels2, has_changed2 = weisfeiler_lehman_coloring(indptr2, indices2, labels2, powers, max_iter=1)
+        _, counts1 = np.unique(np.array(labels1), return_counts=True)
+        _, counts2 = np.unique(np.array(labels2), return_counts=True)
+        if (counts1 != counts2).any():
             return False
-
         iteration += 1
 
     return True