scikit-network 0.31.0__cp310-cp310-win_amd64.whl → 0.32.1__cp310-cp310-win_amd64.whl

sknetwork/visualization/tests/test_graphs.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""tests for visualization/graphs.py"""
+"""tests for visualization of graphs"""
 
 import tempfile
 import unittest
@@ -10,7 +10,7 @@ from scipy import sparse
 
 from sknetwork.data.test_graphs import test_disconnected_graph, test_bigraph_disconnect
 from sknetwork.data.toy_graphs import karate_club, painters, movie_actor, bow_tie, star_wars
-from sknetwork.visualization.graphs import svg_graph, svg_bigraph, svg_text, rescale
+from sknetwork.visualization.graphs import visualize_graph, visualize_bigraph, svg_graph, svg_bigraph, svg_text, rescale
 
 
 # noinspection DuplicatedCode
@@ -21,74 +21,77 @@ class TestVisualization(unittest.TestCase):
         adjacency = graph.adjacency
         position = graph.position
         labels = graph.labels
+        image = visualize_graph(adjacency, position, labels=labels)
+        self.assertEqual(image[1:4], 'svg')
+        # alias
         image = svg_graph(adjacency, position, labels=labels)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, labels=list(labels))
+        image = visualize_graph(adjacency, position, labels=list(labels))
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, display_edges=False)
+        image = visualize_graph(adjacency, position, display_edges=False)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, height=None)
+        image = visualize_graph(adjacency, position, height=None)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, height=300, width=None)
+        image = visualize_graph(adjacency, position, height=300, width=None)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, height=None, width=200)
+        image = visualize_graph(adjacency, position, height=None, width=200)
         self.assertEqual(image[1:4], 'svg')
         n = adjacency.shape[0]
         edge_labels = [(0, 1, 0), (1, 1, 1), (3, 10, 2)]
-        image = svg_graph(adjacency, position=None, names=np.arange(n), labels=np.arange(n), scores=np.arange(n),
-                          seeds=[0, 1], width=200, height=200, margin=10, margin_text=5, scale=3,
-                          node_order=np.flip(np.arange(n)),
-                          node_size=5, node_size_min=2, node_size_max=6, display_node_weight=True,
-                          node_weights=np.arange(n),
-                          node_width=2, node_width_max=5, node_color='red', edge_width=2, edge_width_min=2,
-                          edge_width_max=4, edge_color='blue', edge_labels=edge_labels, display_edge_weight=True,
-                          font_size=14)
+        image = visualize_graph(adjacency, position=None, names=np.arange(n), labels=np.arange(n), scores=np.arange(n),
+                                seeds=[0, 1], width=200, height=200, margin=10, margin_text=5, scale=3,
+                                node_order=np.flip(np.arange(n)),
+                                node_size=5, node_size_min=2, node_size_max=6, display_node_weight=True,
+                                node_weights=np.arange(n),
+                                node_width=2, node_width_max=5, node_color='red', edge_width=2, edge_width_min=2,
+                                edge_width_max=4, edge_color='blue', edge_labels=edge_labels, display_edge_weight=True,
+                                font_size=14)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position=None, labels={0: 0})
+        image = visualize_graph(adjacency, position=None, labels={0: 0})
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position=None, scores={0: 0})
+        image = visualize_graph(adjacency, position=None, scores={0: 0})
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency=None, position=position)
+        image = visualize_graph(adjacency=None, position=position)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency=None, position=position, edge_labels=edge_labels)
+        image = visualize_graph(adjacency=None, position=position, edge_labels=edge_labels)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, labels, label_colors={0: "red", 1: "blue"})
+        image = visualize_graph(adjacency, position, labels, label_colors={0: "red", 1: "blue"})
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, labels, label_colors=["red", "blue"])
+        image = visualize_graph(adjacency, position, labels, label_colors=["red", "blue"])
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, labels, node_weights=np.arange(adjacency.shape[0]))
+        image = visualize_graph(adjacency, position, labels, node_weights=np.arange(adjacency.shape[0]))
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, scores=list(np.arange(n)))
+        image = visualize_graph(adjacency, position, scores=list(np.arange(n)))
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, seeds={0: 1, 2: 1})
+        image = visualize_graph(adjacency, position, seeds={0: 1, 2: 1})
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, labels=np.arange(n), name_position='left')
+        image = visualize_graph(adjacency, position, labels=np.arange(n), name_position='left')
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, scale=2, labels=np.arange(n), name_position='left')
+        image = visualize_graph(adjacency, position, scale=2, labels=np.arange(n), name_position='left')
         self.assertEqual(image[1:4], 'svg')
         with self.assertRaises(ValueError):
-            svg_graph(adjacency, position, labels=[0, 1])
+            visualize_graph(adjacency, position, labels=[0, 1])
         with self.assertRaises(ValueError):
-            svg_graph(adjacency, position, scores=[0, 1])
-        svg_graph(adjacency, position, scale=2, labels=np.arange(n), name_position='left')
+            visualize_graph(adjacency, position, scores=[0, 1])
+        visualize_graph(adjacency, position, scale=2, labels=np.arange(n), name_position='left')
 
     def test_directed(self):
         graph = painters(True)
         adjacency = graph.adjacency
         position = graph.position
         names = graph.names
-        image = svg_graph(adjacency, position, names=names)
+        image = visualize_graph(adjacency, position, names=names)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_graph(adjacency, position, display_edges=False)
+        image = visualize_graph(adjacency, position, display_edges=False)
         self.assertEqual(image[1:4], 'svg')
         n = adjacency.shape[0]
-        image = svg_graph(adjacency, position=None, names=np.arange(n), labels=np.arange(n), scores=np.arange(n),
-                          name_position='below', seeds=[0, 1], width=200, height=200, margin=10, margin_text=5,
-                          scale=3, node_order=np.flip(np.arange(n)),
-                          node_size=5, node_size_min=2, node_size_max=6, display_node_weight=True,
-                          node_weights=np.arange(n),
-                          node_width=2, node_width_max=5, node_color='red', edge_width=2, edge_width_min=2,
-                          edge_width_max=4, edge_color='blue', display_edge_weight=True, font_size=14)
+        image = visualize_graph(adjacency, position=None, names=np.arange(n), labels=np.arange(n), scores=np.arange(n),
+                                name_position='below', seeds=[0, 1], width=200, height=200, margin=10, margin_text=5,
+                                scale=3, node_order=np.flip(np.arange(n)),
+                                node_size=5, node_size_min=2, node_size_max=6, display_node_weight=True,
+                                node_weights=np.arange(n),
+                                node_width=2, node_width_max=5, node_color='red', edge_width=2, edge_width_min=2,
+                                edge_width_max=4, edge_color='blue', display_edge_weight=True, font_size=14)
         self.assertEqual(image[1:4], 'svg')
 
     def test_bipartite(self):
@@ -96,54 +99,57 @@ class TestVisualization(unittest.TestCase):
         biadjacency = graph.biadjacency
         names_row = graph.names_row
         names_col = graph.names_col
+        image = visualize_bigraph(biadjacency, names_row, names_col)
+        self.assertEqual(image[1:4], 'svg')
+        # alias
         image = svg_bigraph(biadjacency, names_row, names_col)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_bigraph(biadjacency, display_edges=False)
+        image = visualize_bigraph(biadjacency, display_edges=False)
         self.assertEqual(image[1:4], 'svg')
-        image = svg_bigraph(biadjacency, reorder=False)
+        image = visualize_bigraph(biadjacency, reorder=False)
         self.assertEqual(image[1:4], 'svg')
         n_row, n_col = biadjacency.shape
         position_row = np.random.random((n_row, 2))
         position_col = np.random.random((n_col, 2))
         edge_labels = [(0, 1, 0), (1, 1, 1), (3, 10, 2)]
-        image = svg_bigraph(biadjacency=biadjacency, names_row=np.arange(n_row), names_col=np.arange(n_col),
-                            labels_row=np.arange(n_row), labels_col=np.arange(n_col), scores_row=np.arange(n_row),
-                            scores_col=np.arange(n_col), seeds_row=[0, 1], seeds_col=[1, 2],
-                            position_row=position_row, position_col=position_col, color_row='red', color_col='white',
-                            width=200, height=200, margin=10, margin_text=5, scale=3, node_size=5,
-                            node_size_min=1, node_size_max=30, node_weights_row=np.arange(n_row),
-                            node_weights_col=np.arange(n_col), display_node_weight=True, node_width=2, node_width_max=5,
-                            edge_labels=edge_labels, edge_width=2, edge_width_min=0.3, edge_width_max=4,
-                            edge_color='red', display_edge_weight=True, font_size=14)
+        image = visualize_bigraph(biadjacency=biadjacency, names_row=np.arange(n_row), names_col=np.arange(n_col),
+                                  labels_row=np.arange(n_row), labels_col=np.arange(n_col), scores_row=np.arange(n_row),
+                                  scores_col=np.arange(n_col), seeds_row=[0, 1], seeds_col=[1, 2],
+                                  position_row=position_row, position_col=position_col, color_row='red', color_col='white',
+                                  width=200, height=200, margin=10, margin_text=5, scale=3, node_size=5,
+                                  node_size_min=1, node_size_max=30, node_weights_row=np.arange(n_row),
+                                  node_weights_col=np.arange(n_col), display_node_weight=True, node_width=2, node_width_max=5,
+                                  edge_labels=edge_labels, edge_width=2, edge_width_min=0.3, edge_width_max=4,
+                                  edge_color='red', display_edge_weight=True, font_size=14)
         self.assertEqual(image[1:4], 'svg')
 
     def test_disconnect(self):
         adjacency = test_disconnected_graph()
         position = np.random.random((adjacency.shape[0], 2))
-        image = svg_graph(adjacency, position)
+        image = visualize_graph(adjacency, position)
         self.assertEqual(image[1:4], 'svg')
         biadjacency = test_bigraph_disconnect()
-        image = svg_bigraph(biadjacency)
+        image = visualize_bigraph(biadjacency)
         self.assertEqual(image[1:4], 'svg')
 
     def test_probs(self):
         adjacency = bow_tie()
         probs = np.array([[.5, .5], [0, 0], [1, 0], [0, 1], [0, 1]])
-        image = svg_graph(adjacency, probs=probs)
+        image = visualize_graph(adjacency, probs=probs)
         self.assertEqual(image[1:4], 'svg')
         probs = sparse.csr_matrix(probs)
-        image = svg_graph(adjacency, probs=probs)
+        image = visualize_graph(adjacency, probs=probs)
         self.assertEqual(image[1:4], 'svg')
         biadjacency = star_wars()
         probs_row = sparse.csr_matrix([[.5, .5], [0, 0], [1, 0], [0, 1]])
         probs_col = sparse.csr_matrix([[.5, .5], [0, 0], [1, 0]])
-        image = svg_bigraph(biadjacency, probs_row=probs_row, probs_col=probs_col)
+        image = visualize_bigraph(biadjacency, probs_row=probs_row, probs_col=probs_col)
         self.assertEqual(image[1:4], 'svg')
 
     def test_labels(self):
         adjacency = bow_tie()
         names = ["aa", "bb", "<>", "a&b", ""]
-        image = svg_graph(adjacency, names=names)
+        image = visualize_graph(adjacency, names=names)
         self.assertEqual(image[1:4], 'svg')
 
     def test_text(self):
@@ -160,11 +166,11 @@ class TestVisualization(unittest.TestCase):
         graph = karate_club(True)
         adjacency = graph.adjacency
         position = graph.position
-        _ = svg_graph(adjacency, position, filename=filename)
+        _ = visualize_graph(adjacency, position, filename=filename)
         with open(filename + '.svg', 'r') as f:
             row = f.readline()
             self.assertEqual(row[1:4], 'svg')
-        _ = svg_bigraph(adjacency, position, filename=filename)
+        _ = visualize_bigraph(adjacency, position, filename=filename)
         with open(filename + '.svg', 'r') as f:
             row = f.readline()
             self.assertEqual(row[1:4], 'svg')

sknetwork/embedding/louvain_hierarchy.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-# coding: utf-8
-"""
-Created on Dec 2020
-@author: Quentin Lutz <qlutz@enst.fr>
-"""
-from typing import Optional, Union
-
-import numpy as np
-from scipy import sparse
-
-from sknetwork.utils.check import check_format, check_random_state
-from sknetwork.utils.format import get_adjacency
-from sknetwork.clustering.louvain import Louvain
-from sknetwork.embedding.base import BaseEmbedding
-
-
-class LouvainNE(BaseEmbedding):
-    """Embedding of graphs based on the hierarchical Louvain algorithm with random scattering per level.
-
-    Parameters
-    ----------
-    n_components : int
-        Dimension of the embedding.
-    scale : float
-        Dilution factor to be applied on the random vector to be added at each iteration of the clustering method.
-    resolution :
-        Resolution parameter.
-    tol_optimization :
-        Minimum increase in the objective function to enter a new optimization pass.
-    tol_aggregation :
-        Minimum increase in the objective function to enter a new aggregation pass.
-    n_aggregations :
-        Maximum number of aggregations.
-        A negative value is interpreted as no limit.
-    shuffle_nodes :
-        Enables node shuffling before optimization.
-    random_state :
-        Random number generator or random seed. If None, numpy.random is used.
-
-    Attributes
-    ----------
-    embedding_ : array, shape = (n, n_components)
-        Embedding of the nodes.
-    embedding_row_ : array, shape = (n_row, n_components)
-        Embedding of the rows, for bipartite graphs.
-    embedding_col_ : array, shape = (n_col, n_components)
-        Embedding of the columns, for bipartite graphs.
-    Example
-    -------
-    >>> from sknetwork.embedding import LouvainNE
-    >>> from sknetwork.data import karate_club
-    >>> louvain = LouvainNE(n_components=3)
-    >>> adjacency = karate_club()
-    >>> embedding = louvain.fit_transform(adjacency)
-    >>> embedding.shape
-    (34, 3)
-
-    References
-    ----------
-    Bhowmick, A. K., Meneni, K., Danisch, M., Guillaume, J. L., & Mitra, B. (2020, January).
-    `LouvainNE: Hierarchical Louvain Method for High Quality and Scalable Network Embedding.
-    <https://hal.archives-ouvertes.fr/hal-02999888/document>`_
-    In Proceedings of the 13th International Conference on Web Search and Data Mining (pp. 43-51).
-    """
-    def __init__(self, n_components: int = 2, scale: float = .1, resolution: float = 1, tol_optimization: float = 1e-3,
-                 tol_aggregation: float = 1e-3, n_aggregations: int = -1, shuffle_nodes: bool = False,
-                 random_state: Optional[Union[np.random.RandomState, int]] = None, verbose: bool = False):
-        super(LouvainNE, self).__init__()
-
-        self.n_components = n_components
-        self.scale = scale
-        self._clustering_method = Louvain(resolution=resolution, tol_optimization=tol_optimization,
-                                          tol_aggregation=tol_aggregation, n_aggregations=n_aggregations,
-                                          shuffle_nodes=shuffle_nodes, random_state=random_state, verbose=verbose)
-        self.random_state = check_random_state(random_state)
-        self.bipartite = None
-
-    def _recursive_louvain(self, adjacency: Union[sparse.csr_matrix, np.ndarray], depth: int,
-                           nodes: Optional[np.ndarray] = None):
-        """Recursive function for fit, modifies the embedding in place.
-
-        Parameters
-        ----------
-        adjacency :
-            Adjacency matrix of the graph.
-        depth :
-            Depth of the recursion.
-        nodes :
-            The indices of the current nodes in the original graph.
-        """
-        n = adjacency.shape[0]
-        if nodes is None:
-            nodes = np.arange(n)
-
-        if adjacency.nnz:
-            labels = self._clustering_method.fit_transform(adjacency)
-        else:
-            labels = np.zeros(n)
-
-        clusters = np.unique(labels)
-
-        if len(clusters) != 1:
-            random_vectors = (self.scale ** depth) * self.random_state.rand(self.n_components, len(clusters))
-            for index, cluster in enumerate(clusters):
-                mask = (labels == cluster)
-                nodes_cluster = nodes[mask]
-                self.embedding_[nodes_cluster, :] += random_vectors[:, index]
-                n_row = len(mask)
-                indptr = np.zeros(n_row + 1, dtype=int)
-                indptr[1:] = np.cumsum(mask)
-                n_col = indptr[-1]
-                combiner = sparse.csr_matrix((np.ones(n_col), np.arange(n_col, dtype=int), indptr),
-                                             shape=(n_row, n_col))
-                adjacency_cluster = adjacency[mask, :].dot(combiner)
-                self._recursive_louvain(adjacency_cluster, depth + 1, nodes_cluster)
-
-    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False):
-        """Embedding of graphs from a clustering obtained with Louvain.
-
-        Parameters
-        ----------
-        input_matrix :
-            Adjacency matrix or biadjacency matrix of the graph.
-        force_bipartite :
-            If ``True``, force the input matrix to be considered as a biadjacency matrix even if square.
-        Returns
-        -------
-        self: :class:`LouvainNE`
-        """
-        # input
-        input_matrix = check_format(input_matrix)
-        adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
-        n = adjacency.shape[0]
-
-        # embedding
-        self.embedding_ = np.zeros((n, self.n_components))
-        self._recursive_louvain(adjacency, 0)
-
-        if self.bipartite:
-            self._split_vars(input_matrix.shape)
-        return self

sknetwork/embedding/tests/test_louvain_hierarchy.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""tests for LouvainNE"""
-import unittest
-
-from sknetwork.data.test_graphs import test_graph, test_disconnected_graph, test_digraph, test_bigraph
-from sknetwork.embedding import LouvainNE
-
-
-class TestLouvainNE(unittest.TestCase):
-
-    def test_louvain_hierarchy(self):
-        louvain = LouvainNE()
-        for adjacency in [test_graph(), test_disconnected_graph(), test_digraph()]:
-            self.assertTupleEqual(louvain.fit_transform(adjacency).shape, (10, 2))
-        louvain.fit(test_bigraph())
-        self.assertTupleEqual(louvain.embedding_.shape, (6, 2))
-        louvain.fit(test_graph(), force_bipartite=True)
-        self.assertTupleEqual(louvain.embedding_.shape, (10, 2))