scikit-network 0.33.3__cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

sknetwork/hierarchy/tests/test_algos.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2020
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.hierarchy import LouvainIteration, LouvainHierarchy, Paris
+
+
+class TestLouvainHierarchy(unittest.TestCase):
+
+    def test(self):
+        louvain_iteration = LouvainIteration()
+        louvain_iteration_ = LouvainIteration(resolution=2, depth=1)
+        louvain_hierarchy = LouvainHierarchy()
+        louvain_hierarchy_ = LouvainHierarchy(tol_aggregation=0.1)
+        paris = Paris()
+        paris_ = Paris(weights='uniform', reorder=False)
+        for algo in [louvain_iteration, louvain_iteration_, louvain_hierarchy, louvain_hierarchy_, paris, paris_]:
+            for input_matrix in [test_graph(), test_digraph(), test_bigraph()]:
+                dendrogram = algo.fit_predict(input_matrix)
+                self.assertEqual(dendrogram.shape, (input_matrix.shape[0] - 1, 4))
+                if algo.bipartite:
+                    self.assertEqual(algo.dendrogram_full_.shape, (sum(input_matrix.shape) - 1, 4))
+        adjacency = test_graph()
+        algo = Paris()
+        dendrogram = algo.fit_predict(adjacency)
+        dendrogram_ = algo.predict()
+        self.assertAlmostEqual(np.linalg.norm(dendrogram - dendrogram_), 0)

sknetwork/hierarchy/tests/test_metrics.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on March 2019
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.data import cyclic_graph
+from sknetwork.hierarchy import Paris, LouvainIteration, dasgupta_cost, dasgupta_score, tree_sampling_divergence
+
+
+# noinspection PyMissingOrEmptyDocstring
+class TestMetrics(unittest.TestCase):
+
+    def setUp(self):
+        self.paris = Paris()
+        self.louvain_iteration = LouvainIteration()
+
+    def test_undirected(self):
+        adjacency = cyclic_graph(3)
+        dendrogram = self.paris.fit_predict(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 2.666, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.111, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.0632, 3)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, normalized=False), 0.0256, 3)
+        adjacency = test_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 4.26, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.573, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.304, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_cost(adjacency, dendrogram), 4.43, 2)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.555, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.286, 2)
+
+    def test_directed(self):
+        adjacency = test_digraph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.566, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.318, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.55, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.313, 2)
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.682, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.464, 2)
+        dendrogram = self.louvain_iteration.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram), 0.670, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram), 0.594, 2)
+
+    def test_options(self):
+        adjacency = test_graph()
+        dendrogram = self.paris.fit_transform(adjacency)
+        self.assertAlmostEqual(dasgupta_score(adjacency, dendrogram, weights='degree'), 0.573, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, weights='uniform'), 0.271, 2)
+        self.assertAlmostEqual(tree_sampling_divergence(adjacency, dendrogram, normalized=False), 0.367, 2)

sknetwork/hierarchy/tests/test_postprocess.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on March 2019
+@author: Thomas Bonald <bonald@enst.fr>
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+
+import unittest
+
+from sknetwork.data import karate_club
+from sknetwork.hierarchy import Paris, cut_straight, cut_balanced, aggregate_dendrogram
+
+
+# noinspection PyMissingOrEmptyDocstring
+class TestCuts(unittest.TestCase):
+
+    def setUp(self):
+        paris = Paris()
+        self.adjacency = karate_club()
+        self.dendrogram = paris.fit_transform(self.adjacency)
+
+    def test_cuts(self):
+        labels = cut_straight(self.dendrogram)
+        self.assertEqual(len(set(labels)), 2)
+        labels = cut_straight(self.dendrogram, n_clusters=5)
+        self.assertEqual(len(set(labels)), 5)
+        labels = cut_balanced(self.dendrogram, 2)
+        self.assertEqual(len(set(labels)), 21)
+        labels, new_dendrogram = cut_balanced(self.dendrogram, max_cluster_size=4, return_dendrogram=True)
+        self.assertEqual(len(set(labels)), 12)
+        self.assertTupleEqual(new_dendrogram.shape, (11, 4))
+        paris = Paris(reorder=False)
+        dendrogram = paris.fit_predict(self.adjacency)
+        labels = cut_balanced(dendrogram, 4)
+        self.assertEqual(len(set(labels)), 12)
+
+    def test_options(self):
+        labels = cut_straight(self.dendrogram, threshold=0.5)
+        self.assertEqual(len(set(labels)), 7)
+        labels = cut_straight(self.dendrogram, n_clusters=3, threshold=0.5)
+        self.assertEqual(len(set(labels)), 3)
+        labels = cut_straight(self.dendrogram, sort_clusters=False)
+        self.assertEqual(len(set(labels)), 2)
+        labels = cut_balanced(self.dendrogram, max_cluster_size=2, sort_clusters=False)
+        self.assertEqual(len(set(labels)), 21)
+        labels = cut_balanced(self.dendrogram, max_cluster_size=10)
+        self.assertEqual(len(set(labels)), 5)
+
+    def test_aggregation(self):
+        aggregated = aggregate_dendrogram(self.dendrogram, n_clusters=3)
+        self.assertEqual(len(aggregated), 2)
+
+        aggregated, counts = aggregate_dendrogram(self.dendrogram, n_clusters=3, return_counts=True)
+        self.assertEqual(len(aggregated), 2)
+        self.assertEqual(len(counts), 3)
+

sknetwork/linalg/__init__.py

@@ -0,0 +1,9 @@
+"""Module of linear algebra."""
+from sknetwork.linalg.basics import safe_sparse_dot
+from sknetwork.linalg.eig_solver import EigSolver, LanczosEig
+from sknetwork.linalg.laplacian import get_laplacian
+from sknetwork.linalg.normalizer import diagonal_pseudo_inverse, get_norms, normalize
+from sknetwork.linalg.operators import Regularizer, Laplacian, Normalizer, CoNeighbor
+from sknetwork.linalg.polynome import Polynome
+from sknetwork.linalg.sparse_lowrank import SparseLR
+from sknetwork.linalg.svd_solver import SVDSolver, LanczosSVD

sknetwork/linalg/basics.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+
+def safe_sparse_dot(a, b):
+    """Dot product with proper use of the sparse matrix format.
+    Use BLAS instead of numpy.dot when possible to avoid unnecessary copies.
+
+    Parameters
+    ----------
+    a : array, sparse matrix or LinearOperator
+    b : array, sparse matrix or LinearOperator
+    Returns
+    -------
+    dot_product : array or sparse matrix
+        sparse if ``a`` or ``b`` is sparse.
+    """
+    if type(a) == np.ndarray:
+        return b.T.dot(a.T).T
+    if isinstance(a, LinearOperator) and isinstance(b, LinearOperator):
+        raise NotImplementedError
+    if hasattr(a, 'right_sparse_dot') and type(b) == sparse.csr_matrix:
+        if callable(a.right_sparse_dot):
+            return a.right_sparse_dot(b)
+    if hasattr(b, 'left_sparse_dot') and type(a) == sparse.csr_matrix:
+        if callable(b.left_sparse_dot):
+            return b.left_sparse_dot(a)
+    else:
+        return a.dot(b)