scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/utils/kmeans.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import numpy as np
+from scipy.cluster.vq import kmeans2
+
+from sknetwork.utils.base import Algorithm
+
+
+class KMeansDense(Algorithm):
+    """Standard KMeansDense clustering based on SciPy function ``kmeans2``.
+
+    Parameters
+    ----------
+    n_clusters :
+        Number of desired clusters.
+    init :
+        Method for initialization. Available methods are ‘random’, ‘points’, ‘++’ and ‘matrix’:
+        * ‘random’: generate k centroids from a Gaussian with mean and variance estimated from the data.
+        * ‘points’: choose k observations (rows) at random from data for the initial centroids.
+        * ‘++’: choose k observations accordingly to the kmeans++ method (careful seeding)
+        * ‘matrix’: interpret the k parameter as a k by M (or length k array for one-dimensional data) array of initial
+        centroids.
+    n_init :
+        Number of iterations of the k-means algorithm to run.
+    tol :
+        Relative tolerance with regards to inertia to declare convergence.
+
+    Attributes
+    ----------
+    labels_ :
+        Label of each sample.
+    cluster_centers_ :
+        A ‘k’ by ‘N’ array of centroids found at the last iteration of k-means.
+
+    References
+    ----------
+    * MacQueen, J. (1967, June). Some methods for classification and analysis of multivariate observations.
+      In Proceedings of the fifth Berkeley symposium on mathematical statistics and probability
+      (Vol. 1, No. 14, pp. 281-297).
+
+    * Arthur, D., & Vassilvitskii, S. (2007, January). k-means++: The advantages of careful seeding.
+      In Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms (pp. 1027-1035).
+      Society for Industrial and Applied Mathematics.
+    """
+    def __init__(self, n_clusters: int = 8, init: str = '++', n_init: int = 10, tol: float = 1e-4):
+        self.n_clusters = n_clusters
+        self.init = init.lower()
+        self.n_init = n_init
+        self.tol = tol
+
+        self.labels_ = None
+        self.cluster_centers_ = None
+
+    def fit(self, x: np.ndarray) -> 'KMeansDense':
+        """Fit algorithm to the data.
+
+        Parameters
+        ----------
+        x:
+            Data to cluster.
+
+        Returns
+        -------
+        self: :class:`KMeansDense`
+        """
+        centroids, labels = kmeans2(data=x, k=self.n_clusters, iter=self.n_init, thresh=self.tol, minit=self.init)
+        self.cluster_centers_ = centroids
+        self.labels_ = labels
+
+        return self
+
+    def fit_transform(self, x: np.ndarray) -> np.ndarray:
+        """Fit algorithm to the data and return the labels.
+
+        Parameters
+        ----------
+        x:
+            Data to cluster.
+
+        Returns
+        -------
+        labels: np.ndarray
+        """
+        self.fit(x)
+        return self.labels_

sknetwork/utils/knn.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from abc import ABC
+
+import numpy as np
+from scipy import sparse
+from scipy.spatial import cKDTree
+
+from sknetwork.utils.base import Algorithm
+from sknetwork.utils.format import directed2undirected
+from sknetwork.utils.knn1d import knn1d
+
+
+class BaseTransformer(Algorithm, ABC):
+    """Base class for transformers."""
+    def __init__(self, undirected: bool = False):
+        self.undirected = undirected
+
+        self.adjacency_ = None
+
+    def fit_transform(self, x: np.ndarray) -> sparse.csr_matrix:
+        """Fit algorithm to the data and return the computed adjacency.
+
+        Parameters
+        ----------
+        x: np.ndarray
+            Input data.
+
+        Returns
+        -------
+        adjacency : sparse.csr_matrix
+        """
+        self.fit(x)
+        return self.adjacency_
+
+    def make_undirected(self):
+        """Modifies the adjacency to match desired constrains."""
+        if self.adjacency_ is not None and self.undirected:
+            dtype = self.adjacency_.dtype
+            self.adjacency_ = directed2undirected(self.adjacency_, weighted=False).astype(dtype)
+
+        return self
+
+
+class KNNDense(BaseTransformer):
+    """Extract adjacency from vector data through k-nearest-neighbor search with KD-Tree.
+
+    Parameters
+    ----------
+    n_neighbors :
+        Number of neighbors for each sample in the transformed sparse graph.
+    undirected :
+        As the nearest neighbor relationship is not symmetric, the graph is directed by default.
+        Setting this parameter to ``True`` forces the algorithm to return undirected graphs.
+    leaf_size :
+        Leaf size passed to KDTree.
+        This can affect the speed of the construction and query, as well as the memory required to store the tree.
+    p :
+        Which Minkowski p-norm to use. 1 is the sum-of-absolute-values “Manhattan” distance,
+        2 is the usual Euclidean distance infinity is the maximum-coordinate-difference distance.
+        A finite large p may cause a ValueError if overflow can occur.
+    eps :
+        Return approximate nearest neighbors; the k-th returned value is guaranteed to be no further than (1+tol_nn)
+        times the distance to the real k-th nearest neighbor.
+    n_jobs :
+        Number of jobs to schedule for parallel processing. If -1 is given all processors are used.
+
+    Attributes
+    ----------
+    adjacency_ :
+        Adjacency matrix of the graph.
+
+    References
+    ----------
+    Maneewongvatana, S., & Mount, D. M. (1999, December). It’s okay to be skinny, if your friends are fat.
+    In Center for Geometric Computing 4th Annual Workshop on Computational Geometry (Vol. 2, pp. 1-8).
+    """
+    def __init__(self, n_neighbors: int = 5, undirected: bool = False, leaf_size: int = 16, p=2, eps: float = 0.01,
+                 n_jobs=1):
+        super(KNNDense, self).__init__(undirected)
+
+        self.n_neighbors = n_neighbors
+        self.leaf_size = leaf_size
+        self.p = p
+        self.eps = eps
+        self.n_jobs = n_jobs
+
+    def fit(self, x: np.ndarray) -> 'KNNDense':
+        """Fit algorithm to the data.
+
+        Parameters
+        ----------
+        x :
+            Data to transform into adjacency.
+
+        Returns
+        -------
+        self : :class:`KNNDense`
+        """
+        tree = cKDTree(x, self.leaf_size)
+        _, neighbors = tree.query(x, self.n_neighbors + 1, self.eps, self.p, workers=self.n_jobs)
+
+        n: int = x.shape[0]
+        indptr: np.ndarray = np.arange(n + 1) * (self.n_neighbors + 1)
+        indices: np.ndarray = neighbors.reshape(-1)
+        data = np.ones(indices.shape[0], dtype=bool)
+
+        self.adjacency_ = sparse.csr_matrix((data, indices, indptr))
+        self.make_undirected()
+        self.adjacency_.setdiag(0)
+
+        return self
+
+
+class CNNDense(BaseTransformer):
+    """Extract adjacency from vector data through component-wise k-nearest-neighbor search.
+    KNN is applied independently on each column of the input matrix.
+
+    Parameters
+    ----------
+    n_neighbors :
+        Number of neighbors per dimension.
+    undirected :
+        As the nearest neighbor relationship is not symmetric, the graph is directed by default.
+        Setting this parameter to ``True`` forces the algorithm to return undirected graphs.
+
+    Attributes
+    ----------
+    adjacency_ :
+        Adjacency matrix of the  graph.
+    """
+    def __init__(self, n_neighbors: int = 1, undirected: bool = False):
+        super(CNNDense, self).__init__(undirected)
+
+        self.n_neighbors = n_neighbors
+
+    def fit(self, x: np.ndarray) -> 'CNNDense':
+        """Fit algorithm to the data.
+
+        Parameters
+        ----------
+        x:
+            Data to transform into adjacency.
+
+        Returns
+        -------
+        self: :class:`CNNDense`
+        """
+        rows, cols = [], []
+        for j in range(x.shape[1]):
+            row, col = knn1d(x[:, j].astype(np.float32), self.n_neighbors)
+            rows += row
+            cols += col
+
+        rows = np.array(rows)
+        cols = np.array(cols)
+        data = np.ones(cols.shape[0], dtype=bool)
+
+        self.adjacency_ = sparse.csr_matrix((data, (rows, cols)))
+        self.make_undirected()
+
+        return self

sknetwork/utils/knn1d.pyx

@@ -0,0 +1,80 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+""" One dimensional nearest neighbor search.
+Created on Mar, 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import numpy as np
+cimport numpy as np
+
+from libcpp.vector cimport vector
+cimport cython
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def knn1d(float[:] x, int n_neighbors):
+    """K nearest neighbors search for 1-dimensional arrays.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        1-d data
+    n_neighbors: int
+        Number of neighbors to return.
+    Returns
+    -------
+    tuple
+        List of source nodes and list of target nodes.
+    """
+    cdef int n
+    cdef int i
+    cdef int j
+    cdef int ix
+    cdef int low
+    cdef int hgh
+    cdef int neigh
+    cdef int val
+
+    cdef vector[int] sorted_ix
+    cdef vector[int] row
+    cdef vector[int] col
+    cdef vector[int] candidates
+    cdef vector[int] sorted_candidates
+    cdef vector[int] sorted_deltas
+    cdef vector[int] tmp
+
+    cdef vector[float] deltas
+
+    n = x.shape[0]
+    tmp = np.argsort(x)
+    for i in range(n):
+        sorted_ix.push_back(tmp[i])
+
+    for i in range(n):
+        deltas.clear()
+        sorted_candidates.clear()
+
+        ix = sorted_ix[i]
+        low = max(0, i - n_neighbors)
+        hgh = min(n - 1, i + n_neighbors + 1)
+        candidates = sorted_ix[low:hgh]
+
+        for j in range(len(candidates)):
+            deltas.push_back(abs(x[candidates[j]] - x[ix]))
+
+        sorted_deltas = np.argsort(deltas)
+        for j in range(len(sorted_deltas)):
+            val = candidates[sorted_deltas[j]]
+            sorted_candidates.push_back(val)
+        sorted_candidates = sorted_candidates[:n_neighbors+1]
+
+        for j in range(len(sorted_candidates)):
+            neigh = sorted_candidates[j]
+            if neigh != ix:
+                row.push_back(ix)
+                col.push_back(neigh)
+
+    return row, col

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.
+    dtype :
+        Type of the entries. 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/minheap.pxd

@@ -0,0 +1,22 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Jun 3, 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+from libcpp.vector cimport vector
+
+cdef class MinHeap:
+
+    cdef vector[int] val, pos
+    cdef int size
+
+    cdef int pop_min(self, int[:] scores)
+    cdef bint empty(self)
+    cdef void swap(self, int x, int y)
+    cdef void insert_key(self, int k, int[:] scores)
+    cdef void decrease_key(self, int i, int[:] scores)
+    cdef void min_heapify(self, int i, int[:] scores)

sknetwork/utils/minheap.pyx

@@ -0,0 +1,111 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Jun 3, 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+cimport cython
+
+
+cdef inline int parent(int i):
+    """Index of the parent node of i in the tree."""
+    return (i - 1) // 2
+
+cdef inline int left(int i):
+    """Index of the left child of i in the tree."""
+    return 2 * i + 1
+
+cdef inline int right(int i):
+    """Index of the right child of i in the tree."""
+    return 2 * i + 2
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef class MinHeap:
+    """Min heap data structure."""
+    def __cinit__(self, int n):
+        self.val.reserve(n)		# reserves the necessary space in the vector
+        self.pos.reserve(n)		# reserves the necessary space in the other vector
+        self.size = 0
+
+    cdef bint empty(self):
+        """Check if the heap is empty."""
+        return self.size == 0
+
+    cdef inline void swap(self, int x, int y):
+        """Exchange two elements in the heap."""
+        cdef int tmp
+        tmp = self.val[x]
+        self.val[x] = self.val[y]
+        self.val[y] = tmp
+
+        # updates the position of the corresponding elements
+        self.pos[self.val[x]] = x
+        self.pos[self.val[y]] = y
+
+    # Inserts a new key k
+    cdef void insert_key(self, int k, int[:] scores):
+        """Insert new element into the heap"""
+        # First insert the new key at the end
+        self.val[self.size] = k
+        self.pos[k] = self.size
+        cdef int i = self.size
+        self.size += 1
+
+        cdef int p = parent(i)
+        while (p >= 0) and (scores[self.val[p]] > scores[self.val[i]]) :
+            self.swap(i, p)
+            i = p
+            p = parent(i)
+
+
+    cdef void decrease_key(self, int i, int[:] scores):
+        """Decrease value of key at index 'i' to new_val.
+        It is assumed that the new value is smaller than the old one.
+        """
+        cdef int pos, p
+        pos = self.pos[i]
+        if pos < self.size:
+            p = parent(pos)
+
+            while (pos != 0) and (scores[self.val[p]] > scores[self.val[pos]]):
+                self.swap(pos, p)
+                pos = p
+                p = parent(pos)
+
+    cdef int pop_min(self, int[:] scores):
+        """Remove and return the minimum element (or root) from the heap."""
+        if self.size == 1:
+            self.size = 0
+            return self.val[0]
+
+        # Store the minimum value, and remove it from heap
+        cdef int root = self.val[0]
+        self.val[0] = self.val[self.size-1]
+        self.pos[self.val[0]] = 0
+        self.size -= 1
+        self.min_heapify(0, scores)
+
+        return root
+
+    cdef void min_heapify(self, int i, int[:] scores):
+        """A recursive method to heapify a subtree with the root at given index
+        This function assumes that the subtrees are already heapified.
+        """
+        cdef int l, r, smallest
+        l = left(i)
+        r = right(i)
+        smallest = i
+        if (l < self.size) and (scores[self.val[l]] < scores[self.val[i]]):
+            smallest = l
+
+        if (r < self.size) and (scores[self.val[r]] < scores[self.val[smallest]]):
+            smallest = r
+
+        if smallest != i:
+            self.swap(i, smallest)
+            self.min_heapify(smallest, scores)

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