scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/topology/triangles.pyx

@@ -0,0 +1,166 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Jun 3, 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>
+"""
+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
+
+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.
+
+    Parameters
+    ----------
+    source :
+        Index of the node to study.
+    indptr :
+        CSR format index pointer array of the normalized adjacency matrix of a DAG.
+    indices :
+        CSR format index array of the normalized adjacency matrix of a DAG.
+
+    Returns
+    -------
+    n_triangles :
+        Number of nodes in the intersection
+    """
+    cdef int i, j, k
+    cdef int v
+    cdef long n_triangles = 0		# number of nodes in the intersection
+
+    for k in range(indptr[source], indptr[source+1]):
+        v = indices[k]
+        i = indptr[source]
+        j = indptr[v]
+
+        # calculates the intersection of the neighbors of u and v
+        while (i < indptr[source+1]) and (j < indptr[v+1]):
+            if indices[i] == indices[j]:
+                i += 1
+                j += 1
+                n_triangles += 1
+            else :
+                if indices[i] < indices[j]:
+                    i += 1
+                else :
+                    j += 1
+
+    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.
+
+    Parameters
+    ----------
+    indptr :
+        CSR format index pointer array of the normalized adjacency matrix of a DAG.
+    indices :
+        CSR format index array of the normalized adjacency matrix of a DAG.
+    parallelize :
+        If ``True``, use a parallel range to count triangles.
+
+    Returns
+    -------
+    n_triangles :
+        Number of triangles in the graph
+    """
+    cdef int n = indptr.size() - 1
+    cdef int u
+    cdef long n_triangles = 0
+
+    if parallelize:
+        for u in prange(n, nogil=True):
+            n_triangles += count_local_triangles(u, indptr, indices)
+    else:
+        for u in range(n):
+            n_triangles += count_local_triangles(u, indptr, indices)
+
+    return n_triangles
+
+
+class Triangles(Algorithm):
+    """Count the number of triangles in a graph, and evaluate the clustering coefficient.
+
+    * Graphs
+
+    Parameters
+    ----------
+    parallelize :
+        If ``True``, use a parallel range while listing the triangles.
+
+    Attributes
+    ----------
+    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)
+    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_

sknetwork/topology/weisfeiler_lehman.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 2, 2020
+@author: Pierre Pebereau <pierre.pebereau@telecom-paris.fr>
+@author: Alexis Barreaux <alexis.barreaux@telecom-paris.fr>
+"""
+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
+
+
+class WeisfeilerLehman(Algorithm):
+    """Weisfeiler-Lehman algorithm for coloring/labeling graphs in order to check similarity.
+
+    Parameters
+    ----------
+    max_iter : int
+        Maximum number of iterations. Negative value  means until convergence.
+
+    Attributes
+    ----------
+    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)
+
+    References
+    ----------
+    * Douglas, B. L. (2011).
+      `The Weisfeiler-Lehman Method and Graph Isomorphism Testing.
+      <https://arxiv.org/pdf/1101.5211.pdf>`_
+
+    * 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>`_
+      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.
+
+    Parameters
+    -----------
+    adjacency1 :
+        First adjacency matrix.
+    adjacency2 :
+        Second adjacency matrix.
+    max_iter : int
+        Maximum number of coloring iterations. Negative value means until convergence.
+
+    Returns
+    -------
+    test_result : bool
+
+    Example
+    -------
+    >>> from sknetwork.topology import are_isomorphic
+    >>> from sknetwork.data import house, bow_tie
+    >>> are_isomorphic(house(), bow_tie())
+    False
+
+    References
+    ----------
+    * Douglas, B. L. (2011).
+      `The Weisfeiler-Lehman Method and Graph Isomorphism Testing.
+      <https://arxiv.org/pdf/1101.5211.pdf>`_
+
+    * 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>`_
+      Journal of Machine Learning Research 12, 2011.
+    """
+    if (adjacency1.shape != adjacency2.shape) or (adjacency1.nnz != adjacency2.nnz):
+        return False
+
+    n = adjacency1.shape[0]
+
+    if max_iter < 0 or max_iter > n:
+        max_iter = n
+
+    indptr1 = adjacency1.indptr.astype(np.int32)
+    indptr2 = adjacency2.indptr.astype(np.int32)
+    indices1 = adjacency1.indices.astype(np.int32)
+    indices2 = adjacency2.indices.astype(np.int32)
+
+    labels_1 = np.zeros(n, dtype=np.int32)
+    labels_2 = np.zeros(n, dtype=np.int32)
+
+    powers = (- np.pi / 3.15) ** np.arange(n, 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():
+            return False
+
+        iteration += 1
+
+    return True

sknetwork/topology/weisfeiler_lehman_core.pyx

@@ -0,0 +1,116 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on July 1, 2020
+@author: Pierre Pebereau <pierre.pebereau@telecom-paris.fr>
+@author: Alexis Barreaux <alexis.barreaux@telecom-paris.fr>
+"""
+from libcpp.vector cimport vector
+from libc.math cimport pow
+cimport cython
+
+ctypedef (int, double, int) ctuple
+
+cdef extern from "<algorithm>" namespace "std":
+    # fixed sort as per https://stackoverflow.com/questions/57584909/unable-to-use-cdef-function-in-stdsort-as-comparison-function
+    void sort(...)
+    void csort "sort"(...)
+
+cdef bint is_lower(ctuple a, ctuple b) :
+    """Lexicographic comparison between triplets based on the first two values.
+
+    Parameters
+    ----------
+    a:
+        First triplet.
+    b:
+        Second triplet.
+
+    Returns
+    -------
+    ``True`` if a < b, and ``False`` otherwise.
+    """
+    cdef int a1, b1
+    cdef double a2, b2
+
+    a1, a2, _ = a
+    b1, b2, _ = b
+    if a1 == b1 :
+        return a2 < b2
+    return a1 < b1
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def weisfeiler_lehman_coloring(int[:] indptr, int[:] indices, int[:] labels, double [:] powers, int max_iter):
+    """Weisfeiler-Lehman coloring.
+
+    Parameters
+    ----------
+    indptr :
+        Indptr of the CSR.
+    indices :
+        Indices of the CSR.
+    labels : int[:]
+        Labels to be changed.
+    powers : double [:]
+        Powers being used as hash and put in a memory view to limit several identical calculations.
+    max_iter : int
+        Maximum number of iterations.
+
+    Returns
+    -------
+    labels : int[:]
+        Colors of the nodes.
+    has_changed : bint
+        True if the output labels are not the same as the input ones. False otherwise.
+    """
+    cdef int n = indptr.shape[0] -1
+    cdef int iteration = 0
+    cdef int i, j, j1, j2, jj, label
+
+    cdef double epsilon = pow(10, -10)
+
+    cdef vector[ctuple] new_labels
+    cdef ctuple tuple_ref, tuple_new
+    cdef double hash_ref, hash_new
+    cdef int label_ref, label_new
+
+    cdef bint has_changed = True
+
+    while iteration < max_iter and has_changed:
+        new_labels.clear()
+        has_changed = False
+
+        for i in range(n):
+            hash_ref = 0
+            j1 = indptr[i]
+            j2 = indptr[i + 1]
+
+            for jj in range(j1, j2):
+                j = indices[jj]
+                hash_ref += powers[labels[j]]
+
+            new_labels.push_back((labels[i], hash_ref, i))
+        csort(new_labels.begin(), new_labels.end(), is_lower)
+        label = 0
+        tuple_new = new_labels[0]
+        labels[tuple_new[2]] = label
+        for j in range(1, n):
+            tuple_ref = tuple_new
+            tuple_new = new_labels[j]
+            label_ref, hash_ref, _ = tuple_ref
+            label_new, hash_new, i = tuple_new
+
+            if abs(hash_new - hash_ref) > epsilon or label_new != label_ref :
+                label += 1
+
+            if labels[i] != label:
+                has_changed = True
+
+            labels[i] = label
+        iteration += 1
+
+    return labels, has_changed

sknetwork/utils/__init__.py

@@ -0,0 +1,40 @@
+"""utils module"""
+from sknetwork.utils.check import is_symmetric
+from sknetwork.utils.co_neighbor import co_neighbor_graph
+from sknetwork.utils.format import *
+from sknetwork.utils.kmeans import KMeansDense
+from sknetwork.utils.knn import KNNDense, CNNDense
+from sknetwork.utils.membership import get_membership, from_membership
+from sknetwork.utils.neighbors import get_neighbors, get_degrees, get_weights
+from sknetwork.utils.simplex import projection_simplex, projection_simplex_array, projection_simplex_csr
+from sknetwork.utils.ward import WardDense
+
+
+class Bunch(dict):
+    """Container object for datasets.
+    Dictionary-like object that exposes its keys as attributes.
+
+    This code is taken from scikit-learn.
+    >>> bunch = Bunch(a=1, b=2)
+    >>> bunch['a']
+    1
+    >>> bunch.a
+    1
+    >>> bunch.b = 3
+    >>> bunch['b']
+    3
+    >>> bunch.c = 4
+    >>> bunch['c']
+    4
+    """
+    def __init__(self, **kwargs):
+        super().__init__(kwargs)
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(key)

sknetwork/utils/base.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Jun 28, 2019
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+import inspect
+
+
+class Algorithm:
+    """Base class for all algorithms."""
+    def __repr__(self):
+        # parameters not to display
+        arg_black_list = ['self', 'random_state', 'verbose']
+        output = self.__class__.__name__ + '('
+        signature = inspect.signature(self.__class__.__init__)
+        arguments = [arg.name for arg in signature.parameters.values() if arg.name not in arg_black_list]
+        for p in arguments:
+            try:
+                val = self.__dict__[p]
+            except KeyError:
+                continue
+            if type(val) == str:
+                val = "'" + val + "'"
+            else:
+                val = str(val)
+            output += p + '=' + val + ', '
+        if output[-1] != '(':
+            return output[:-2] + ')'
+        else:
+            return output + ')'
+
+    def fit(self, *args, **kwargs):
+        """Fit Algorithm to the data."""
+        raise NotImplementedError