code: def overlap(
      input_graph: Graph,
      vertex_pair: cudf.DataFrame = None,
      do_expensive_check: bool = False,  # deprecated
      use_weight: bool = False,
  ):
      """
      Compute the Overlap Coefficient between each pair of vertices connected by
      an edge, or between arbitrary pairs of vertices specified by the user.
      Overlap Coefficient is defined between two sets as the ratio of the volume
      of their intersection divided by the smaller of their two volumes. In the
      context of graphs, the neighborhood of a vertex is seen as a set. The
      Overlap Coefficient weight of each edge represents the strength of
      connection between vertices based on the relative similarity of their
      neighbors. If first is specified but second is not, or vice versa, an
      exception will be thrown.
  
      cugraph.overlap, in the absence of a specified vertex pair list, will
      compute the two_hop_neighbors of the entire graph to construct a vertex pair
      list and will return the overlap coefficient for those vertex pairs. This is
      not advisable as the vertex_pairs can grow exponentially with respect to the
      size of the datasets
  
      Parameters
      ----------
      input_graph : cugraph.Graph
          cuGraph Graph instance, should contain the connectivity information
          as an edge list. The adjacency list will be computed if not already
          present.
  
          This implementation only supports undirected, non-multi edge Graph.
      vertex_pair : cudf.DataFrame, optional (default=None)
          A GPU dataframe consisting of two columns representing pairs of
          vertices. If provided, the overlap coefficient is computed for the
          given vertex pairs, else, it is computed for all vertex pairs.
  
      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.
  
      use_weight : bool, optional (default=False)
          Flag to indicate whether to compute weighted overlap (if use_weight==True)
          or un-weighted overlap (if use_weight==False).
          'input_graph' must be weighted if 'use_weight=True'.
  
  
  
      Returns
      -------
      df : cudf.DataFrame
          GPU data frame of size E (the default) or the size of the given pairs
          (first, second) containing the Overlap coefficients. 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['overlap_coeff'] : cudf.Series
              The computed overlap coefficient between the first and the second
              vertex ID.
  
      Examples
      --------
      >>> from cugraph.datasets import karate
      >>> from cugraph import overlap
      >>> input_graph = karate.get_graph(download=True, ignore_weights=True)
      >>> df = overlap(input_graph)
  
      """
      if do_expensive_check:
          warnings.warn(
              "do_expensive_check is deprecated since vertex IDs are no longer "
              "required to be consecutively numbered",
              FutureWarning,
          )
  
      if input_graph.is_directed():
          raise ValueError("Input must be an undirected Graph.")
  
      if vertex_pair is None:
          # Call two_hop neighbor of the entire graph
          vertex_pair = input_graph.get_two_hop_neighbors()
  
      v_p_num_col = len(vertex_pair.columns)
  
      if isinstance(vertex_pair, cudf.DataFrame):
          vertex_pair = renumber_vertex_pair(input_graph, vertex_pair)
          vertex_pair = ensure_valid_dtype(input_graph, vertex_pair)
          src_col_name = vertex_pair.columns[0]
          dst_col_name = vertex_pair.columns[1]
          first = vertex_pair[src_col_name]
          second = vertex_pair[dst_col_name]
  
      elif vertex_pair is not None:
          raise ValueError("vertex_pair must be a cudf dataframe")
  
      first, second, overlap_coeff = pylibcugraph_overlap_coefficients(
          resource_handle=ResourceHandle(),
          graph=input_graph._plc_graph,
          first=first,
          second=second,
          use_weight=use_weight,
          do_expensive_check=False,
      )
  
      if input_graph.renumbered:
          vertex_pair = input_graph.unrenumber(
              vertex_pair, src_col_name, preserve_order=True
          )
          vertex_pair = input_graph.unrenumber(
              vertex_pair, dst_col_name, preserve_order=True
          )
  
      if v_p_num_col == 2:
          # single column vertex
          vertex_pair = vertex_pair.rename(
              columns={src_col_name: "first", dst_col_name: "second"}
          )
  
      df = vertex_pair
      df["overlap_coeff"] = cudf.Series(overlap_coeff)
  
      return df
  
file_path: cugraph/python/cugraph/cugraph/link_prediction/overlap.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 overlap_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: overlap(input_graph, vertex_pair, do_expensive_check, use_weight) and returns: df