scikit-network 0.33.3__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

sknetwork/utils/membership.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.neighbors import get_degrees
+
+
+def get_membership(labels: np.ndarray, dtype=bool, n_labels: Optional[int] = None) -> sparse.csr_matrix:
+    """Build the binary matrix of the label assignments, of shape n_samples x n_labels.
+    Negative labels are ignored.
+
+    Parameters
+    ----------
+    labels :
+        Label of each node (integers).
+    dtype :
+        Type of the output. Boolean by default.
+    n_labels : int
+        Number of labels.
+
+    Returns
+    -------
+    membership : sparse.csr_matrix
+        Binary matrix of label assignments.
+
+    Example
+    -------
+    >>> from sknetwork.utils import get_membership
+    >>> labels = np.array([0, 0, 1, 2])
+    >>> membership = get_membership(labels)
+    >>> membership.toarray().astype(int)
+    array([[1, 0, 0],
+           [1, 0, 0],
+           [0, 1, 0],
+           [0, 0, 1]])
+    """
+    n: int = len(labels)
+    if n_labels is None:
+        shape = (n, max(labels)+1)
+    else:
+        shape = (n, n_labels)
+    ix = (labels >= 0)
+    data = np.ones(ix.sum())
+    row = np.arange(n)[ix]
+    col = labels[ix]
+    return sparse.csr_matrix((data, (row, col)), shape=shape, dtype=dtype)
+
+
+def from_membership(membership: sparse.csr_matrix) -> np.ndarray:
+    """Get the labels from a membership matrix (n_samples x n_labels).
+    Samples without label get -1.
+
+    Parameters
+    ----------
+    membership :
+        Membership matrix.
+
+    Returns
+    -------
+    labels : np.ndarray
+        Labels (columns indices of the membership matrix).
+    Example
+    -------
+    >>> from scipy import sparse
+    >>> from sknetwork.utils import from_membership
+    >>> membership = sparse.eye(3).tocsr()
+    >>> labels = from_membership(membership)
+    >>> labels
+    array([0, 1, 2])
+    """
+    mask = get_degrees(membership) > 0
+    labels = -np.ones(membership.shape[0], dtype=int)
+    labels[mask] = membership.indices
+    return labels

sknetwork/utils/neighbors.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on December 29, 2020
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+import numpy as np
+from scipy import sparse
+
+
+def get_neighbors(input_matrix: sparse.csr_matrix, node: int, transpose: bool = False) -> np.ndarray:
+    """Get the neighbors of a node.
+
+    If the graph is directed, returns the vector of successors. Set ``transpose=True``
+    to get the predecessors.
+
+    For a biadjacency matrix, returns the neighbors of a row node. Set ``transpose=True``
+    to get the neighbors of a column node.
+
+    Parameters
+    ----------
+    input_matrix : sparse.csr_matrix
+        Adjacency or biadjacency matrix.
+    node : int
+        Target node.
+    transpose :
+        If ``True``, transpose the input matrix.
+    Returns
+    -------
+    neighbors : np.ndarray
+        Array of neighbors of the target node.
+
+    Example
+    -------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> get_neighbors(adjacency, node=0)
+    array([1, 4], dtype=int32)
+    """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
+    neighbors = matrix.indices[matrix.indptr[node]: matrix.indptr[node + 1]]
+    return neighbors
+
+
+def get_degrees(input_matrix: sparse.csr_matrix, transpose: bool = False) -> np.ndarray:
+    """Get the vector of degrees of a graph.
+
+    If the graph is directed, returns the out-degrees (number of successors). Set ``transpose=True``
+    to get the in-degrees (number of predecessors).
+
+    For a biadjacency matrix, returns the degrees of rows. Set ``transpose=True``
+    to get the degrees of columns.
+
+    Parameters
+    ----------
+    input_matrix : sparse.csr_matrix
+        Adjacency or biadjacency matrix.
+    transpose :
+        If ``True``, transpose the input matrix.
+    Returns
+    -------
+    degrees : np.ndarray
+        Array of degrees.
+
+    Example
+    -------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> get_degrees(adjacency)
+    array([2, 3, 2, 2, 3], dtype=int32)
+    """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
+    degrees = matrix.indptr[1:] - matrix.indptr[:-1]
+    return degrees
+
+
+def get_weights(input_matrix: sparse.csr_matrix, transpose: bool = False) -> np.ndarray:
+    """Get the vector of weights of the nodes of a graph. If the graph is not weighted, return the vector of degrees.
+
+    If the graph is directed, returns the out-weights (total weight of outgoing links). Set ``transpose=True``
+    to get the in-weights (total weight of incoming links).
+
+    For a biadjacency matrix, returns the weights of rows. Set ``transpose=True``
+    to get the weights of columns.
+
+    Parameters
+    ----------
+    input_matrix : sparse.csr_matrix
+        Adjacency or biadjacency matrix.
+    transpose :
+        If ``True``, transpose the input matrix.
+    Returns
+    -------
+    weights : np.ndarray
+        Array of weights.
+
+    Example
+    -------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> get_weights(adjacency)
+    array([2., 3., 2., 2., 3.])
+    """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
+    weights = matrix.dot(np.ones(matrix.shape[1]))
+    return weights

sknetwork/utils/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for utils"""

sknetwork/utils/tests/test_check.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for check.py"""
+import unittest
+
+from sknetwork.data import cyclic_digraph
+from sknetwork.data.test_graphs import test_disconnected_graph
+from sknetwork.utils.check import *
+from sknetwork.utils.format import check_csr_or_slr
+
+
+class TestChecks(unittest.TestCase):
+
+    def setUp(self):
+        """Simple graphs for tests."""
+        self.adjacency = cyclic_digraph(3)
+        self.dense_mat = np.identity(3)
+
+    def test_check_csr_slr(self):
+        with self.assertRaises(TypeError):
+            check_csr_or_slr(np.ones(3))
+
+    def test_check_square(self):
+        with self.assertRaises(ValueError):
+            check_square(np.ones((3, 7)))
+
+    def test_check_connected(self):
+        with self.assertRaises(ValueError):
+            check_connected(test_disconnected_graph())
+
+    def test_check_symmetry(self):
+        with self.assertRaises(ValueError):
+            check_symmetry(self.adjacency)
+
+    def test_nonnegative_entries(self):
+        self.assertTrue(has_nonnegative_entries(self.adjacency))
+        self.assertTrue(has_nonnegative_entries(self.dense_mat))
+
+    def test_check_nonnegative(self):
+        with self.assertRaises(ValueError):
+            check_nonnegative(-self.dense_mat)
+
+    def test_positive_entries(self):
+        self.assertFalse(has_positive_entries(self.dense_mat))
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            has_positive_entries(self.adjacency)
+
+    def test_check_positive(self):
+        check_positive(np.ones(3))
+        with self.assertRaises(ValueError):
+            check_positive(-self.dense_mat)
+
+    def test_probas(self):
+        self.assertTrue(is_proba_array(np.array([.5, .5])))
+        check_is_proba(0.5)
+        with self.assertRaises(TypeError):
+            is_proba_array(np.ones((2, 2, 2)))
+        self.assertRaises(TypeError, check_is_proba, 'toto')
+        with self.assertRaises(ValueError):
+            check_is_proba(2)
+
+    def test_damping(self):
+        with self.assertRaises(ValueError):
+            check_damping_factor(1)
+
+    def test_error_make_weights(self):
+        with self.assertRaises(ValueError):
+            make_weights(distribution='junk', adjacency=self.adjacency)
+
+    def test_error_check_is_proba(self):
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_is_proba('junk')
+        with self.assertRaises(ValueError):
+            check_is_proba(2)
+
+    def test_error_check_weights(self):
+        with self.assertRaises(ValueError):
+            check_weights(np.zeros(4), self.adjacency)
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_weights(2, self.adjacency)
+        with self.assertRaises(ValueError):
+            check_weights(np.zeros(3), self.adjacency, positive_entries=True)
+        with self.assertRaises(ValueError):
+            check_weights(-np.ones(3), self.adjacency)
+
+    def test_random_state(self):
+        random_state = np.random.RandomState(1)
+        self.assertEqual(type(check_random_state(random_state)), np.random.RandomState)
+
+    def test_error_random_state(self):
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_random_state('junk')
+
+    def test_check_labels(self):
+        with self.assertRaises(ValueError):
+            check_labels(np.ones(3))
+        labels = np.ones(5)
+        labels[0] = 0
+        classes, n_classes = check_labels(labels)
+        self.assertTrue(np.equal(classes, np.arange(2)).all())
+        self.assertEqual(n_classes, 2)
+
+    def test_check_n_jobs(self):
+        self.assertEqual(check_n_jobs(None), 1)
+        self.assertEqual(check_n_jobs(-1), None)
+        self.assertEqual(check_n_jobs(8), 8)
+
+    def test_check_n_neighbors(self):
+        with self.assertWarns(Warning):
+            check_n_neighbors(10, 5)
+
+    def test_adj_vector(self):
+        n = 10
+        vector1 = np.random.rand(n)
+        vector2 = sparse.csr_matrix(vector1)
+        adj1 = check_adjacency_vector(vector1)
+        adj2 = check_adjacency_vector(vector2)
+
+        self.assertEqual((adj1 - adj2).nnz, 0)
+        self.assertEqual(adj1.shape, (1, n))
+
+        with self.assertRaises(ValueError):
+            check_adjacency_vector(vector1, 2 * n)
+
+    def test_check_n_clusters(self):
+        with self.assertRaises(ValueError):
+            check_n_clusters(3, 2)
+        with self.assertRaises(ValueError):
+            check_n_clusters(0, 2, 1)
+
+    def test_min_size(self):
+        with self.assertRaises(ValueError):
+            check_min_size(1, 3)
+
+    def test_min_nnz(self):
+        with self.assertRaises(ValueError):
+            check_min_nnz(1, 3)
+
+    def test_dendrogram(self):
+        with self.assertRaises(ValueError):
+            check_dendrogram(np.ones((3, 3)))
+
+    def test_n_components(self):
+        self.assertEqual(5, check_n_components(5, 10))
+        with self.assertWarns(Warning):
+            self.assertEqual(2, check_n_components(5, 2))
+
+    def test_scaling(self):
+        adjacency = cyclic_digraph(3)
+        with self.assertRaises(ValueError):
+            check_scaling(-1, adjacency, regularize=True)
+        adjacency = test_disconnected_graph()
+        with self.assertRaises(ValueError):
+            check_scaling(-1, adjacency, regularize=False)
+
+    def test_boolean_entries(self):
+        with self.assertRaises(TypeError):
+            has_boolean_entries([True, 0, 2])
+        self.assertFalse(has_boolean_entries(np.array([0, 1, True])))
+
+    def test_boolean(self):
+        check_boolean(np.array([True, False, True]))
+        with self.assertRaises(ValueError):
+            check_boolean(np.array([True, 0, 2]))
+
+    def test_check_vector_format(self):
+        check_vector_format(np.arange(4), np.ones(4))
+        with self.assertRaises(ValueError):
+            check_vector_format(np.arange(4), np.ones((4, 3)))
+        with self.assertRaises(ValueError):
+            check_vector_format(np.arange(4), np.ones(5))
+
+    def test_has_self_loops(self):
+        self.assertTrue(has_self_loops(sparse.csr_matrix(np.array([[1, 0], [1, 1]]))))
+        self.assertFalse(has_self_loops(sparse.csr_matrix(np.array([[0, 0], [1, 1]]))))
+
+    def test_add_self_loops(self):
+        # Square adjacency
+        adjacency = sparse.csr_matrix(np.array([[0, 0], [1, 1]]))
+        self.assertFalse(has_self_loops(adjacency))
+        adjacency = add_self_loops(adjacency)
+        self.assertTrue(has_self_loops(adjacency))
+        # Non square adjacency
+        adjacency = sparse.csr_matrix(np.array([[0, 0, 1], [1, 1, 1]]))
+        n_row, n_col = adjacency.shape
+        self.assertTrue(has_self_loops(add_self_loops(adjacency)[:, :n_row]))

sknetwork/utils/tests/test_format.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for format.py"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.utils.format import *
+
+
+class TestFormats(unittest.TestCase):
+
+    def setUp(self):
+        """Basic biadjacency for tests."""
+        self.biadjacency = test_bigraph()
+
+    def test_directed2undirected(self):
+        adjacency = test_digraph()
+        ref = directed2undirected(adjacency)
+        self.assertEqual(ref.shape, adjacency.shape)
+        self.assertTrue(is_symmetric(ref))
+
+        adjacency = test_graph().astype(bool)
+        n = adjacency.shape[0]
+        diff = directed2undirected(adjacency, weighted=False) - adjacency
+        self.assertEqual(diff.nnz, 0)
+
+        slr = SparseLR(adjacency, [(np.zeros(n), np.zeros(n))])
+        self.assertRaises(ValueError, directed2undirected, slr, weighted=False)
+        slr = 0.5 * directed2undirected(slr)
+        self.assertEqual(slr.shape, (n, n))
+
+        x = np.random.randn(n)
+        error = np.linalg.norm(slr.dot(x) - adjacency.dot(x))
+        self.assertAlmostEqual(error, 0)
+
+    def test_bipartite2directed(self):
+        n_row, n_col = self.biadjacency.shape
+        n = n_row + n_col
+
+        directed_graph = bipartite2directed(self.biadjacency)
+        self.assertEqual(directed_graph.shape, (n, n))
+
+        slr = SparseLR(self.biadjacency, [(np.ones(n_row), np.ones(n_col))])
+        directed_graph = bipartite2directed(slr)
+        self.assertTrue(type(directed_graph) == SparseLR)
+
+    def test_bipartite2undirected(self):
+        n_row, n_col = self.biadjacency.shape
+        n = n_row + n_col
+
+        undirected_graph = bipartite2undirected(self.biadjacency)
+        self.assertEqual(undirected_graph.shape, (n, n))
+        self.assertTrue(is_symmetric(undirected_graph))
+
+        slr = SparseLR(self.biadjacency, [(np.ones(n_row), np.ones(n_col))])
+        undirected_graph = bipartite2undirected(slr)
+        self.assertTrue(type(undirected_graph) == SparseLR)
+
+    def test_check(self):
+        with self.assertRaises(ValueError):
+            check_format(sparse.csr_matrix((3, 4)), allow_empty=False)
+        adjacency = check_format(np.array([[0, 2], [2, 3]]))
+        self.assertTrue(adjacency.shape == (2, 2))

sknetwork/utils/tests/test_membership.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2022
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+import unittest
+
+import numpy as np
+
+from sknetwork.utils.membership import get_membership, from_membership
+
+
+class TestMembership(unittest.TestCase):
+
+    def test_membership(self):
+        labels = np.array([0, 0, 1, 2, 1, 1])
+        membership = get_membership(labels)
+        self.assertEqual(membership.nnz, 6)
+        self.assertEqual(np.linalg.norm(labels - from_membership(membership)), 0)
+        labels = np.array([0, 0, 1, 2, 1, -1])
+        membership = get_membership(labels)
+        self.assertEqual(membership.nnz, 5)
+        self.assertEqual(np.linalg.norm(labels - from_membership(membership)), 0)

sknetwork/utils/tests/test_neighbors.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on December 2020
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+import unittest
+
+import numpy as np
+from numpy.linalg import norm
+
+from sknetwork.data import karate_club, painters
+from sknetwork.utils import get_neighbors, get_degrees, get_weights
+
+
+class TestNeighbors(unittest.TestCase):
+
+    def test_graph(self):
+        adjacency = karate_club()
+        neighbors = get_neighbors(adjacency, 5)
+        degrees = get_degrees(adjacency)
+        neighbors_true = np.array([0, 6, 10, 16])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(degrees[5], 4)
+
+    def test_digraph(self):
+        adjacency = painters()
+        neighbors = get_neighbors(adjacency, 0)
+        out_degrees = get_degrees(adjacency)
+        out_weights = get_weights(adjacency)
+        neighbors_true = np.array([3, 10])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(out_degrees[0], 2)
+        self.assertEqual(out_weights[0], 2)
+        neighbors = get_neighbors(adjacency, 0, transpose=True)
+        in_degrees = get_degrees(adjacency, transpose=True)
+        in_weights = get_weights(adjacency, transpose=True)
+        neighbors_true = np.array([3,  6,  8, 10, 11])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(in_degrees[0], 5)
+        self.assertEqual(in_weights[0], 5)

sknetwork/utils/tests/test_tfidf.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for tfidf.py"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.tfidf import get_tfidf
+
+
+class TestTFIDF(unittest.TestCase):
+
+    def test_tfidf(self):
+        count = sparse.csr_matrix(np.array([[0, 1, 2], [0, 2, 1], [0, 0, 1]]))
+        tfidf = get_tfidf(count)
+        self.assertEqual(count.shape, tfidf.shape)
+        self.assertEqual(tfidf.nnz, 2)

sknetwork/utils/tests/test_values.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for values.py"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.utils.values import get_values, stack_values, values2prob
+
+
+class TestValues(unittest.TestCase):
+
+    def test_get_values(self):
+        n = 10
+        labels_array = -np.ones(n)
+        labels_array[:2] = np.arange(2)
+        labels_dict = {0: 0, 1: 1}
+        labels_array = get_values((n,), labels_array)
+        labels_ = get_values((n,), labels_dict)
+        self.assertTrue(np.allclose(labels_array, labels_))
+        with self.assertRaises(ValueError):
+            get_values((5,), labels_array)
+        self.assertRaises(TypeError, get_values, 'toto', 3)
+        with self.assertWarns(Warning):
+            labels_dict[0] = -1
+            get_values((n,), labels_dict)
+
+    def test_values2probs(self):
+        n = 4
+        values_array = np.array([0, 1, -1, 0])
+        values_dict = {0: 0, 1: 1, 3: 0}
+
+        probs1 = values2prob(n, values_array)
+        probs2 = values2prob(n, values_dict)
+        self.assertTrue(np.allclose(probs1, probs2))
+
+        bad_input = np.array([0, 0, -1, 0])
+        with self.assertRaises(ValueError):
+            values2prob(n, bad_input)
+
+    def test_stack_values(self):
+        shape = 4, 3
+        values_row_array = np.array([0, 1, -1, 0])
+        values_row_dict = {0: 0, 1: 1, 3: 0}
+        values_col_array = np.array([0, 1, -1])
+        values_col_dict = {0: 0, 1: 1}
+
+        values1 = stack_values(shape, values_row_array, values_col_array)
+        values2 = stack_values(shape, values_row_dict, values_col_dict)
+        values3 = stack_values(shape, values_row_array, values_col_dict)
+        values4 = stack_values(shape, values_row_dict, values_col_array)
+
+        self.assertTrue(np.allclose(values1, values2))
+        self.assertTrue(np.allclose(values2, values3))
+        self.assertTrue(np.allclose(values3, values4))
+
+        values1 = stack_values(shape, values_row_array, None)
+        values2 = stack_values(shape, values_row_dict, None)
+
+        self.assertTrue(np.allclose(values1, values2))
+
+        values1 = stack_values(shape, None, values_col_array)
+        values2 = stack_values(shape, None, values_col_dict)
+
+        self.assertTrue(np.allclose(values1, values2))

sknetwork/utils/tfidf.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in February 2023
+@author: Thomas Bonald <thomas.bonald&telecom-paris.fr>
+"""
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg import normalize
+from sknetwork.utils import get_degrees
+
+
+def get_tfidf(count_matrix: sparse.csr_matrix):
+    """Get the tf-idf from a count matrix in sparse format.
+
+    Parameters
+    ----------
+    count_matrix : sparse.csr_matrix
+        Count matrix, shape (n_documents, n_words).
+
+    Returns
+    -------
+    tf_idf : sparse.csr_matrix
+        tf-idf matrix, shape (n_documents, n_words).
+
+    References
+    ----------
+    https://en.wikipedia.org/wiki/Tfidf
+    """
+    n_documents, n_words = count_matrix.shape
+    tf = normalize(count_matrix)
+    freq = get_degrees(count_matrix > 0, transpose=True)
+    idf = np.zeros(n_words)
+    idf[freq > 0] = np.log(n_documents / freq[freq > 0])
+    tf_idf = tf.dot(sparse.diags(idf))
+    return tf_idf