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

sknetwork/classification/diffusion.py

@@ -10,7 +10,8 @@ import numpy as np
 from scipy import sparse
 
 from sknetwork.classification.base import BaseClassifier
-from sknetwork.linalg.normalization import normalize
+from sknetwork.path.distances import get_distances
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.utils.format import get_adjacency_values
 from sknetwork.utils.membership import get_membership
 from sknetwork.utils.neighbors import get_degrees
@@ -27,25 +28,24 @@ class DiffusionClassifier(BaseClassifier):
         Number of iterations of the diffusion (discrete time).
     centering : bool
         If ``True``, center the temperature of each label to its mean before classification (default).
-    threshold : float
-        Minimum difference of temperatures between the 2 top labels to classify a node (default = 0).
-        If the difference of temperatures does not exceed this threshold, return -1 for this node (no label).
+    scale : float
+        Multiplicative factor applied to tempreatures before softmax (default = 5).
+        Used only when centering is ``True``.
 
     Attributes
     ----------
     labels_ : np.ndarray, shape (n_labels,)
-        Label of each node.
-    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix.
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
     labels_row_ : np.ndarray
         Labels of rows, for bipartite graphs.
     labels_col_ : np.ndarray
         Labels of columns, for bipartite graphs.
-    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix of rows, for bipartite graphs.
-    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
-        Membership matrix of columns, for bipartite graphs.
-
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
     Example
     -------
     >>> from sknetwork.data import karate_club
@@ -63,7 +63,7 @@ class DiffusionClassifier(BaseClassifier):
     Zhu, X., Lafferty, J., & Rosenfeld, R. (2005). `Semi-supervised learning with graphs`
     (Doctoral dissertation, Carnegie Mellon University, language technologies institute, school of computer science).
     """
-    def __init__(self, n_iter: int = 10, centering: bool = True, threshold: float = 0):
+    def __init__(self, n_iter: int = 10, centering: bool = True, scale: float = 5):
         super(DiffusionClassifier, self).__init__()
 
         if n_iter <= 0:
@@ -71,7 +71,7 @@ class DiffusionClassifier(BaseClassifier):
         else:
             self.n_iter = n_iter
         self.centering = centering
-        self.threshold = threshold
+        self.scale = scale
 
     def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray],
             labels: Optional[Union[dict, np.ndarray]] = None, labels_row: Optional[Union[dict, np.ndarray]] = None,
@@ -81,13 +81,15 @@ class DiffusionClassifier(BaseClassifier):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        labels :
+        labels : dict, np.ndarray
             Known labels (dictionary or vector of int). Negative values ignored.
-        labels_row, labels_col :
-            Labels of rows and columns for bipartite graphs. Negative values ignored.
-        force_bipartite :
+        labels_row : dict, np.ndarray
+            Labels of rows for bipartite graphs. Negative values ignored.
+        labels_col : dict, np.ndarray
+            Labels of columns for bipartite graphs. Negative values ignored.
+        force_bipartite : bool
             If ``True``, consider the input matrix as a biadjacency matrix (default = ``False``).
 
         Returns
@@ -101,33 +103,31 @@ class DiffusionClassifier(BaseClassifier):
         labels = values.astype(int)
         if (labels < 0).all():
             raise ValueError('At least one node must be given a non-negative label.')
-        temperatures = get_membership(labels).toarray()
+        labels_reindex = labels.copy()
+        labels_unique, inverse = np.unique(labels[labels >= 0], return_inverse=True)
+        labels_reindex[labels >= 0] = inverse
+        temperatures = get_membership(labels_reindex).toarray()
         temperatures_seeds = temperatures[labels >= 0]
-        n_labels = temperatures.shape[1]
-        temperatures[labels < 0] = 1 / n_labels
+        temperatures[labels < 0] = 0.5
         diffusion = normalize(adjacency)
         for i in range(self.n_iter):
             temperatures = diffusion.dot(temperatures)
             temperatures[labels >= 0] = temperatures_seeds
-
-        self.membership_ = sparse.csr_matrix(temperatures)
-
         if self.centering:
             temperatures -= temperatures.mean(axis=0)
+        labels_ = labels_unique[temperatures.argmax(axis=1)]
 
-        labels_ = temperatures.argmax(axis=1)
-        # set label -1 to nodes without temperature (no diffusion to them)
-        labels_[get_degrees(self.membership_) == 0] = -1
+        # softmax
+        if self.centering:
+            temperatures = np.exp(self.scale * temperatures)
 
-        if self.threshold >= 0:
-            if n_labels > 2:
-                top_temperatures = np.partition(-temperatures, 2, axis=1)[:, :2]
-            else:
-                top_temperatures = temperatures
-            differences = np.abs(top_temperatures[:, 0] - top_temperatures[:, 1])
-            labels_[differences <= self.threshold] = -1
+        # set label -1 to nodes not reached by diffusion
+        distances = get_distances(adjacency, source=np.flatnonzero(labels >= 0))
+        labels_[distances < 0] = -1
+        temperatures[distances < 0] = 0
 
         self.labels_ = labels_
+        self.probs_ = sparse.csr_matrix(normalize(temperatures))
         self._split_vars(input_matrix.shape)
 
         return self

sknetwork/classification/knn.py

@@ -12,7 +12,7 @@ from scipy import sparse
 
 from sknetwork.classification.base import BaseClassifier
 from sknetwork.embedding.base import BaseEmbedding
-from sknetwork.linalg.normalization import get_norms, normalize
+from sknetwork.linalg.normalizer import get_norms, normalize
 from sknetwork.utils.check import check_n_neighbors
 from sknetwork.utils.format import get_adjacency_values
 
@@ -22,28 +22,29 @@ class NNClassifier(BaseClassifier):
 
     Parameters
     ----------
-    n_neighbors :
+    n_neighbors : int
         Number of nearest neighbors .
-    embedding_method :
+    embedding_method : :class:`BaseEmbedding`
         Embedding method used to represent nodes in vector space.
         If ``None`` (default), use identity.
-    normalize :
+    normalize : bool
         If ``True``, apply normalization so that all vectors have norm 1 in the embedding space.
 
     Attributes
     ----------
     labels_ : np.ndarray, shape (n_labels,)
-        Label of each node.
-    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix.
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
     labels_row_ : np.ndarray
         Labels of rows, for bipartite graphs.
     labels_col_ : np.ndarray
         Labels of columns, for bipartite graphs.
-    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix of rows, for bipartite graphs.
-    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
-        Membership matrix of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
+
     Example
     -------
     >>> from sknetwork.classification import NNClassifier
@@ -91,10 +92,10 @@ class NNClassifier(BaseClassifier):
         col += list(labels[index_train])
         data += list(np.ones_like(index_train))
 
-        membership = normalize(sparse.csr_matrix((data, (row, col)), shape=(len(labels), np.max(labels) + 1)))
-        labels = np.argmax(membership.toarray(), axis=1)
+        probs = normalize(sparse.csr_matrix((data, (row, col)), shape=(len(labels), np.max(labels) + 1)))
+        labels = np.argmax(probs.toarray(), axis=1)
 
-        return membership, labels
+        return probs, labels
 
     def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], labels: Union[np.ndarray, dict] = None,
             labels_row: Union[np.ndarray, dict] = None, labels_col: Union[np.ndarray, dict] = None) -> 'NNClassifier':
@@ -102,12 +103,14 @@ class NNClassifier(BaseClassifier):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        labels :
-            Known labels (dictionary or array). Negative values ignored.
-        labels_row, labels_col :
-            Labels of rows and columns (for bipartite graphs).
+        labels : np.ndarray, dict
+            Known labels. Negative values ignored.
+        labels_row : np.ndarray, dict
+            Known labels of rows, for bipartite graphs.
+        labels_col : np.ndarray, dict
+            Known labels of columns, for bipartite graphs.
 
         Returns
         -------
@@ -126,10 +129,10 @@ class NNClassifier(BaseClassifier):
         if self.normalize:
             embedding = normalize(embedding, p=2)
 
-        membership, labels = self._fit_core(embedding, labels, index_seed, index_remain)
+        probs, labels = self._fit_core(embedding, labels, index_seed, index_remain)
 
         self.labels_ = labels
-        self.membership_ = membership
+        self.probs_ = probs
         self._split_vars(input_matrix.shape)
 
         return self

sknetwork/classification/metrics.py

@@ -158,7 +158,7 @@ def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_preci
     mask = counts_pred > 0
     precisions[mask] = counts_correct[mask] / counts_pred[mask]
     f1_scores = np.zeros(n_labels)
-    mask = (counts_true > 0) & (counts_pred > 0)
+    mask = (precisions > 0) & (recalls > 0)
     f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])
     if return_precision_recall:
         return f1_scores, precisions, recalls

sknetwork/classification/pagerank.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on March 2020
+Created in March 2020
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 from typing import Optional
@@ -17,9 +17,9 @@ class PageRankClassifier(RankClassifier):
 
     Parameters
     ----------
-    damping_factor:
+    damping_factor: float
         Probability to continue the random walk.
-    solver : :obj:`str`
+    solver : str
         Which solver to use: 'piteration', 'diteration', 'bicgstab', 'lanczos'.
     n_iter : int
         Number of iterations for some solvers such as ``'piteration'`` or ``'diteration'``.
@@ -29,17 +29,17 @@ class PageRankClassifier(RankClassifier):
     Attributes
     ----------
     labels_ : np.ndarray, shape (n_labels,)
-        Label of each node.
-    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix.
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
     labels_row_ : np.ndarray
         Labels of rows, for bipartite graphs.
     labels_col_ : np.ndarray
         Labels of columns, for bipartite graphs.
-    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix of rows, for bipartite graphs.
-    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
-        Membership matrix of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
 
     Example
     -------

sknetwork/classification/propagation.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # coding: utf-8
 """
-Created on April 2020
+Created in April 2020
 @author: Thomas Bonald <tbonald@enst.fr>
 """
 
@@ -12,7 +12,7 @@ from scipy import sparse
 
 from sknetwork.classification.base import BaseClassifier
 from sknetwork.classification.vote import vote_update
-from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.utils.format import get_adjacency_values
 from sknetwork.utils.membership import get_membership
 
@@ -25,9 +25,9 @@ class Propagation(BaseClassifier):
     n_iter : float
         Maximum number of iterations (-1 for infinity).
     node_order : str
-        * `'random'`: node labels are updated in random order.
-        * `'increasing'`: node labels are updated by increasing order of (in-)weight.
-        * `'decreasing'`: node labels are updated by decreasing order of (in-)weight.
+        * ``'random'``: node labels are updated in random order.
+        * ``'increasing'``: node labels are updated by increasing order of (in-) weight.
+        * ``'decreasing'``: node labels are updated by decreasing order of (in-) weight.
         * Otherwise, node labels are updated by index order.
     weighted : bool
         If ``True``, the vote of each neighbor is proportional to the edge weight.
@@ -36,17 +36,17 @@ class Propagation(BaseClassifier):
     Attributes
     ----------
     labels_ : np.ndarray, shape (n_labels,)
-        Label of each node.
-    membership_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix.
+        Labels of nodes.
+    probs_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distribution over labels.
     labels_row_ : np.ndarray
         Labels of rows, for bipartite graphs.
     labels_col_ : np.ndarray
         Labels of columns, for bipartite graphs.
-    membership_row_ : sparse.csr_matrix, shape (n_row, n_labels)
-        Membership matrix of rows, for bipartite graphs.
-    membership_col_ : sparse.csr_matrix, shape (n_col, n_labels)
-        Membership matrix of columns, for bipartite graphs.
+    probs_row_ : sparse.csr_matrix, shape (n_row, n_labels)
+        Probability distributions over labels of rows, for bipartite graphs.
+    probs_col_ : sparse.csr_matrix, shape (n_col, n_labels)
+        Probability distributions over labels of columns, for bipartite graphs.
 
     Example
     -------
@@ -97,12 +97,15 @@ class Propagation(BaseClassifier):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        labels :
-            Known labels (dictionary or array). Negative values ignored.
-        labels_row, labels_col :
-            Labels of rows and columns (for bipartite graphs).
+        labels : np.ndarray, dict
+            Known labels. Negative values ignored.
+        labels_row : np.ndarray, dict
+            Known labels of rows, for bipartite graphs.
+        labels_col : np.ndarray, dict
+            Known labels of columns, for bipartite graphs.
+
         Returns
         -------
         self: :class:`Propagation`
@@ -138,11 +141,11 @@ class Propagation(BaseClassifier):
             labels_remain = labels[index_remain].copy()
             labels = np.asarray(vote_update(indptr, indices, data, labels, index_remain))
 
-        membership = get_membership(labels)
-        membership = normalize(adjacency.dot(membership))
+        probs = get_membership(labels)
+        probs = normalize(adjacency.dot(probs))
 
         self.labels_ = labels
-        self.membership_ = membership
+        self.probs_ = probs
         self._split_vars(input_matrix.shape)
 
         return self

sknetwork/classification/tests/test_diffusion.py

@@ -23,9 +23,9 @@ class TestDiffusionClassifier(unittest.TestCase):
         self.assertTrue(len(algo.labels_) == n_nodes)
         with self.assertRaises(ValueError):
             DiffusionClassifier(n_iter=0)
-        algo = DiffusionClassifier(centering=False, threshold=1)
-        algo.fit(adjacency, labels=labels)
-        self.assertTrue(max(algo.labels_) == -1)
+        algo = DiffusionClassifier(centering=True, scale=10)
+        probs = algo.fit_predict_proba(adjacency, labels=labels)[:, 1]
+        self.assertTrue(max(probs) > 0.99)
 
     def test_bipartite(self):
         biadjacency = test_bigraph()
@@ -36,6 +36,7 @@ class TestDiffusionClassifier(unittest.TestCase):
         algo.fit(biadjacency, labels_row=labels_row, labels_col=labels_col)
         self.assertTrue(len(algo.labels_row_) == n_row)
         self.assertTrue(len(algo.labels_col_) == n_col)
+        self.assertTrue(all(algo.labels_col_ == algo.predict(columns=True)))
 
     def test_predict(self):
         adjacency = test_graph()
@@ -65,3 +66,12 @@ class TestDiffusionClassifier(unittest.TestCase):
         self.assertTrue(membership.shape == (n_row, 2))
         membership = algo.transform(columns=True)
         self.assertTrue(membership.shape == (n_col, 2))
+
+    def test_reindex_label(self):
+        adjacency = test_graph()
+        n_nodes = adjacency.shape[0]
+        labels = {0: 0, 1: 2, 2: 3}
+        algo = DiffusionClassifier()
+        labels_pred = algo.fit_predict(adjacency, labels=labels)
+        self.assertTrue(len(labels_pred) == n_nodes)
+        self.assertTrue(set(list(labels_pred)) == {0, 2, 3})