scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/topology/dag_core.pyx

@@ -1,38 +0,0 @@
-# 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

@@ -1,193 +0,0 @@
-# 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_
-
-

sknetwork/topology/kcore.pyx

@@ -1,120 +0,0 @@
-# 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>
-"""
-cimport cython
-
-import numpy as np
-cimport numpy as np
-
-from scipy import sparse
-
-from sknetwork.utils.base import Algorithm
-from sknetwork.utils.minheap cimport MinHeap
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef fit_core(int[:] indptr, int[:] indices):
-    """Compute the core value of each node.
-
-    Parameters
-    ----------
-    indptr :
-        CSR format index array of the normalized adjacency matrix.
-    indices :
-        CSR format index pointer array of the normalized 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
-
-    # inserts all nodes in the heap
-    for i in range(n):
-        mh.insert_key(i, degrees)
-
-    i = n - 1		# index of the rear of the list/array
-    while not mh.empty():		# until the heap is emptied
-        min_node = mh.pop_min(degrees)
-        core_value = max(core_value, degrees[min_node])
-
-        # decreases the degree of each neighbors of min_node to simulate its deletion
-        for k in range(indptr[min_node], indptr[min_node+1]):
-            j = indices[k]
-            degrees[j] -= 1
-            mh.decrease_key(j, degrees)		# updates the heap to take into account the new degrees
-
-        labels[min_node] = core_value
-        i -= 1
-
-    return np.asarray(labels)
-
-
-class CoreDecomposition(Algorithm):
-    """K-core decomposition algorithm.
-
-    * Graphs
-
-    Attributes
-    ----------
-    labels_ : np.ndarray
-        Core value of each node.
-    core_value_ : int
-        Maximum core value of the graph
-
-    Example
-    -------
-    >>> from sknetwork.topology import CoreDecomposition
-    >>> from sknetwork.data import karate_club
-    >>> kcore = CoreDecomposition()
-    >>> adjacency = karate_club()
-    >>> kcore.fit(adjacency)
-    >>> kcore.core_value_
-    4
-    """
-    def __init__(self):
-        super(CoreDecomposition, self).__init__()
-        self.labels_ = None
-        self.core_value_ = None
-
-    def fit(self, adjacency: sparse.csr_matrix) -> 'CoreDecomposition':
-        """K-core decomposition.
-
-        Parameters
-        ----------
-        adjacency :
-            Adjacency matrix of the graph.
-
-        Returns
-        -------
-         self: :class:`CoreDecomposition`
-        """
-        labels = fit_core(adjacency.indptr, adjacency.indices)
-        self.labels_ = labels
-        self.core_value_ = labels.max()
-        return self
-
-    def fit_transform(self, adjacency: sparse.csr_matrix):
-        """Fit algorithm to the data and return the core value of each node. Same parameters as the ``fit`` method.
-
-        Returns
-        -------
-        labels :
-            Core value of the nodes.
-        """
-        self.fit(adjacency)
-        return self.labels_

sknetwork/topology/tests/test_cores.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Tests for k-core decimposition"""
-import unittest
-
-from sknetwork.data.test_graphs import *
-from sknetwork.topology import CoreDecomposition
-
-
-class TestCoreDecomposition(unittest.TestCase):
-
-    def test_empty(self):
-        adjacency = test_graph_empty()
-        kcore = CoreDecomposition().fit(adjacency)
-        self.assertEqual(kcore.core_value_, 0)
-
-    def test_cliques(self):
-        adjacency = test_graph_clique()
-        n = adjacency.shape[0]
-        kcore = CoreDecomposition().fit(adjacency)
-        self.assertEqual(kcore.core_value_, n - 1)

sknetwork/topology/tests/test_dag.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-""""tests for dag.py"""
-import unittest
-
-import numpy as np
-
-from sknetwork.data import house
-from sknetwork.topology import DAG
-
-
-class TestDAG(unittest.TestCase):
-
-    def test_options(self):
-        adjacency = house()
-        dag = DAG()
-        dag.fit(adjacency)
-        self.assertEqual(dag.indptr_.shape[0], adjacency.shape[0]+1)
-        self.assertEqual(dag.indices_.shape[0], 6)
-
-        with self.assertRaises(ValueError):
-            dag.fit(adjacency, sorted_nodes=np.arange(3))
-
-        with self.assertRaises(ValueError):
-            dag = DAG(ordering='toto')
-            dag.fit(adjacency)

sknetwork/topology/tests/test_wl_coloring.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Tests for Weisfeiler-Lehman coloring"""
-import unittest
-
-from sknetwork.data import house, bow_tie
-from sknetwork.data.test_graphs import *
-from sknetwork.topology import WeisfeilerLehman
-
-
-class TestWLColoring(unittest.TestCase):
-
-    def test_empty(self):
-        adjacency = test_graph_empty()
-        labels = WeisfeilerLehman().fit_transform(adjacency)
-        self.assertTrue((labels == np.zeros(10)).all())
-
-    def test_cliques(self):
-        adjacency = test_graph_clique()
-        labels = WeisfeilerLehman().fit_transform(adjacency)
-        self.assertTrue((labels == np.zeros(10)).all())
-
-    def test_house(self):
-        adjacency = house()
-        labels = WeisfeilerLehman().fit_transform(adjacency)
-        self.assertTrue((labels == np.array([0, 2, 1, 1, 2])).all())
-
-    def test_bow_tie(self):
-        adjacency = bow_tie()
-        labels = WeisfeilerLehman().fit_transform(adjacency)
-        self.assertTrue((labels == np.array([1, 0, 0, 0, 0])).all())
-
-    def test_iso(self):
-        adjacency = house()
-        n = adjacency.indptr.shape[0] - 1
-        reorder = list(range(n))
-        np.random.shuffle(reorder)
-        adjacency2 = adjacency[reorder][:, reorder]
-        l1 = WeisfeilerLehman().fit_transform(adjacency)
-        l2 = WeisfeilerLehman().fit_transform(adjacency2)
-        l1.sort()
-        l2.sort()
-        self.assertTrue((l1 == l2).all())
-
-    def test_early_stop(self):
-        adjacency = house()
-        wl = WeisfeilerLehman(max_iter=1)
-        labels = wl.fit_transform(adjacency)
-        self.assertTrue((labels == np.array([0, 1, 0, 0, 1])).all())

sknetwork/topology/tests/test_wl_kernel.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Tests for Weisfeiler-Lehman kernels"""
-import unittest
-
-import numpy as np
-
-from sknetwork.data import house, bow_tie, linear_graph
-from sknetwork.topology import are_isomorphic
-
-
-class TestWLKernel(unittest.TestCase):
-
-    def test_isomorphism(self):
-        ref = house()
-        n = ref.shape[0]
-
-        adjacency = house()
-        reorder = list(range(n))
-        np.random.shuffle(reorder)
-        adjacency = adjacency[reorder][:, reorder]
-        self.assertTrue(are_isomorphic(ref, adjacency))
-
-        adjacency = bow_tie()
-        self.assertFalse(are_isomorphic(ref, adjacency))
-
-        adjacency = linear_graph(n)
-        self.assertFalse(are_isomorphic(ref, adjacency))
-
-        adjacency = linear_graph(n + 1)
-        self.assertFalse(are_isomorphic(ref, adjacency))

sknetwork/utils/base.py

@@ -1,35 +0,0 @@
-#!/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 data."""
-        raise NotImplementedError

sknetwork/utils/simplex.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on June 4 2019
-@author: Nathan de Lara <nathan.delara@polytechnique.org>
-"""
-from typing import Union
-
-import numpy as np
-from scipy import sparse
-
-from sknetwork.linalg.normalization import normalize
-
-
-def projection_simplex_array(array: np.ndarray, scale: float = 1) -> np.ndarray:
-    """Project each line of the input onto the Euclidean simplex i.e. solve
-
-    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
-
-    Parameters
-    ----------
-    array: np.ndarray
-        Data to project. Either one or two dimensional.
-    scale: float
-        Scale of the simplex i.e. sums of the projected coefficients.
-
-    Returns
-    -------
-    projection : np.ndarray
-        Array with the same shape as the input.
-
-    Example
-    -------
-    >>> X = np.array([[2, 2], [-0.75, 0.25]])
-    >>> projection_simplex_array(X)
-    array([[0.5, 0.5],
-           [0. , 1. ]])
-    """
-    if len(array.shape) == 1:
-        array = array.reshape(1, array.shape[0])
-    n_row, n_col = array.shape
-
-    sorted_array = -np.sort(-array)
-    cumsum_array = np.cumsum(sorted_array, axis=1) - scale
-    denom = 1 + np.arange(n_col)
-    condition = sorted_array - cumsum_array / denom > 0
-    max_index = np.argmax(condition / denom[::-1], axis=1)
-    threshold = (cumsum_array / denom)[np.arange(n_row), max_index]
-
-    return np.maximum(array - threshold[:, np.newaxis], 0)
-
-
-def projection_simplex_csr(matrix: sparse.csr_matrix, scale: float = 1):
-    """Project each line of the input onto the Euclidean simplex i.e. solve
-
-    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
-
-    Parameters
-    ----------
-    matrix : sparse.csr_matrix
-        Matrix whose rows must be projected.
-    scale: float
-        Scale of the simplex i.e. sums of the projected coefficients.
-
-    Returns
-    -------
-    projection : sparse.csr_matrix
-        Matrix with the same shape as the input.
-
-    Examples
-    --------
-    >>> X = sparse.csr_matrix(np.array([[2, 2], [-0.75, 0.25]]))
-    >>> X_proj = projection_simplex_csr(X)
-    >>> X_proj.nnz
-    3
-    >>> X_proj.toarray()
-    array([[0.5, 0.5],
-           [0. , 1. ]])
-    """
-    data = matrix.data
-    if data.dtype == bool or (data.min() == data.max()):
-        return normalize(matrix, p=1)
-
-    indptr = matrix.indptr
-    new_data = np.zeros_like(data)
-
-    for i in range(indptr.size-1):
-        j1 = indptr[i]
-        j2 = indptr[i+1]
-        new_data[j1:j2] = projection_simplex_array(data[j1:j2], scale=scale)
-
-    new_matrix = sparse.csr_matrix((new_data, matrix.indices, indptr), shape=matrix.shape)
-    new_matrix.eliminate_zeros()
-    return new_matrix
-
-
-def projection_simplex(x: Union[np.ndarray, sparse.csr_matrix], scale: float = 1.):
-    """Project each line of the input onto the Euclidean simplex i.e. solve
-
-    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
-
-    Parameters
-    ----------
-    x :
-        Data to project. Either one or two dimensional. Can be sparse or dense.
-    scale : float
-        Scale of the simplex i.e. sums of the projected coefficients.
-
-    Returns
-    -------
-    projection : np.ndarray or sparse.csr_matrix
-        Array with the same type and shape as the input.
-
-    Example
-    -------
-    >>> X = np.array([[2, 2], [-0.75, 0.25]])
-    >>> projection_simplex(X)
-    array([[0.5, 0.5],
-           [0. , 1. ]])
-    >>> X_csr = sparse.csr_matrix(X)
-    >>> X_proj = projection_simplex(X_csr)
-    >>> X_proj.nnz
-    3
-    >>> X_proj.toarray()
-    array([[0.5, 0.5],
-           [0. , 1. ]])
-
-    References
-    ----------
-    Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008, July).
-    `Efficient projections onto the l 1-ball for learning in high dimensions.
-    <http://machinelearning.org/archive/icml2008/papers/361.pdf>`_
-    In Proceedings of the 25th international conference on Machine learning (pp. 272-279). ACM.
-    """
-    if isinstance(x, np.ndarray):
-        return projection_simplex_array(x, scale)
-    elif isinstance(x, sparse.csr_matrix):
-        return projection_simplex_csr(x, scale)
-    else:
-        raise TypeError('Input must be a numpy array or a CSR matrix.')

sknetwork/utils/tests/test_base.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""tests for base.py"""
-import unittest
-
-from sknetwork.utils.base import Algorithm
-
-
-class TestBase(unittest.TestCase):
-
-    def test_repr(self):
-        class Stub(Algorithm):
-            """Docstring"""
-            def __init__(self, some_param: int, another_param: str, random_state: int, some_unused_param: int):
-                self.some_param = some_param
-                self.another_param = another_param
-                self.random_state = random_state
-
-            def fit(self):
-                """Docstring"""
-                pass
-
-        stub = Stub(1, 'abc', 3, 4)
-        self.assertEqual(repr(stub), "Stub(some_param=1, another_param='abc')")
-
-    def test_fit(self):
-        stub = Algorithm()
-        self.assertRaises(NotImplementedError, stub.fit, None)