scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/regression/diffusion.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from typing import Union, Optional, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg.normalization import normalize
+from sknetwork.regression.base import BaseRegressor
+from sknetwork.utils.format import get_adjacency_seeds
+
+
+def init_temperatures(seeds: np.ndarray, init: Optional[float]) -> Tuple[np.ndarray, np.ndarray]:
+    """Init temperatures."""
+    n = len(seeds)
+    border = (seeds >= 0)
+    if init is None:
+        temperatures = seeds[border].mean() * np.ones(n)
+    else:
+        temperatures = init * np.ones(n)
+    temperatures[border] = seeds[border]
+    return temperatures, border
+
+
+class Diffusion(BaseRegressor):
+    """Regression by diffusion along the edges, given the temperatures of some seed nodes (heat equation).
+
+    All values are updated, including those of seed nodes (free diffusion).
+    See ``Dirichlet`` for diffusion with boundary constraints.
+
+    Parameters
+    ----------
+    n_iter : int
+        Number of iterations of the diffusion (must be positive).
+
+    Attributes
+    ----------
+    values_ : np.ndarray
+        Value of each node (= temperature).
+    values_row_: np.ndarray
+        Values of rows, for bipartite graphs.
+    values_col_: np.ndarray
+        Values of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.data import house
+    >>> diffusion = Diffusion(n_iter=2)
+    >>> adjacency = house()
+    >>> seeds = {0: 1, 2: 0}
+    >>> values = diffusion.fit_predict(adjacency, seeds)
+    >>> np.round(values, 2)
+    array([0.58, 0.56, 0.38, 0.58, 0.42])
+
+    References
+    ----------
+    Chung, F. (2007). The heat kernel as the pagerank of a graph. Proceedings of the National Academy of Sciences.
+    """
+    def __init__(self, n_iter: int = 3):
+        super(Diffusion, self).__init__()
+
+        if n_iter <= 0:
+            raise ValueError('The number of iterations must be positive.')
+        else:
+            self.n_iter = n_iter
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
+            seeds: Optional[Union[dict, np.ndarray]] = None, seeds_row: Optional[Union[dict, np.ndarray]] = None,
+            seeds_col: Optional[Union[dict, np.ndarray]] = None, init: Optional[float] = None,
+            force_bipartite: bool = False) -> 'Diffusion':
+        """Compute the diffusion (temperatures at equilibrium).
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        seeds :
+            Temperatures of seed nodes in initial state (dictionary or vector). Negative temperatures ignored.
+        seeds_row, seeds_col :
+            Temperatures of rows and columns for bipartite graphs. Negative temperatures ignored.
+        init :
+            Temperature of non-seed nodes in initial state.
+            If ``None``, use the average temperature of seed nodes (default).
+        force_bipartite :
+            If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
+
+        Returns
+        -------
+        self: :class:`Diffusion`
+        """
+        adjacency, seeds, self.bipartite = get_adjacency_seeds(input_matrix, force_bipartite=force_bipartite,
+                                                               seeds=seeds, seeds_row=seeds_row, seeds_col=seeds_col)
+        values, _ = init_temperatures(seeds, init)
+        diffusion = normalize(adjacency)
+        for i in range(self.n_iter):
+            values = diffusion.dot(values)
+
+        self.values_ = values
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+        return self
+
+
+class Dirichlet(BaseRegressor):
+    """Regression by the Dirichlet problem, given the temperature of some seed nodes
+     (heat diffusion with boundary constraints).
+
+     Only values of non-seed nodes are updated. The temperatures of seed nodes are fixed.
+
+    Parameters
+    ----------
+    n_iter : int
+        Number of iterations of the diffusion (must be positive).
+
+    Attributes
+    ----------
+    values_ : np.ndarray
+        Value of each node (= temperature).
+    values_row_: np.ndarray
+        Values of rows, for bipartite graphs.
+    values_col_: np.ndarray
+        Values of columns, for bipartite graphs.
+    Example
+    -------
+    >>> from sknetwork.regression import Dirichlet
+    >>> from sknetwork.data import house
+    >>> dirichlet = Dirichlet()
+    >>> adjacency = house()
+    >>> seeds = {0: 1, 2: 0}
+    >>> values = dirichlet.fit_predict(adjacency, seeds)
+    >>> np.round(values, 2)
+    array([1.  , 0.54, 0.  , 0.31, 0.62])
+
+    References
+    ----------
+    Chung, F. (2007). The heat kernel as the pagerank of a graph. Proceedings of the National Academy of Sciences.
+    """
+    def __init__(self, n_iter: int = 10):
+        super(Dirichlet, self).__init__()
+
+        if n_iter <= 0:
+            raise ValueError('The number of iterations must be positive.')
+        else:
+            self.n_iter = n_iter
+        self.bipartite = None
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
+            seeds: Optional[Union[dict, np.ndarray]] = None, seeds_row: Optional[Union[dict, np.ndarray]] = None,
+            seeds_col: Optional[Union[dict, np.ndarray]] = None, init: Optional[float] = None,
+            force_bipartite: bool = False) -> 'Dirichlet':
+        """Compute the solution to the Dirichlet problem (temperatures at equilibrium).
+
+        Parameters
+        ----------
+        input_matrix :
+            Adjacency matrix or biadjacency matrix of the graph.
+        seeds :
+            Temperatures of seed nodes (dictionary or vector). Negative temperatures ignored.
+        seeds_row, seeds_col :
+            Temperatures of rows and columns for bipartite graphs. Negative temperatures ignored.
+        init :
+            Temperature of non-seed nodes in initial state.
+            If ``None``, use the average temperature of seed nodes (default).
+        force_bipartite :
+            If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
+
+        Returns
+        -------
+        self: :class:`Dirichlet`
+        """
+        adjacency, seeds, self.bipartite = get_adjacency_seeds(input_matrix, force_bipartite=force_bipartite,
+                                                               seeds=seeds, seeds_row=seeds_row, seeds_col=seeds_col)
+        temperatures, border = init_temperatures(seeds, init)
+        values = temperatures.copy()
+        diffusion = normalize(adjacency)
+        for i in range(self.n_iter):
+            values = diffusion.dot(values)
+            values[border] = temperatures[border]
+
+        self.values_ = values
+        if self.bipartite:
+            self._split_vars(input_matrix.shape)
+
+        return self

sknetwork/regression/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for regression"""

sknetwork/regression/tests/test_API.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for regression API"""
+import unittest
+
+from sknetwork.data.test_graphs import test_bigraph, test_graph, test_digraph
+from sknetwork.regression import *
+
+
+class TestAPI(unittest.TestCase):
+
+    def test_basic(self):
+        methods = [Diffusion(), Dirichlet()]
+        for adjacency in [test_graph(), test_digraph()]:
+            n = adjacency.shape[0]
+            for method in methods:
+                score = method.fit_predict(adjacency)
+                self.assertEqual(score.shape, (n, ))
+                self.assertTrue(min(score) >= 0)
+                score = method.fit_transform(adjacency)
+                self.assertEqual(score.shape, (n,))
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        n_row, n_col = biadjacency.shape
+
+        methods = [Diffusion(), Dirichlet()]
+        for method in methods:
+            method.fit(biadjacency)
+            values_row = method.values_row_
+            values_col = method.values_col_
+
+            self.assertEqual(values_row.shape, (n_row,))
+            self.assertEqual(values_col.shape, (n_col,))

sknetwork/regression/tests/test_diffusion.py

@@ -0,0 +1,48 @@
+#!/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_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_transform(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, seeds_row={0: 1})
+            self.assertTrue(np.all(values <= 1) and np.all(values >= 0))
+            values = algo.fit_predict(biadjacency, seeds_row={0: 0.1}, seeds_col={1: 2}, init=0.3)
+            self.assertTrue(np.all(values <= 2) and np.all(values >= 0.1))
+
+    def test_initial_state(self):
+        for adjacency in [test_graph(), test_digraph()]:
+            for algo in self.algos:
+                values = algo.fit_transform(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/topology/__init__.py

@@ -0,0 +1,9 @@
+"""Module on topology."""
+from sknetwork.topology.kcliques import Cliques
+from sknetwork.topology.kcore import CoreDecomposition
+from sknetwork.topology.triangles import Triangles
+
+from sknetwork.topology.dag import DAG
+from sknetwork.topology.structure import is_acyclic, is_bipartite, is_connected, get_largest_connected_component, \
+    get_connected_components
+from sknetwork.topology.weisfeiler_lehman import WeisfeilerLehman, are_isomorphic

sknetwork/topology/dag.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Jun 3, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import numpy as np
+from scipy import sparse
+from sknetwork.topology.dag_core import fit_core
+
+from sknetwork.utils.base import Algorithm
+
+
+class DAG(Algorithm):
+    """Build a Directed Acyclic Graph from an adjacency.
+
+    * Graphs
+    * DiGraphs
+
+    Parameters
+    ----------
+    ordering : str
+        A method to sort the nodes.
+
+        * If None, the default order is the index.
+        * If ``'degree'``, the nodes are sorted by ascending degree.
+
+    Attributes
+    ----------
+    indptr_ : np.ndarray
+        Pointer index as for CSR format.
+    indices_ : np.ndarray
+        Indices as for CSR format.
+    """
+    def __init__(self, ordering: str = None):
+        super(DAG, self).__init__()
+        self.ordering = ordering
+        self.indptr_ = None
+        self.indices_ = None
+
+    def fit(self, adjacency: sparse.csr_matrix, sorted_nodes=None):
+        """Fit algorithm to the data.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph.
+        sorted_nodes : np.ndarray
+            An order on the nodes such that the DAG only contains edges (i, j) such that
+            ``sorted_nodes[i] < sorted_nodes[j]``.
+        """
+        indptr = adjacency.indptr.astype(np.int32)
+        indices = adjacency.indices.astype(np.int32)
+
+        if sorted_nodes is not None:
+            if adjacency.shape[0] != sorted_nodes.shape[0]:
+                raise ValueError('Dimensions mismatch between adjacency and sorted_nodes.')
+            else:
+                sorted_nodes = sorted_nodes.astype(np.int32)
+        else:
+            if self.ordering is None:
+                sorted_nodes = np.arange(adjacency.shape[0]).astype(np.int32)
+            elif self.ordering == 'degree':
+                degrees = indptr[1:] - indptr[:-1]
+                sorted_nodes = np.argsort(degrees).astype(np.int32)
+            else:
+                raise ValueError('Unknown ordering of nodes.')
+
+        ix = np.zeros(adjacency.shape[0], dtype=np.int32)
+        dag_indptr, dag_indices = fit_core(indptr, indices, sorted_nodes, ix)
+        self.indptr_ = np.asarray(dag_indptr)
+        self.indices_ = np.asarray(dag_indices)
+
+        return self

sknetwork/topology/dag_core.pyx

@@ -0,0 +1,38 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Jun 3, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from libcpp.vector cimport vector
+
+cimport cython
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def fit_core(int[:] indptr, int[:] indices, int[:] sorted_nodes, int[:] ix):
+    """Build DAG given an order of the nodes.
+    """
+    cdef int n = indptr.shape[0] - 1
+    cdef int u, v, k
+    cdef long n_triangles = 0
+    cdef vector[int] dag_indptr, dag_indices
+
+    for i in range(n):
+        ix[sorted_nodes[i]] = i
+
+    # create the DAG
+    cdef int ptr = 0
+    dag_indptr.push_back(ptr)
+    for u in range(n):
+        for k in range(indptr[u], indptr[u+1]):
+            v = indices[k]
+            if ix[u] < ix[v]:	# the edge needs to be added
+                dag_indices.push_back(v)
+                ptr += 1
+        dag_indptr.push_back(ptr)
+
+    return dag_indptr, dag_indices

sknetwork/topology/kcliques.pyx

@@ -0,0 +1,193 @@
+# 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>
+"""
+from libcpp.vector cimport vector
+import numpy as np
+cimport numpy as np
+from scipy import sparse
+
+cimport cython
+
+from sknetwork.topology.dag import DAG
+from sknetwork.topology.kcore import CoreDecomposition
+
+
+# ----- Collections of arrays used by our listing algorithm -----
+@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 fit_core(vector[int] indptr, vector[int] indices, int l, ListingBox box):
+    cdef int n = indptr.size() - 1
+    cdef long n_cliques = 0
+    cdef int i, j, k
+    cdef int u, v, w
+    cdef int cd
+
+    if l == 2:
+        degree_l = box.degrees[2]
+        sub_l = box.subs[2]
+        for i in range(box.ns[2]):
+            j = sub_l[i]
+            n_cliques += degree_l[j]
+
+        return n_cliques
+
+    sub_l = box.subs[l]
+    sub_prev = box.subs[l-1]
+    degree_l = box.degrees[l]
+    deg_prev = box.degrees[l-1]
+    for i in range(box.ns[l]):
+        u = sub_l[i]
+        box.ns[l-1] = 0
+        cd = indptr[u] + degree_l[u]
+        for j in range(indptr[u], cd):
+            v = indices[j]
+            if box.lab[v] == l:
+                box.lab[v] = l-1
+                sub_prev[box.ns[l-1]] = v
+                box.ns[l-1] += 1
+                deg_prev[v] = 0
+
+        for j in range(box.ns[l-1]):
+            v = sub_prev[j]
+            cd = indptr[v] + degree_l[v]
+            k = indptr[v]
+            while k < cd:
+                w = indices[k]
+                if box.lab[w] == l-1:
+                    deg_prev[v] += 1
+                else:
+                    cd -= 1
+                    indices[k] = indices[cd]
+                    k -= 1
+                    indices[cd] = w
+
+                k += 1
+
+        n_cliques += fit_core(indptr, indices, l-1, box)
+        for j in range(box.ns[l-1]):
+            v = sub_prev[j]
+            box.lab[v] = l
+
+    return n_cliques
+
+
+class Cliques:
+    """ Clique counting algorithm.
+
+    Parameters
+    ----------
+    k : int
+        Clique order (e.g., k = 3 means triangles).
+
+    Attributes
+    ----------
+    n_cliques_ : int
+        Number of cliques.
+
+    Example
+    -------
+    >>> from sknetwork.data import karate_club
+    >>> cliques = Cliques(k=3)
+    >>> adjacency = karate_club()
+    >>> cliques.fit_transform(adjacency)
+    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).
+    """
+    def __init__(self, k: int):
+        self.k = np.int32(k)
+        self.n_cliques_ = 0
+
+    def fit(self, adjacency: sparse.csr_matrix) -> 'Cliques':
+        """K-cliques count.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph.
+
+        Returns
+        -------
+         self: :class:`Cliques`
+        """
+        if self.k < 2:
+            raise ValueError("k should be at least 2")
+
+        kcore = CoreDecomposition()
+        labels = kcore.fit_transform(adjacency)
+        sorted_nodes = np.argsort(labels)
+
+        dag = DAG()
+        dag.fit(adjacency, sorted_nodes)
+        indptr = dag.indptr_
+        indices = dag.indices_
+
+        box = ListingBox.__new__(ListingBox, indptr, self.k)
+        self.n_cliques_ = fit_core(indptr, indices, self.k, box)
+
+        return self
+
+    def fit_transform(self, adjacency: sparse.csr_matrix) -> int:
+        """ Fit algorithm to the data and return the number of cliques. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        n_cliques : int
+            Number of k-cliques.
+        """
+        self.fit(adjacency)
+        return self.n_cliques_
+
+