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

sknetwork/path/metrics.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on May, 2020
-@author: Nathan de Lara <nathan.delara@polytechnique.org>
-"""
-from typing import Union, Optional
-
-import numpy as np
-from scipy import sparse
-
-from sknetwork.path.shortest_path import get_distances
-
-
-def get_diameter(adjacency: Union[sparse.csr_matrix, np.ndarray],
-                 n_sources: Optional[Union[int, float]] = None,
-                 unweighted: bool = False, n_jobs: Optional[int] = None) -> int:
-    """Lower bound on the diameter of a graph which is the length of the longest
-    shortest path between two nodes.
-
-
-    Parameters
-    ----------
-    adjacency :
-        Adjacency matrix of the graph.
-    n_sources :
-        Number of node sources to use for approximation.
-
-        * If None, compute exact diameter.
-        * If int, sample n_sample source nodes at random.
-        * If float, sample (n_samples * n) source nodes at random.
-    unweighted:
-        Whether or not the graph is unweighted.
-    n_jobs :
-        If an integer value is given, denotes the number of workers to use (-1
-        means the maximum number will be used).
-        If ``None``, no parallel computations are made.
-
-    Returns
-    -------
-    diameter : int
-
-    Examples
-    --------
-    >>> from sknetwork.data import house
-    >>> adjacency = house()
-    >>> d_exact = get_diameter(adjacency)
-    >>> d_exact
-    2
-    >>> d_approx = get_diameter(adjacency, 2)
-    >>> d_approx <= d_exact
-    True
-    >>> d_approx = get_diameter(adjacency, 0.5)
-    >>> d_approx <= d_exact
-    True
-
-    Notes
-    -----
-    This is a basic implementation that computes distances between nodes and
-    returns the maximum.
-    """
-    n = adjacency.shape[0]
-    if n_sources is None or n_sources == n:
-        sources = np.arange(n)
-    else:
-        if np.issubdtype(type(n_sources), np.floating) and n_sources < 1.:
-            n_sources = int(n_sources * n)
-        if np.issubdtype(type(n_sources), np.integer) and n_sources <= n:
-            sources = np.random.choice(n, n_sources, replace=False)
-        else:
-            raise ValueError("n_sources must be either None, an integer smaller"
-                             "than the number of nodes or a float"
-                             "smaller than 1.")
-    dists = get_distances(adjacency, sources, method='D', return_predecessors=False,
-                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
-    return dists.max()
-
-
-def get_radius(adjacency: Union[sparse.csr_matrix, np.ndarray],
-               n_sources: Optional[Union[int, float]] = None,
-               unweighted: bool = False, n_jobs: Optional[int] = None) -> int:
-    """Computes the radius of the graph which. The radius of the graph is the
-    minimum eccentricity of the graph.
-
-    Parameters
-    ----------
-    adjacency :
-        Adjacency matrix of the graph.
-    n_sources :
-        Number of node sources to use for approximation.
-
-        * If None, compute exact diameter.
-        * If int, sample n_sample source nodes at random.
-        * If float, sample (n_samples * n) source nodes at random.
-    unweighted:
-        Whether the graph is unweighted.
-    n_jobs :
-        If an integer value is given, denotes the number of workers to use (-1
-        means the maximum number will be used).
-        If ``None``, no parallel computations are made.
-
-    Returns
-    -------
-    radius : int
-
-    Notes
-    -----
-    This is a basic implementation that computes distances between nodes and
-    returns the maximum.
-    """
-
-    # Get the nodes.
-    dists = get_distances(adjacency, sources=n_sources, method='D',
-                          return_predecessors=False,
-                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
-    # Get the eccentricities of each node.
-    eccentricities = dists.max(axis=1)
-
-    return eccentricities.min()
-
-
-def get_eccentricity(adjacency: Union[sparse.csr_matrix, np.ndarray], node: int,
-                     unweighted: bool = False,
-                     n_jobs: Optional[int] = None) -> int:
-    """Computes the eccentricity of a node. The eccentricity of a node, u, is the
-    maximum length of the shortest paths from u to the other nodes in the graph.
-
-    Parameters
-    ----------
-    adjacency :
-        Adjacency matrix of the graph.
-    node:
-        The node to compute the eccentricity for.
-    unweighted:
-        Whether or not the graph is unweighted.
-    n_jobs :
-        If an integer value is given, denotes the number of workers to use (-1
-        means the maximum number will be used).
-        If ``None``, no parallel computations are made.
-
-    Returns
-    -------
-    eccentricity : int
-    """
-
-    dists = get_distances(adjacency, node, method='D', return_predecessors=False,
-                          unweighted=unweighted, n_jobs=n_jobs).astype(int)
-    return dists.max()

sknetwork/path/tests/test_metrics.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-""""tests for metrics.py"""
-import unittest
-
-from sknetwork.data import house
-from sknetwork.path import get_diameter, get_eccentricity, get_radius
-
-
-
-class TestMetrics(unittest.TestCase):
-
-    def test_diameter_1(self):
-        adjacency = house()
-        with self.assertRaises(ValueError):
-            get_diameter(adjacency, 2.5)
-    def test_diameter_2(self):
-        adjacency = house()
-        self.assertEqual(get_diameter(adjacency), 2)
-    def test_eccentricity_1(self):
-        adjacency = house()
-        self.assertEqual(get_eccentricity(adjacency, 1), 2)
-    def test_radius_1(self):
-        adjacency = house()
-        self.assertEqual(get_radius(adjacency), 2)
-    def test_radius_2(self):
-        adjacency = house()
-        self.assertEqual(get_radius(adjacency,[0,1]), 2)
-

sknetwork/ranking/harmonic.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on November 19 2019
-@author: Quentin Lutz <qlutz@enst.fr>
-"""
-from typing import Union, Optional
-
-import numpy as np
-from scipy import sparse
-
-from sknetwork.path.shortest_path import get_distances
-from sknetwork.ranking.base import BaseRanking
-from sknetwork.utils.check import check_format, check_square
-
-
-class Harmonic(BaseRanking):
-    """Harmonic centrality of each node in a connected graph, corresponding to the average inverse length of
-    the shortest paths from that node to all the other ones.
-
-    For a directed graph, the harmonic centrality is computed in terms of outgoing paths.
-
-    Parameters
-    ----------
-    n_jobs:
-        If an integer value is given, denotes the number of workers to use (-1 means the maximum number will be used).
-        If ``None``, no parallel computations are made.
-
-    Attributes
-    ----------
-    scores_ : np.ndarray
-        Score of each node.
-
-    Example
-    -------
-    >>> from sknetwork.ranking import Harmonic
-    >>> from sknetwork.data import house
-    >>> harmonic = Harmonic()
-    >>> adjacency = house()
-    >>> scores = harmonic.fit_predict(adjacency)
-    >>> np.round(scores, 2)
-    array([3. , 3.5, 3. , 3. , 3.5])
-
-    References
-    ----------
-    Marchiori, M., & Latora, V. (2000).
-    `Harmony in the small-world.
-    <https://arxiv.org/pdf/cond-mat/0008357.pdf>`_
-    Physica A: Statistical Mechanics and its Applications, 285(3-4), 539-546.
-    """
-
-    def __init__(self, n_jobs: Optional[int] = None):
-        super(Harmonic, self).__init__()
-
-        self.n_jobs = n_jobs
-
-    def fit(self, adjacency: Union[sparse.csr_matrix, np.ndarray]) -> 'Harmonic':
-        """Harmonic centrality for connected graphs.
-
-        Parameters
-        ----------
-        adjacency :
-            Adjacency matrix of the graph.
-
-        Returns
-        -------
-        self: :class:`Harmonic`
-        """
-        adjacency = check_format(adjacency)
-        check_square(adjacency)
-        n = adjacency.shape[0]
-        indices = np.arange(n)
-
-        dists = get_distances(adjacency, n_jobs=self.n_jobs, sources=indices)
-
-        np.fill_diagonal(dists, 1)
-        inv = (1 / dists)
-        np.fill_diagonal(inv, 0)
-
-        self.scores_ = inv.dot(np.ones(n))
-
-        return self

sknetwork/topology/dag.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Jun 3, 2020
-@author: Nathan de Lara <nathan.delara@polytechnique.org>
-"""
-import numpy as np
-from scipy import sparse
-from sknetwork.topology.dag_core import fit_core
-
-from sknetwork.utils.base import Algorithm
-
-
-class DAG(Algorithm):
-    """Build a Directed Acyclic Graph from an adjacency.
-
-    * Graphs
-    * DiGraphs
-
-    Parameters
-    ----------
-    ordering : str
-        A method to sort the nodes.
-
-        * If None, the default order is the index.
-        * If ``'degree'``, the nodes are sorted by ascending degree.
-
-    Attributes
-    ----------
-    indptr_ : np.ndarray
-        Pointer index as for CSR format.
-    indices_ : np.ndarray
-        Indices as for CSR format.
-    """
-    def __init__(self, ordering: str = None):
-        super(DAG, self).__init__()
-        self.ordering = ordering
-        self.indptr_ = None
-        self.indices_ = None
-
-    def fit(self, adjacency: sparse.csr_matrix, sorted_nodes=None):
-        """Fit algorithm to the data.
-
-        Parameters
-        ----------
-        adjacency :
-            Adjacency matrix of the graph.
-        sorted_nodes : np.ndarray
-            An order on the nodes such that the DAG only contains edges (i, j) such that
-            ``sorted_nodes[i] < sorted_nodes[j]``.
-        """
-        indptr = adjacency.indptr.astype(np.int32)
-        indices = adjacency.indices.astype(np.int32)
-
-        if sorted_nodes is not None:
-            if adjacency.shape[0] != sorted_nodes.shape[0]:
-                raise ValueError('Dimensions mismatch between adjacency and sorted_nodes.')
-            else:
-                sorted_nodes = sorted_nodes.astype(np.int32)
-        else:
-            if self.ordering is None:
-                sorted_nodes = np.arange(adjacency.shape[0]).astype(np.int32)
-            elif self.ordering == 'degree':
-                degrees = indptr[1:] - indptr[:-1]
-                sorted_nodes = np.argsort(degrees).astype(np.int32)
-            else:
-                raise ValueError('Unknown ordering of nodes.')
-
-        ix = np.zeros(adjacency.shape[0], dtype=np.int32)
-        dag_indptr, dag_indices = fit_core(indptr, indices, sorted_nodes, ix)
-        self.indptr_ = np.asarray(dag_indptr)
-        self.indices_ = np.asarray(dag_indices)
-
-        return self