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

sknetwork/{utils → topology}/minheap.pxd

@@ -1,9 +1,7 @@
 # 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>
 """

sknetwork/{utils → topology}/minheap.pyx

@@ -1,9 +1,7 @@
 # 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>
 """

sknetwork/topology/structure.py

@@ -1,18 +1,19 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on July 24, 2019
+Created in July 2019
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 @author: Quentin Lutz <qlutz@enst.fr>
 @author: Thomas Bonald <tbonald@enst.fr>
 """
-from typing import Tuple, Optional, Union
+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 get_connected_components(input_matrix: sparse.csr_matrix, connection: str = 'weak', force_bipartite: bool = False) \
@@ -191,44 +192,3 @@ def is_bipartite(adjacency: sparse.csr_matrix, return_biadjacency: bool = False)
         return True
 
 
-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

sknetwork/topology/tests/test_cliques.py

@@ -1,28 +1,28 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Tests for k-cliques count"""
+"""Tests for cliques"""
 import unittest
 
 from scipy.special import comb
 
 from sknetwork.data.test_graphs import *
-from sknetwork.topology import Cliques
+from sknetwork.topology.cliques import count_cliques
 
 
-class TestCliqueListing(unittest.TestCase):
+class TestClique(unittest.TestCase):
 
     def test_empty(self):
         adjacency = test_graph_empty()
-        self.assertEqual(Cliques(2).fit_transform(adjacency), 0)
-        cliques = Cliques(1)
-        self.assertRaises(ValueError, cliques.fit_transform, adjacency)
+        self.assertEqual(count_cliques(adjacency), 0)
+        with self.assertRaises(ValueError):
+            count_cliques(adjacency, 1)
 
     def test_disconnected(self):
-        adjacency = test_graph_disconnect()
-        self.assertEqual(Cliques(3).fit_transform(adjacency), 1)
+        adjacency = test_disconnected_graph()
+        self.assertEqual(count_cliques(adjacency), 1)
 
     def test_cliques(self):
-        adjacency = test_graph_clique()
+        adjacency = test_clique()
         n = adjacency.shape[0]
-        self.assertEqual(Cliques(3).fit_transform(adjacency), comb(n, 3, exact=True))
-        self.assertEqual(Cliques(4).fit_transform(adjacency), comb(n, 4, exact=True))
+        self.assertEqual(count_cliques(adjacency), comb(n, 3, exact=True))
+        self.assertEqual(count_cliques(adjacency, 4), comb(n, 4, exact=True))

sknetwork/topology/tests/test_core.py

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

sknetwork/topology/tests/test_cycles.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for cycles.py"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
+from sknetwork.topology import is_connected, is_acyclic, get_cycles, break_cycles
+from sknetwork.utils.format import bipartite2undirected, directed2undirected
+
+
+class TestCycle(unittest.TestCase):
+
+    def test_is_acyclic(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        self.assertFalse(is_acyclic(adjacency_with_self_loops))
+        self.assertFalse(is_acyclic(adjacency_with_self_loops, directed=True))
+        directed_cycle = cyclic_digraph(3)
+        self.assertFalse(is_acyclic(directed_cycle))
+        with self.assertRaises(ValueError):
+            is_acyclic(directed_cycle, directed=False)
+        undirected_line = linear_graph(2)
+        self.assertTrue(is_acyclic(undirected_line))
+        self.assertFalse(is_acyclic(undirected_line, directed=True))
+        acyclic_graph = linear_digraph(2)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+    def test_get_cycles(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        node_cycles = get_cycles(adjacency_with_self_loops, directed=True)
+        self.assertEqual(node_cycles, [[0], [1]])
+
+        cycle_adjacency = cyclic_digraph(4)
+        node_cycles = get_cycles(cycle_adjacency, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [3])), shape=cycle_adjacency.shape)
+        node_cycles = get_cycles(adjacency_with_subcycles, directed=True)
+        self.assertEqual(node_cycles, [[0, 1, 3], [0, 1, 2, 3]])
+
+        undirected_cycle = cyclic_graph(4)
+        node_cycles = get_cycles(undirected_cycle, directed=False)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1], ([1, 2, 3], [2, 3, 1])), shape=(4, 4))
+        node_cycles = get_cycles(disconnected_cycles, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [1, 2, 3])
+
+    def test_break_cycles(self):
+        cycle_adjacency = cyclic_digraph(4)
+        acyclic_graph = break_cycles(cycle_adjacency, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [0])), shape=cycle_adjacency.shape)
+        acyclic_graph = break_cycles(adjacency_with_subcycles, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        undirected_cycle = house(metadata=False)
+        acyclic_graph = break_cycles(undirected_cycle, root=0, directed=False)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1, 1, 1], ([0, 1, 2, 3, 4], [1, 0, 3, 4, 2])), shape=(5, 5))
+        self.assertFalse(is_connected(disconnected_cycles))
+        acyclic_graph = break_cycles(disconnected_cycles, root=[0, 2], directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))

sknetwork/topology/tests/test_structure.py

@@ -6,9 +6,9 @@ import unittest
 import numpy as np
 from scipy import sparse
 
-from sknetwork.data import star_wars, cyclic_digraph, linear_digraph, linear_graph
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
 from sknetwork.topology import get_connected_components, get_largest_connected_component
-from sknetwork.topology import is_connected, is_bipartite, is_acyclic
+from sknetwork.topology import is_connected, is_bipartite
 from sknetwork.utils.format import bipartite2undirected, directed2undirected
 
 
@@ -83,17 +83,3 @@ class TestStructure(unittest.TestCase):
         adjacency = directed2undirected(cyclic_digraph(3))
         bipartite = is_bipartite(adjacency, return_biadjacency=False)
         self.assertEqual(bipartite, False)
-
-    def test_is_acyclic(self):
-        adjacency_with_self_loops = sparse.identity(2, format='csr')
-        self.assertFalse(is_acyclic(adjacency_with_self_loops))
-        self.assertFalse(is_acyclic(adjacency_with_self_loops, directed=True))
-        directed_cycle = cyclic_digraph(3)
-        self.assertFalse(is_acyclic(directed_cycle))
-        with self.assertRaises(ValueError):
-            is_acyclic(directed_cycle, directed=False)
-        undirected_line = linear_graph(2)
-        self.assertTrue(is_acyclic(undirected_line))
-        self.assertFalse(is_acyclic(undirected_line, directed=True))
-        acyclic_graph = linear_digraph(2)
-        self.assertTrue(is_acyclic(acyclic_graph))

sknetwork/topology/tests/test_triangles.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Tests for label propagation"""
+"""Tests for triangle counting"""
 
 import unittest
 
@@ -9,34 +9,30 @@ from scipy.special import comb
 from sknetwork.data import karate_club
 from sknetwork.data.parse import from_edge_list
 from sknetwork.data.test_graphs import *
-from sknetwork.topology import Triangles
+from sknetwork.topology.triangles import count_triangles, get_clustering_coefficient
 
 
-class TestTriangleListing(unittest.TestCase):
+class TestTriangle(unittest.TestCase):
 
     def test_empty(self):
         adjacency = test_graph_empty()
-        self.assertEqual(Triangles().fit_transform(adjacency), 0)
+        self.assertEqual(count_triangles(adjacency), 0)
 
     def test_disconnected(self):
-        adjacency = test_graph_disconnect()
-        self.assertEqual(Triangles().fit_transform(adjacency), 1)
+        adjacency = test_disconnected_graph()
+        self.assertEqual(count_triangles(adjacency), 1)
 
     def test_cliques(self):
-        adjacency = test_graph_clique()
+        adjacency = test_clique()
         n = adjacency.shape[0]
-        nb = Triangles().fit_transform(adjacency)
-        self.assertEqual(nb, comb(n, 3, exact=True))
+        self.assertEqual(count_triangles(adjacency), comb(n, 3, exact=True))
 
     def test_clustering_coefficient(self):
         edges = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]
         adjacency = from_edge_list(edges, directed=False, matrix_only=True)
-
-        triangles = Triangles().fit(adjacency)
-        self.assertEqual(0.75, triangles.clustering_coef_)
+        self.assertEqual(0.75, get_clustering_coefficient(adjacency))
 
     def test_options(self):
         adjacency = karate_club()
-
-        self.assertEqual(Triangles(parallelize=False).fit_transform(adjacency), 45)
-        self.assertEqual(Triangles(parallelize=True).fit_transform(adjacency), 45)
+        self.assertEqual(count_triangles(adjacency, parallelize=False), 45)
+        self.assertEqual(count_triangles(adjacency, parallelize=True), 45)

sknetwork/topology/tests/test_wl.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Weisfeiler-Lehman"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, bow_tie, linear_graph
+from sknetwork.data.test_graphs import *
+from sknetwork.topology import color_weisfeiler_lehman, 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))
+
+
+class TestWLColoring(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_cliques(self):
+        adjacency = test_clique()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_house(self):
+        adjacency = house()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.array([0, 2, 1, 1, 2])).all())
+
+    def test_bow_tie(self):
+        adjacency = bow_tie()
+        labels = color_weisfeiler_lehman(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 = color_weisfeiler_lehman(adjacency)
+        l2 = color_weisfeiler_lehman(adjacency2)
+        l1.sort()
+        l2.sort()
+        self.assertTrue((l1 == l2).all())
+
+    def test_early_stop(self):
+        adjacency = house()
+        labels = color_weisfeiler_lehman(adjacency, max_iter=1)
+        self.assertTrue((labels == np.array([0, 1, 0, 0, 1])).all())