okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/algorithms/link_prediction.py

@@ -1,687 +0,0 @@
-"""
-Link prediction algorithms.
-"""
-
-from math import log
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = [
-    "resource_allocation_index",
-    "jaccard_coefficient",
-    "adamic_adar_index",
-    "preferential_attachment",
-    "cn_soundarajan_hopcroft",
-    "ra_index_soundarajan_hopcroft",
-    "within_inter_cluster",
-    "common_neighbor_centrality",
-]
-
-
-def _apply_prediction(G, func, ebunch=None):
-    """Applies the given function to each edge in the specified iterable
-    of edges.
-
-    `G` is an instance of :class:`networkx.Graph`.
-
-    `func` is a function on two inputs, each of which is a node in the
-    graph. The function can return anything, but it should return a
-    value representing a prediction of the likelihood of a "link"
-    joining the two nodes.
-
-    `ebunch` is an iterable of pairs of nodes. If not specified, all
-    non-edges in the graph `G` will be used.
-
-    """
-    if ebunch is None:
-        ebunch = nx.non_edges(G)
-    else:
-        for u, v in ebunch:
-            if u not in G:
-                raise nx.NodeNotFound(f"Node {u} not in G.")
-            if v not in G:
-                raise nx.NodeNotFound(f"Node {v} not in G.")
-    return ((u, v, func(u, v)) for u, v in ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def resource_allocation_index(G, ebunch=None):
-    r"""Compute the resource allocation index of all node pairs in ebunch.
-
-    Resource allocation index of `u` and `v` is defined as
-
-    .. math::
-
-        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{1}{|\Gamma(w)|}
-
-    where $\Gamma(u)$ denotes the set of neighbors of $u$.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        Resource allocation index will be computed for each pair of
-        nodes given in the iterable. The pairs must be given as
-        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
-        is None then all nonexistent edges in the graph will be used.
-        Default value: None.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their resource allocation index.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> preds = nx.resource_allocation_index(G, [(0, 1), (2, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 1) -> 0.75000000
-    (2, 3) -> 0.75000000
-
-    References
-    ----------
-    .. [1] T. Zhou, L. Lu, Y.-C. Zhang.
-       Predicting missing links via local information.
-       Eur. Phys. J. B 71 (2009) 623.
-       https://arxiv.org/pdf/0901.0553.pdf
-    """
-
-    def predict(u, v):
-        return sum(1 / G.degree(w) for w in nx.common_neighbors(G, u, v))
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def jaccard_coefficient(G, ebunch=None):
-    r"""Compute the Jaccard coefficient of all node pairs in ebunch.
-
-    Jaccard coefficient of nodes `u` and `v` is defined as
-
-    .. math::
-
-        \frac{|\Gamma(u) \cap \Gamma(v)|}{|\Gamma(u) \cup \Gamma(v)|}
-
-    where $\Gamma(u)$ denotes the set of neighbors of $u$.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        Jaccard coefficient will be computed for each pair of nodes
-        given in the iterable. The pairs must be given as 2-tuples
-        (u, v) where u and v are nodes in the graph. If ebunch is None
-        then all nonexistent edges in the graph will be used.
-        Default value: None.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their Jaccard coefficient.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> preds = nx.jaccard_coefficient(G, [(0, 1), (2, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 1) -> 0.60000000
-    (2, 3) -> 0.60000000
-
-    References
-    ----------
-    .. [1] D. Liben-Nowell, J. Kleinberg.
-           The Link Prediction Problem for Social Networks (2004).
-           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
-    """
-
-    def predict(u, v):
-        union_size = len(set(G[u]) | set(G[v]))
-        if union_size == 0:
-            return 0
-        return len(nx.common_neighbors(G, u, v)) / union_size
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def adamic_adar_index(G, ebunch=None):
-    r"""Compute the Adamic-Adar index of all node pairs in ebunch.
-
-    Adamic-Adar index of `u` and `v` is defined as
-
-    .. math::
-
-        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{1}{\log |\Gamma(w)|}
-
-    where $\Gamma(u)$ denotes the set of neighbors of $u$.
-    This index leads to zero-division for nodes only connected via self-loops.
-    It is intended to be used when no self-loops are present.
-
-    Parameters
-    ----------
-    G : graph
-        NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        Adamic-Adar index will be computed for each pair of nodes given
-        in the iterable. The pairs must be given as 2-tuples (u, v)
-        where u and v are nodes in the graph. If ebunch is None then all
-        nonexistent edges in the graph will be used.
-        Default value: None.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their Adamic-Adar index.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> preds = nx.adamic_adar_index(G, [(0, 1), (2, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 1) -> 2.16404256
-    (2, 3) -> 2.16404256
-
-    References
-    ----------
-    .. [1] D. Liben-Nowell, J. Kleinberg.
-           The Link Prediction Problem for Social Networks (2004).
-           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
-    """
-
-    def predict(u, v):
-        return sum(1 / log(G.degree(w)) for w in nx.common_neighbors(G, u, v))
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def common_neighbor_centrality(G, ebunch=None, alpha=0.8):
-    r"""Return the CCPA score for each pair of nodes.
-
-    Compute the Common Neighbor and Centrality based Parameterized Algorithm(CCPA)
-    score of all node pairs in ebunch.
-
-    CCPA score of `u` and `v` is defined as
-
-    .. math::
-
-        \alpha \cdot (|\Gamma (u){\cap }^{}\Gamma (v)|)+(1-\alpha )\cdot \frac{N}{{d}_{uv}}
-
-    where $\Gamma(u)$ denotes the set of neighbors of $u$, $\Gamma(v)$ denotes the
-    set of neighbors of $v$, $\alpha$ is  parameter varies between [0,1], $N$ denotes
-    total number of nodes in the Graph and ${d}_{uv}$ denotes shortest distance
-    between $u$ and $v$.
-
-    This algorithm is based on two vital properties of nodes, namely the number
-    of common neighbors and their centrality. Common neighbor refers to the common
-    nodes between two nodes. Centrality refers to the prestige that a node enjoys
-    in a network.
-
-    .. seealso::
-
-        :func:`common_neighbors`
-
-    Parameters
-    ----------
-    G : graph
-        NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        Preferential attachment score will be computed for each pair of
-        nodes given in the iterable. The pairs must be given as
-        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
-        is None then all nonexistent edges in the graph will be used.
-        Default value: None.
-
-    alpha : Parameter defined for participation of Common Neighbor
-            and Centrality Algorithm share. Values for alpha should
-            normally be between 0 and 1. Default value set to 0.8
-            because author found better performance at 0.8 for all the
-            dataset.
-            Default value: 0.8
-
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their Common Neighbor and Centrality based
-        Parameterized Algorithm(CCPA) score.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NetworkXAlgorithmError
-        If self loops exist in `ebunch` or in `G` (if `ebunch` is `None`).
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> preds = nx.common_neighbor_centrality(G, [(0, 1), (2, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p}")
-    (0, 1) -> 3.4000000000000004
-    (2, 3) -> 3.4000000000000004
-
-    References
-    ----------
-    .. [1] Ahmad, I., Akhtar, M.U., Noor, S. et al.
-           Missing Link Prediction using Common Neighbor and Centrality based Parameterized Algorithm.
-           Sci Rep 10, 364 (2020).
-           https://doi.org/10.1038/s41598-019-57304-y
-    """
-
-    # When alpha == 1, the CCPA score simplifies to the number of common neighbors.
-    if alpha == 1:
-
-        def predict(u, v):
-            if u == v:
-                raise nx.NetworkXAlgorithmError("Self loops are not supported")
-
-            return len(nx.common_neighbors(G, u, v))
-
-    else:
-        spl = dict(nx.shortest_path_length(G))
-        inf = float("inf")
-
-        def predict(u, v):
-            if u == v:
-                raise nx.NetworkXAlgorithmError("Self loops are not supported")
-            path_len = spl[u].get(v, inf)
-
-            n_nbrs = len(nx.common_neighbors(G, u, v))
-            return alpha * n_nbrs + (1 - alpha) * len(G) / path_len
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def preferential_attachment(G, ebunch=None):
-    r"""Compute the preferential attachment score of all node pairs in ebunch.
-
-    Preferential attachment score of `u` and `v` is defined as
-
-    .. math::
-
-        |\Gamma(u)| |\Gamma(v)|
-
-    where $\Gamma(u)$ denotes the set of neighbors of $u$.
-
-    Parameters
-    ----------
-    G : graph
-        NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        Preferential attachment score will be computed for each pair of
-        nodes given in the iterable. The pairs must be given as
-        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
-        is None then all nonexistent edges in the graph will be used.
-        Default value: None.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their preferential attachment score.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> preds = nx.preferential_attachment(G, [(0, 1), (2, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p}")
-    (0, 1) -> 16
-    (2, 3) -> 16
-
-    References
-    ----------
-    .. [1] D. Liben-Nowell, J. Kleinberg.
-           The Link Prediction Problem for Social Networks (2004).
-           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
-    """
-
-    def predict(u, v):
-        return G.degree(u) * G.degree(v)
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(node_attrs="community")
-def cn_soundarajan_hopcroft(G, ebunch=None, community="community"):
-    r"""Count the number of common neighbors of all node pairs in ebunch
-        using community information.
-
-    For two nodes $u$ and $v$, this function computes the number of
-    common neighbors and bonus one for each common neighbor belonging to
-    the same community as $u$ and $v$. Mathematically,
-
-    .. math::
-
-        |\Gamma(u) \cap \Gamma(v)| + \sum_{w \in \Gamma(u) \cap \Gamma(v)} f(w)
-
-    where $f(w)$ equals 1 if $w$ belongs to the same community as $u$
-    and $v$ or 0 otherwise and $\Gamma(u)$ denotes the set of
-    neighbors of $u$.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        The score will be computed for each pair of nodes given in the
-        iterable. The pairs must be given as 2-tuples (u, v) where u
-        and v are nodes in the graph. If ebunch is None then all
-        nonexistent edges in the graph will be used.
-        Default value: None.
-
-    community : string, optional (default = 'community')
-        Nodes attribute name containing the community information.
-        G[u][community] identifies which community u belongs to. Each
-        node belongs to at most one community. Default value: 'community'.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their score.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NetworkXAlgorithmError
-        If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(3)
-    >>> G.nodes[0]["community"] = 0
-    >>> G.nodes[1]["community"] = 0
-    >>> G.nodes[2]["community"] = 0
-    >>> preds = nx.cn_soundarajan_hopcroft(G, [(0, 2)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p}")
-    (0, 2) -> 2
-
-    References
-    ----------
-    .. [1] Sucheta Soundarajan and John Hopcroft.
-       Using community information to improve the precision of link
-       prediction methods.
-       In Proceedings of the 21st international conference companion on
-       World Wide Web (WWW '12 Companion). ACM, New York, NY, USA, 607-608.
-       http://doi.acm.org/10.1145/2187980.2188150
-    """
-
-    def predict(u, v):
-        Cu = _community(G, u, community)
-        Cv = _community(G, v, community)
-        cnbors = nx.common_neighbors(G, u, v)
-        neighbors = (
-            sum(_community(G, w, community) == Cu for w in cnbors) if Cu == Cv else 0
-        )
-        return len(cnbors) + neighbors
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(node_attrs="community")
-def ra_index_soundarajan_hopcroft(G, ebunch=None, community="community"):
-    r"""Compute the resource allocation index of all node pairs in
-    ebunch using community information.
-
-    For two nodes $u$ and $v$, this function computes the resource
-    allocation index considering only common neighbors belonging to the
-    same community as $u$ and $v$. Mathematically,
-
-    .. math::
-
-        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{f(w)}{|\Gamma(w)|}
-
-    where $f(w)$ equals 1 if $w$ belongs to the same community as $u$
-    and $v$ or 0 otherwise and $\Gamma(u)$ denotes the set of
-    neighbors of $u$.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        The score will be computed for each pair of nodes given in the
-        iterable. The pairs must be given as 2-tuples (u, v) where u
-        and v are nodes in the graph. If ebunch is None then all
-        nonexistent edges in the graph will be used.
-        Default value: None.
-
-    community : string, optional (default = 'community')
-        Nodes attribute name containing the community information.
-        G[u][community] identifies which community u belongs to. Each
-        node belongs to at most one community. Default value: 'community'.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their score.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NetworkXAlgorithmError
-        If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
-    >>> G.nodes[0]["community"] = 0
-    >>> G.nodes[1]["community"] = 0
-    >>> G.nodes[2]["community"] = 1
-    >>> G.nodes[3]["community"] = 0
-    >>> preds = nx.ra_index_soundarajan_hopcroft(G, [(0, 3)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 3) -> 0.50000000
-
-    References
-    ----------
-    .. [1] Sucheta Soundarajan and John Hopcroft.
-       Using community information to improve the precision of link
-       prediction methods.
-       In Proceedings of the 21st international conference companion on
-       World Wide Web (WWW '12 Companion). ACM, New York, NY, USA, 607-608.
-       http://doi.acm.org/10.1145/2187980.2188150
-    """
-
-    def predict(u, v):
-        Cu = _community(G, u, community)
-        Cv = _community(G, v, community)
-        if Cu != Cv:
-            return 0
-        cnbors = nx.common_neighbors(G, u, v)
-        return sum(1 / G.degree(w) for w in cnbors if _community(G, w, community) == Cu)
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(node_attrs="community")
-def within_inter_cluster(G, ebunch=None, delta=0.001, community="community"):
-    """Compute the ratio of within- and inter-cluster common neighbors
-    of all node pairs in ebunch.
-
-    For two nodes `u` and `v`, if a common neighbor `w` belongs to the
-    same community as them, `w` is considered as within-cluster common
-    neighbor of `u` and `v`. Otherwise, it is considered as
-    inter-cluster common neighbor of `u` and `v`. The ratio between the
-    size of the set of within- and inter-cluster common neighbors is
-    defined as the WIC measure. [1]_
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX undirected graph.
-
-    ebunch : iterable of node pairs, optional (default = None)
-        The WIC measure will be computed for each pair of nodes given in
-        the iterable. The pairs must be given as 2-tuples (u, v) where
-        u and v are nodes in the graph. If ebunch is None then all
-        nonexistent edges in the graph will be used.
-        Default value: None.
-
-    delta : float, optional (default = 0.001)
-        Value to prevent division by zero in case there is no
-        inter-cluster common neighbor between two nodes. See [1]_ for
-        details. Default value: 0.001.
-
-    community : string, optional (default = 'community')
-        Nodes attribute name containing the community information.
-        G[u][community] identifies which community u belongs to. Each
-        node belongs to at most one community. Default value: 'community'.
-
-    Returns
-    -------
-    piter : iterator
-        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
-        pair of nodes and p is their WIC measure.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
-
-    NetworkXAlgorithmError
-        - If `delta` is less than or equal to zero.
-        - If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
-
-    NodeNotFound
-        If `ebunch` has a node that is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edges_from([(0, 1), (0, 2), (0, 3), (1, 4), (2, 4), (3, 4)])
-    >>> G.nodes[0]["community"] = 0
-    >>> G.nodes[1]["community"] = 1
-    >>> G.nodes[2]["community"] = 0
-    >>> G.nodes[3]["community"] = 0
-    >>> G.nodes[4]["community"] = 0
-    >>> preds = nx.within_inter_cluster(G, [(0, 4)])
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 4) -> 1.99800200
-    >>> preds = nx.within_inter_cluster(G, [(0, 4)], delta=0.5)
-    >>> for u, v, p in preds:
-    ...     print(f"({u}, {v}) -> {p:.8f}")
-    (0, 4) -> 1.33333333
-
-    References
-    ----------
-    .. [1] Jorge Carlos Valverde-Rebaza and Alneu de Andrade Lopes.
-       Link prediction in complex networks based on cluster information.
-       In Proceedings of the 21st Brazilian conference on Advances in
-       Artificial Intelligence (SBIA'12)
-       https://doi.org/10.1007/978-3-642-34459-6_10
-    """
-    if delta <= 0:
-        raise nx.NetworkXAlgorithmError("Delta must be greater than zero")
-
-    def predict(u, v):
-        Cu = _community(G, u, community)
-        Cv = _community(G, v, community)
-        if Cu != Cv:
-            return 0
-        cnbors = nx.common_neighbors(G, u, v)
-        within = {w for w in cnbors if _community(G, w, community) == Cu}
-        inter = cnbors - within
-        return len(within) / (len(inter) + delta)
-
-    return _apply_prediction(G, predict, ebunch)
-
-
-def _community(G, u, community):
-    """Get the community of the given node."""
-    node_u = G.nodes[u]
-    try:
-        return node_u[community]
-    except KeyError as err:
-        raise nx.NetworkXAlgorithmError(
-            f"No community information available for Node {u}"
-        ) from err