code: def jaccard_coefficient(
      G: Union[Graph, "networkx.Graph"],
      ebunch: Union[
          cudf.DataFrame, Iterable[Union[int, str, float]]
      ] = None,
      do_expensive_check: bool = False,  # deprecated
  ):
      """
      For NetworkX Compatability.  See `jaccard`
  
      Parameters
      ----------
      G : cugraph.Graph or NetworkX.Graph
          cuGraph or NetworkX Graph instance, should contain the connectivity
          information as an edge list. The graph should be undirected where an
          undirected edge is represented by a directed edge in both direction.
          The adjacency list will be computed if not already present.
  
          This implementation only supports undirected, non-multi Graphs.
  
      ebunch : cudf.DataFrame or iterable of node pairs, optional (default=None)
          A GPU dataframe consisting of two columns representing pairs of
          vertices or iterable of 2-tuples (u, v) where u and v are nodes in
          the graph.
  
          If provided, the Overlap coefficient is computed for the given vertex
          pairs. Otherwise, the current implementation computes the overlap
          coefficient for all adjacent vertices in the graph.
  
      do_expensive_check : bool, optional (default=False)
          Deprecated.
                  This option added a check to ensure integer vertex IDs are sequential
          values from 0 to V-1. That check is now redundant because cugraph
          unconditionally renumbers and un-renumbers integer vertex IDs for
          optimal performance, therefore this option is deprecated and will be
          removed in a future version.
  
      Returns
      -------
      df  : cudf.DataFrame
          GPU data frame of size E (the default) or the size of the given pairs
          (first, second) containing the Jaccard weights. The ordering is
          relative to the adjacency list, or that given by the specified vertex
          pairs.
  
          df['first'] : cudf.Series
              The first vertex ID of each pair (will be identical to first if specified).
          df['second'] : cudf.Series
              the second vertex ID of each pair (will be identical to second if
              specified).
          df['jaccard_coeff'] : cudf.Series
              The computed Jaccard coefficient between the first and the second
              vertex ID.
  
      Examples
      --------
      >>> from cugraph.datasets import karate
      >>> from cugraph import jaccard_coefficient
      >>> G = karate.get_graph(download=True)
      >>> df = jaccard_coefficient(G)
  
      """
      if do_expensive_check:
          warnings.warn(
              "do_expensive_check is deprecated since vertex IDs are no longer "
              "required to be consecutively numbered",
              FutureWarning,
          )
  
      vertex_pair = None
  
      G, isNx = ensure_cugraph_obj_for_nx(G)
  
      if isNx is True and ebunch is not None:
          vertex_pair = cudf.DataFrame(ebunch)
  
      df = jaccard(G, vertex_pair)
  
      if isNx is True:
          df = df_edge_score_to_dictionary(
              df, k="jaccard_coeff", src="first", dst="second"
          )
  
      return df
  
file_path: cugraph/python/cugraph/cugraph/link_prediction/jaccard.py
imports: from cugraph.utilities import ensure_cugraph_obj_for_nx, df_edge_score_to_dictionary, renumber_vertex_pair
  import cudf
  import warnings
  from typing import Union, Iterable
  from pylibcugraph import jaccard_coefficients
  from pylibcugraph import ResourceHandle
  from cugraph.structure import Graph
  from cugraph.utilities.utils import import_optional
label_desc: Use image node_id 3 for calling a global function with example usage: jaccard_coefficient(G, ebunch, do_expensive_check) and returns: df