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

sknetwork/hierarchy/paris.pyx

@@ -157,21 +157,21 @@ class Paris(BaseHierarchy):
 
     Parameters
     ----------
-    weights :
+    weights : str
         Weights of nodes.
         ``'degree'`` (default) or ``'uniform'``.
-    reorder :
+    reorder : bool
         If ``True`` (default), reorder the dendrogram in non-decreasing order of height.
 
     Attributes
     ----------
-    dendrogram_ :
+    dendrogram_ : np.ndarray
         Dendrogram of the graph.
-    dendrogram_row_ :
+    dendrogram_row_ : np.ndarray
         Dendrogram for the rows, for bipartite graphs.
-    dendrogram_col_ :
+    dendrogram_col_ : np.ndarray
         Dendrogram for the columns, for bipartite graphs.
-    dendrogram_full_ :
+    dendrogram_full_ : np.ndarray
         Dendrogram for both rows and columns, indexed in this order, for bipartite graphs.
 
     Examples
@@ -212,13 +212,15 @@ class Paris(BaseHierarchy):
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> 'Paris':
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], force_bipartite: bool = False) -> 'Paris':
         """Agglomerative clustering using the nearest neighbor chain.
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
+        force_bipartite :
+            If ``True``, force the input matrix to be considered as a biadjacency matrix.
 
         Returns
         -------
@@ -227,8 +229,7 @@ class Paris(BaseHierarchy):
         self._init_vars()
 
         # input
-        input_matrix = check_format(input_matrix)
-        adjacency, self.bipartite = get_adjacency(input_matrix)
+        adjacency, self.bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
 
         weights = self.weights
         out_weights = get_probs(weights, adjacency)

sknetwork/hierarchy/postprocess.py

@@ -75,17 +75,17 @@ def cut_straight(dendrogram: np.ndarray, n_clusters: Optional[int] = None, thres
 
     Parameters
     ----------
-    dendrogram:
+    dendrogram : np.ndarray
         Dendrogram.
-    n_clusters :
+    n_clusters : int
         Number of clusters (optional).
         The number of clusters can be larger than n_clusters in case of equal heights in the dendrogram.
-    threshold :
+    threshold : float
         Threshold on height (optional).
         If both n_clusters and threshold are ``None``, n_clusters is set to 2.
-    sort_clusters :
+    sort_clusters : bool
         If ``True``,  sorts clusters in decreasing order of size.
-    return_dendrogram :
+    return_dendrogram : bool
         If ``True``, returns the dendrogram formed by the clusters up to the root.
     Returns
     -------
@@ -135,13 +135,13 @@ def cut_balanced(dendrogram: np.ndarray, max_cluster_size: int = 20, sort_cluste
 
     Parameters
     ----------
-    dendrogram:
+    dendrogram : np.ndarray
         Dendrogram
-    max_cluster_size :
+    max_cluster_size : int
         Maximum size of each cluster.
-    sort_clusters :
+    sort_clusters : bool
         If ``True``, sort labels in decreasing order of cluster size.
-    return_dendrogram :
+    return_dendrogram : bool
         If ``True``, returns the dendrogram formed by the clusters up to the root.
     Returns
     -------
@@ -179,19 +179,19 @@ def aggregate_dendrogram(dendrogram: np.ndarray, n_clusters: int = 2, return_cou
 
     Parameters
     ----------
-    dendrogram:
+    dendrogram : np.ndarray
         The input to aggregate.
-    n_clusters:
+    n_clusters : int
         Number of clusters (or leaves) to keep.
-    return_counts
+    return_counts :  bool
         If ``True``, returns an array of counts corresponding to the sizes of the merged subtrees.
         The sum of the counts is equal to the number of samples in the input dendrogram.
 
     Returns
     -------
-    new_dendrogram:
+    new_dendrogram : np.ndarray
         Aggregated dendrogram. The nodes are reindexed from 0.
-    counts:
+    counts : np.ndarray
         Size of the subtrees corresponding to each leaf in new_dendrogram.
     """
     n_nodes: int = dendrogram.shape[0] + 1
@@ -220,12 +220,12 @@ def get_index(tree):
 
     Parameters
     ----------
-    tree:
+    tree :
         The tree to be indexed
 
     Returns
     -------
-    index:
+    index :
         The index of the root of the given tree
     """
     if type(tree) != list:

sknetwork/hierarchy/tests/test_algos.py

@@ -27,3 +27,8 @@ class TestLouvainHierarchy(unittest.TestCase):
                 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

@@ -17,7 +17,7 @@ class TestMetrics(unittest.TestCase):
 
     def setUp(self):
         self.paris = Paris()
-        self.louvain_hierarchy = LouvainIteration()
+        self.louvain_iteration = LouvainIteration()
 
     def test_undirected(self):
         adjacency = cyclic_graph(3)
@@ -31,7 +31,7 @@ class TestMetrics(unittest.TestCase):
         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_hierarchy.fit_transform(adjacency)
+        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)
@@ -41,7 +41,7 @@ class TestMetrics(unittest.TestCase):
         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_hierarchy.fit_transform(adjacency)
+        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)
 
@@ -50,7 +50,7 @@ class TestMetrics(unittest.TestCase):
         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_hierarchy.fit_transform(adjacency)
+        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)
 

sknetwork/linalg/__init__.py

@@ -2,7 +2,7 @@
 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.normalization import diagonal_pseudo_inverse, get_norms, normalize
+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