scikit-network 0.33.0__cp312-cp312-macosx_10_9_x86_64.whl

sknetwork/regression/tests/test_diffusion.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for diffusion.py"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.regression import Diffusion, Dirichlet
+
+
+# noinspection DuplicatedCode
+class TestDiffusion(unittest.TestCase):
+
+    def setUp(self):
+        self.algos = [Diffusion(), Dirichlet()]
+
+    def test_predict(self):
+        adjacency = test_graph()
+        for algo in self.algos:
+            values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5})
+            values_ = algo.predict()
+            self.assertAlmostEqual(np.linalg.norm(values - values_), 0)
+
+    def test_no_iter(self):
+        with self.assertRaises(ValueError):
+            Diffusion(n_iter=-1)
+
+    def test_single_node_graph(self):
+        for algo in self.algos:
+            algo.fit(sparse.identity(1, format='csr'), {0: 1})
+            self.assertEqual(algo.values_, [1])
+
+    def test_range(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            for algo in self.algos:
+                values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5})
+                self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+
+        biadjacency = test_bigraph()
+        for algo in [Diffusion(), Dirichlet()]:
+            values = algo.fit_predict(biadjacency, values_row={0: 1})
+            self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+            values = algo.fit_predict(biadjacency, values_row={0: 0.1}, values_col={1: 2}, init=0.3)
+            self.assertTrue(np.all(values <= 2) and np.all(values >= 0.1))
+            self.assertAlmostEqual(np.linalg.norm(algo.values_col_ - algo.predict(columns=True)), 0)
+
+    def test_initial_state(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            for algo in self.algos:
+                values = algo.fit_predict(adjacency, {0: 0, 1: 1, 2: 0.5}, 0.3)
+                self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+
+    def test_n_iter(self):
+        with self.assertRaises(ValueError):
+            Dirichlet(n_iter=0)
+

sknetwork/sknetwork.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+"""Main module."""

sknetwork/test_base.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for base.py"""
+import unittest
+
+from sknetwork.base import Algorithm
+
+
+class TestBase(unittest.TestCase):
+
+    def setUp(self):
+        class NewAlgo(Algorithm):
+            """Docstring"""
+            def __init__(self, param: int, name: str):
+                self.param = param
+                self.name = name
+
+            def fit(self):
+                """Docstring"""
+                pass
+        self.algo = NewAlgo(1, 'abc')
+
+    def test_repr(self):
+        self.assertEqual(repr(self.algo), "NewAlgo(param=1, name='abc')")
+
+    def test_get_params(self):
+        self.assertEqual(len(self.algo.get_params()), 2)
+
+    def test_set_params(self):
+        self.algo.set_params({'param': 3})
+        self.assertEqual(self.algo.param, 3)
+
+    def test_fit(self):
+        stub = Algorithm()
+        self.assertRaises(NotImplementedError, stub.fit, None)

sknetwork/test_log.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for verbose.py"""
+
+import unittest
+
+from sknetwork.log import Log
+
+
+class TestVerbose(unittest.TestCase):
+
+    def test_prints(self):
+        logger = Log(verbose=True)
+        logger.print_log('Hello', 42)
+        self.assertEqual(str(logger.log), 'Hello 42\n')

sknetwork/topology/__init__.py

@@ -0,0 +1,8 @@
+"""Module on topology."""
+from sknetwork.topology.cliques import count_cliques
+from sknetwork.topology.core import get_core_decomposition
+from sknetwork.topology.triangles import count_triangles, get_clustering_coefficient
+from sknetwork.topology.structure import is_connected, is_bipartite, is_symmetric, get_connected_components, \
+    get_largest_connected_component
+from sknetwork.topology.cycles import is_acyclic, get_cycles, break_cycles
+from sknetwork.topology.weisfeiler_lehman import color_weisfeiler_lehman, are_isomorphic

sknetwork/topology/cliques.pyx

@@ -0,0 +1,149 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in June 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+from libcpp.vector cimport vector
+import numpy as np
+cimport numpy as np
+from scipy import sparse
+
+cimport cython
+
+from sknetwork.path.dag import get_dag
+from sknetwork.topology.core import get_core_decomposition
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef class ListingBox:
+    cdef int[:] ns
+    cdef np.ndarray degrees
+    cdef np.ndarray subs
+    cdef short[:] lab
+
+    def __cinit__(self, vector[int] indptr, int k):
+        cdef int n = indptr.size() - 1
+        cdef int i
+        cdef int max_deg = 0
+
+        cdef np.ndarray[int, ndim=1] ns = np.empty((k+1,), dtype=np.int32)
+        ns[k] = n
+        self.ns = ns
+
+        cdef np.ndarray[short, ndim=1] lab = np.full((n,), k, dtype=np.int16)
+        self.lab = lab
+
+        cdef np.ndarray[int, ndim=1] deg = np.zeros(n, dtype=np.int32)
+        cdef np.ndarray[int, ndim=1] sub = np.zeros(n, dtype=np.int32)
+
+        for i in range(n):
+            deg[i] = indptr[i+1] - indptr[i]
+            max_deg = max(deg[i], max_deg)
+            sub[i] = i
+
+        self.degrees = np.empty((k+1,), dtype=object)
+        self.subs = np.empty((k+1,), dtype=object)
+
+        self.degrees[k] = deg
+        self.subs[k] = sub
+
+        for i in range(2, k):
+            deg = np.zeros(n, dtype=np.int32)
+            sub = np.zeros(max_deg, dtype=np.int32)
+            self.degrees[i] = deg
+            self.subs[i] = sub
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef long count_cliques_from_dag(vector[int] indptr, vector[int] indices, int clique_size, ListingBox box):
+    cdef int n = indptr.size() - 1
+    cdef long n_cliques = 0
+    cdef int i, j, k, k_max
+    cdef int u, v, w
+
+    if clique_size == 2:
+        degree_ = box.degrees[2]
+        sub_ = box.subs[2]
+        for i in range(box.ns[2]):
+            j = sub_[i]
+            n_cliques += degree_[j]
+        return n_cliques
+
+    sub_ = box.subs[clique_size]
+    sub_prev = box.subs[clique_size - 1]
+    degree_ = box.degrees[clique_size]
+    deg_prev = box.degrees[clique_size - 1]
+    for i in range(box.ns[clique_size]):
+        u = sub_[i]
+        box.ns[clique_size - 1] = 0
+        for j in range(indptr[u], indptr[u] + degree_[u]):
+            v = indices[j]
+            if box.lab[v] == clique_size:
+                box.lab[v] = clique_size - 1
+                sub_prev[box.ns[clique_size - 1]] = v
+                box.ns[clique_size - 1] += 1
+                deg_prev[v] = 0
+        for j in range(box.ns[clique_size - 1]):
+            v = sub_prev[j]
+            k = indptr[v]
+            k_max = indptr[v] + degree_[v]
+            while k < k_max:
+                w = indices[k]
+                if box.lab[w] == clique_size - 1:
+                    deg_prev[v] += 1
+                else:
+                    k_max -= 1
+                    indices[k] = indices[k_max]
+                    k -= 1
+                    indices[k_max] = w
+                k += 1
+        n_cliques += count_cliques_from_dag(indptr, indices, clique_size - 1, box)
+        for j in range(box.ns[clique_size - 1]):
+            v = sub_prev[j]
+            box.lab[v] = clique_size
+    return n_cliques
+
+
+def count_cliques(adjacency: sparse.csr_matrix, clique_size: int = 3) -> int:
+    """Count the number of cliques of some size.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    clique_size : int
+        Clique size (default = 3, corresponding to triangles.
+
+    Returns
+    -------
+    n_cliques : int
+        Number of cliques.
+
+    Example
+    -------
+    >>> from sknetwork.data import karate_club
+    >>> adjacency = karate_club()
+    >>> count_cliques(adjacency, 3)
+    45
+
+    References
+    ----------
+    Danisch, M., Balalau, O., & Sozio, M. (2018, April).
+    `Listing k-cliques in sparse real-world graphs.
+    <https://dl.acm.org/doi/pdf/10.1145/3178876.3186125>`_
+    In Proceedings of the 2018 World Wide Web Conference (pp. 589-598).
+    """
+    if clique_size < 2:
+        raise ValueError("The clique size must be at least 2.")
+
+    values = get_core_decomposition(adjacency)
+    dag = get_dag(adjacency, order=np.argsort(values))
+    indptr = dag.indptr
+    indices = dag.indices
+    box = ListingBox.__new__(ListingBox, indptr, clique_size)
+    n_cliques = count_cliques_from_dag(indptr, indices, clique_size, box)
+    return n_cliques

sknetwork/topology/core.pyx

@@ -0,0 +1,90 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in June 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+cimport cython
+
+from typing import Union
+
+import numpy as np
+cimport numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import check_format
+from sknetwork.topology.minheap cimport MinHeap
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef compute_core(int[:] indptr, int[:] indices):
+    """Compute the core value of each node.
+
+    Parameters
+    ----------
+    indptr :
+        CSR format index array of the adjacency matrix.
+    indices :
+        CSR format index pointer array of the adjacency matrix.
+
+    Returns
+    -------
+    labels :
+        Core value of each node.
+    """
+    cdef int n = indptr.shape[0] - 1
+    cdef int core_value	= 0	# current/max core value of the graph
+    cdef int min_node		# current node of minimum degree
+    cdef int i, j, k
+    cdef int[:] degrees = np.asarray(indptr)[1:] - np.asarray(indptr)[:n]
+    cdef np.ndarray[int, ndim=1] labels = np.empty((n,), dtype=np.int32)
+    cdef MinHeap mh = MinHeap.__new__(MinHeap, n)	# minimum heap with an update system
+
+    # insert all nodes in the heap
+    for i in range(n):
+        mh.insert_key(i, degrees)
+
+    i = n - 1
+    while not mh.empty():
+        min_node = mh.pop_min(degrees)
+        core_value = max(core_value, degrees[min_node])
+
+        # decrease the degree of each neighbor of min_node
+        for k in range(indptr[min_node], indptr[min_node+1]):
+            j = indices[k]
+            degrees[j] -= 1
+            mh.decrease_key(j, degrees)		# update the heap to take the new degree into account
+
+        labels[min_node] = core_value
+        i -= 1
+
+    return np.asarray(labels)
+
+
+def get_core_decomposition(adjacency: Union[np.ndarray, sparse.csr_matrix]) -> np.ndarray:
+    """Get the k-core decomposition of a graph.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+
+    Returns
+    -------
+    core_values :
+         Core value of each node.
+
+    Example
+    -------
+    >>> from sknetwork.data import karate_club
+    >>> adjacency = karate_club()
+    >>> core_values = get_core_decomposition(adjacency)
+    >>> len(core_values)
+    34
+    """
+    adjacency = check_format(adjacency, allow_empty=True)
+    indptr = adjacency.indptr
+    indices = adjacency.indices
+    return compute_core(indptr, indices)

sknetwork/topology/cycles.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in February 2024
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+@author: Yiwen Peng <yiwen.peng@telecom-paris.fr>
+"""
+from typing import Tuple, Optional, Union, List
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import is_symmetric, check_format
+from sknetwork.utils.format import get_adjacency
+from sknetwork.path import get_distances
+
+
+def is_acyclic(adjacency: sparse.csr_matrix, directed: Optional[bool] = None) -> bool:
+    """Check whether a graph has no cycle.
+
+    Parameters
+    ----------
+    adjacency:
+        Adjacency matrix of the graph.
+    directed:
+        Whether to consider the graph as directed (inferred if not specified).
+    Returns
+    -------
+    is_acyclic : bool
+        A boolean with value True if the graph has no cycle and False otherwise.
+
+    Example
+    -------
+    >>> from sknetwork.topology import is_acyclic
+    >>> from sknetwork.data import star, grid
+    >>> is_acyclic(star())
+    True
+    >>> is_acyclic(grid())
+    False
+    """
+    if directed is False:
+        # the graph must be undirected
+        if not is_symmetric(adjacency):
+            raise ValueError("The adjacency matrix is not symmetric. The parameter 'directed' must be True.")
+    elif directed is None:
+        # if not specified, infer from the graph
+        directed = not is_symmetric(adjacency)
+    has_loops = (adjacency.diagonal() > 0).any()
+    if has_loops:
+        return False
+    else:
+        n_cc = sparse.csgraph.connected_components(adjacency, directed, connection='strong', return_labels=False)
+        n_nodes = adjacency.shape[0]
+        if directed:
+            return n_cc == n_nodes
+        else:
+            n_edges = adjacency.nnz // 2
+            return n_cc == n_nodes - n_edges
+
+
+def get_cycles(adjacency: sparse.csr_matrix, directed: Optional[bool] = None) -> List[List[int]]:
+    """Get all possible cycles of a graph.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    directed :
+        Whether to consider the graph as directed (inferred if not specified).
+
+    Returns
+    -------
+    cycles : list
+        List of cycles, each cycle represented as a list of nodes.
+
+    Example
+    -------
+    >>> from sknetwork.topology import get_cycles
+    >>> from sknetwork.data import cyclic_digraph
+    >>> graph = cyclic_digraph(4, metadata=True)
+    >>> get_cycles(graph.adjacency, directed=True)
+    [[0, 1, 2, 3]]
+    """
+
+    if directed is False:
+        # the graph must be undirected
+        if not is_symmetric(adjacency):
+            raise ValueError("The adjacency matrix is not symmetric. The parameter 'directed' must be True.")
+    elif directed is None:
+        # if not specified, infer from the graph
+        directed = not is_symmetric(adjacency)
+
+    cycles = []
+    n_nodes = adjacency.shape[0]
+    self_loops = np.argwhere(adjacency.diagonal() > 0).ravel()
+    if len(self_loops) > 0:
+        # add self-loops as cycles
+        for node in self_loops:
+            cycles.append([node])
+
+    # check if the graph is acyclic
+    n_cc, cc_labels = sparse.csgraph.connected_components(adjacency, directed, connection='strong', return_labels=True)
+    if directed and n_cc == n_nodes:
+        return cycles
+    elif not directed:
+        # acyclic undirected graph
+        n_edges = adjacency.nnz // 2
+        if n_cc == n_nodes - n_edges:
+            return cycles
+
+    # locate possible cycles
+    labels, counts = np.unique(cc_labels, return_counts=True)
+    if directed:
+        labels = labels[counts > 1]
+    cycle_starts = [np.argwhere(cc_labels == label).ravel()[0] for label in labels]
+
+    # find cycles for indicated nodes (depth-first traversal)
+    for start_node in cycle_starts:
+        stack = [(start_node, [start_node])]
+        while stack:
+            current_node, path = stack.pop()
+            for neighbor in adjacency.indices[adjacency.indptr[current_node]:adjacency.indptr[current_node+1]]:
+                if not directed and len(path) > 1 and neighbor == path[-2]:
+                    # ignore the inverse edge (back move) in undirected graph
+                    continue
+                if neighbor in path:
+                    cycles.append(path[path.index(neighbor):])
+                else:
+                    stack.append((neighbor, path + [neighbor]))
+
+    # remove duplicates
+    visited_cycles, unique_cycles = set(), []
+    for cycle in cycles:
+        candidate = np.roll(cycle, -cycle.index(min(cycle)))
+        current_cycle = tuple(candidate)
+        if not directed:
+            current_cycle = tuple(np.sort(candidate))
+        if current_cycle not in visited_cycles:
+            unique_cycles.append(list(candidate))
+        visited_cycles.add(current_cycle)
+
+    return unique_cycles
+
+
+def break_cycles(adjacency: sparse.csr_matrix, root: Union[int, List[int]],
+                 directed: Optional[bool] = None) -> sparse.csr_matrix:
+    """Break cycles of a graph from given roots.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    root :
+        The root node or list of root nodes to break cycles from.
+    directed :
+        Whether to consider the graph as directed (inferred if not specified).
+
+    Returns
+    -------
+    adjacency : sparse.csr_matrix
+        Adjacency matrix of the acyclic graph.
+
+    Example
+    -------
+    >>> from sknetwork.topology import break_cycles, is_acyclic
+    >>> from sknetwork.data import cyclic_digraph
+    >>> adjacency = cyclic_digraph(4)
+    >>> dag = break_cycles(adjacency, root=0, directed=True)
+    >>> is_acyclic(dag, directed=True)
+    True
+    """
+
+    if is_acyclic(adjacency, directed):
+        return adjacency
+
+    if root is None:
+        raise ValueError("The parameter root must be specified.")
+    else:
+        out_degree = len(adjacency[root].indices)
+        if out_degree == 0:
+            raise ValueError("Invalid root node. The root must have at least one outgoing edge.")
+        if isinstance(root, int):
+            root = [root]
+
+    if directed is False:
+        # the graph must be undirected
+        if not is_symmetric(adjacency):
+            raise ValueError("The adjacency matrix is not symmetric. The parameter 'directed' must be True.")
+    elif directed is None:
+        # if not specified, infer from the graph
+        directed = not is_symmetric(adjacency)
+
+    # break self-loops
+    adjacency = (adjacency - sparse.diags(adjacency.diagonal().astype(int), format='csr')).astype(int)
+
+    if directed:
+        # break cycles from the cycle node closest to the root
+        _, cc_labels = sparse.csgraph.connected_components(adjacency, directed, connection='strong', return_labels=True)
+        labels, counts = np.unique(cc_labels, return_counts=True)
+        cycle_labels = labels[counts > 1]
+        distances = get_distances(adjacency, source=root)
+
+        for label in cycle_labels:
+            cycle_nodes = np.argwhere(cc_labels == label).ravel()
+            roots_ix = np.argwhere(distances[cycle_nodes] == min(distances[cycle_nodes])).ravel()
+            subroots = set(cycle_nodes[roots_ix])
+            stack = [(subroot, [subroot]) for subroot in subroots]
+            # break cycles using depth-first traversal
+            while stack:
+                current_node, path = stack.pop()
+                # check if the edge still exists
+                if len(path) > 1 and adjacency[path[-2], path[-1]] <= 0:
+                    continue
+                neighbors = adjacency.indices[adjacency.indptr[current_node]:adjacency.indptr[current_node+1]]
+                cycle_neighbors = set(neighbors) & set(cycle_nodes)
+                for neighbor in cycle_neighbors:
+                    if neighbor in path:
+                        adjacency[current_node, neighbor] = 0
+                        adjacency.eliminate_zeros()
+                    else:
+                        stack.append((neighbor, path + [neighbor]))
+    else:
+        # break cycles from given roots for undirected graphs
+        for start_node in root:
+            stack = [(start_node, [start_node])]
+            # break cycles using depth-first traversal
+            while stack:
+                current_node, path = stack.pop()
+                # check if the edge still exists
+                if len(path) > 1 and adjacency[path[-2], path[-1]] <= 0:
+                    continue
+                neighbors = list(adjacency.indices[adjacency.indptr[current_node]:adjacency.indptr[current_node+1]])
+                for neighbor in neighbors:
+                    if len(path) > 1 and neighbor == path[-2]:
+                        continue
+                    if neighbor in path:
+                        adjacency[current_node, neighbor] = 0
+                        adjacency[neighbor, current_node] = 0
+                        adjacency.eliminate_zeros()
+                    else:
+                        stack.append((neighbor, path + [neighbor]))
+
+    return adjacency

sknetwork/topology/minheap.pxd

@@ -0,0 +1,20 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in June 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+from libcpp.vector cimport vector
+
+cdef class MinHeap:
+
+    cdef vector[int] val, pos
+    cdef int size
+
+    cdef int pop_min(self, int[:] scores)
+    cdef bint empty(self)
+    cdef void swap(self, int x, int y)
+    cdef void insert_key(self, int k, int[:] scores)
+    cdef void decrease_key(self, int i, int[:] scores)
+    cdef void min_heapify(self, int i, int[:] scores)