Skip to main content
`Ctrl`+`K`

# Source code for networkx.algorithms.link_prediction

    """
    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