code: def ecg(input_graph, min_weight=0.05, ensemble_size=16, weight=None):
      """
      Compute the Ensemble Clustering for Graphs (ECG) partition of the input
      graph. ECG runs truncated Louvain on an ensemble of permutations of the
      input graph, then uses the ensemble partitions to determine weights for
      the input graph. The final result is found by running full Louvain on
      the input graph using the determined weights.
  
      See https://arxiv.org/abs/1809.05578 for further information.
  
      Parameters
      ----------
      input_graph : cugraph.Graph or NetworkX Graph
          The graph descriptor should contain the connectivity information
          and weights. The adjacency list will be computed if not already
          present.
  
      min_weight : float, optional (default=0.5)
          The minimum value to assign as an edgeweight in the ECG algorithm.
          It should be a value in the range [0,1] usually left as the default
          value of .05
  
      ensemble_size : integer, optional (default=16)
          The number of graph permutations to use for the ensemble.
          The default value is 16, larger values may produce higher quality
          partitions for some graphs.
  
      weight : str, optional (default=None)
          This parameter is here for NetworkX compatibility and
          represents which NetworkX data column represents Edge weights.
  
      Returns
      -------
      parts : cudf.DataFrame or python dictionary
          GPU data frame of size V containing two columns, the vertex id and
          the partition id it is assigned to.
  
          df[vertex] : cudf.Series
              Contains the vertex identifiers
          df[partition] : cudf.Series
              Contains the partition assigned to the vertices
  
      Examples
      --------
      >>> from cugraph.datasets import karate
      >>> G = karate.get_graph(download=True)
      >>> parts = cugraph.ecg(G)
  
      """
  
      input_graph, isNx = ensure_cugraph_obj_for_nx(input_graph)
  
      vertex, partition = pylibcugraph_ecg(
          resource_handle=ResourceHandle(),
          graph=input_graph._plc_graph,
          min_weight=min_weight,
          ensemble_size=ensemble_size,
          do_expensive_check=False,
      )
  
      df = cudf.DataFrame()
      df["vertex"] = vertex
      df["partition"] = partition
  
      if input_graph.renumbered:
          df = input_graph.unrenumber(df, "vertex")
  
      if isNx is True:
          df = df_score_to_dictionary(df, "partition")
  
      return df
  
imports: from cugraph.utilities import ensure_cugraph_obj_for_nx, df_score_to_dictionary
  import cudf
  from pylibcugraph import ecg
  from pylibcugraph import ResourceHandle
label_desc: Use image node_id 1 for calling a global function with example usage: ecg(input_graph, min_weight, ensemble_size, weight) and returns: df