code: def intercluster_distance(
      estimator,
      X,
      y=None,
      ax=None,
      min_size=400,
      max_size=25000,
      embedding="mds",
      scoring="membership",
      legend=True,
      legend_loc="lower left",
      legend_size=1.5,
      random_state=None,
      is_fitted="auto",
      show=True,
      **kwargs,
  ):
      """Quick Method:
      Intercluster distance maps display an embedding of the cluster centers in
      2 dimensions with the distance to other centers preserved. E.g. the closer
      to centers are in the visualization, the closer they are in the original
      feature space. The clusters are sized according to a scoring metric. By
      default, they are sized by membership, e.g. the number of instances that
      belong to each center. This gives a sense of the relative importance of
      clusters. Note however, that because two clusters overlap in the 2D space,
      it does not imply that they overlap in the original feature space.
  
      Parameters
      ----------
      estimator : a Scikit-Learn clusterer
          Should be an instance of a centroidal clustering algorithm (or a
          hierarchical algorithm with a specified number of clusters). Also
          accepts some other models like LDA for text clustering.
          If it is not a clusterer, an exception is raised. If the estimator
          is not fitted, it is fit when the visualizer is fitted, unless
          otherwise specified by ``is_fitted``.
  
      X : array-like of shape (n, m)
          A matrix or data frame with n instances and m features
  
      y : array-like of shape (n,), optional
          A vector or series representing the target for each instance
  
      ax : matplotlib Axes, default: None
          The axes to plot the figure on. If None is passed in the current axes
          will be used (or generated if required).
  
      min_size : int, default: 400
          The size, in points, of the smallest cluster drawn on the graph.
          Cluster sizes will be scaled between the min and max sizes.
  
      max_size : int, default: 25000
          The size, in points, of the largest cluster drawn on the graph.
          Cluster sizes will be scaled between the min and max sizes.
  
      embedding : default: 'mds'
          The algorithm used to embed the cluster centers in 2 dimensional space
          so that the distance between clusters is represented equivalently to
          their relationship in feature spaceself.
          Embedding algorithm options include:
  
          - **mds**: multidimensional scaling
          - **tsne**: stochastic neighbor embedding
  
      scoring : default: 'membership'
          The scoring method used to determine the size of the clusters drawn on
          the graph so that the relative importance of clusters can be viewed.
          Scoring method options include:
  
          - **membership**: number of instances belonging to each cluster
  
      legend : bool, default: True
          Whether or not to draw the size legend onto the graph, omit the legend
          to more easily see clusters that overlap.
  
      legend_loc : str, default: "lower left"
          The location of the legend on the graph, used to move the legend out
          of the way of clusters into open space. The same legend location
          options for matplotlib are used here.
  
          .. seealso:: https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.legend
  
      legend_size : float, default: 1.5
          The size, in inches, of the size legend to inset into the graph.
  
      random_state : int or RandomState, default: None
          Fixes the random state for stochastic embedding algorithms.
  
      is_fitted : bool or str, default='auto'
          Specify if the wrapped estimator is already fitted. If False, the estimator
          will be fit when the visualizer is fit, otherwise, the estimator will not be
          modified. If 'auto' (default), a helper method will check if the estimator
          is fitted before fitting it again.
  
      show : bool, default: True
          If True, calls ``show()``, which in turn calls ``plt.show()`` however
          you cannot call ``plt.savefig`` from this signature, nor
          ``clear_figure``. If False, simply calls ``finalize()``
  
      kwargs : dict
          Keyword arguments passed to the base class and may influence the
          feature visualization properties.
  
      Returns
      -------
      viz : InterclusterDistance
          The intercluster distance visualizer, fitted and finalized.
      """
      oz = InterclusterDistance(
          estimator,
          ax=ax,
          min_size=min_size,
          max_size=max_size,
          embedding=embedding,
          scoring=scoring,
          legend=legend,
          legend_loc=legend_loc,
          legend_size=legend_size,
          random_state=random_state,
          is_fitted=is_fitted,
          **kwargs,
      )
  
      oz.fit(X, y)
  
      if show:
          oz.show()
      else:
          oz.finalize()
  
      return oz
  
imports: import numpy
  import matplotlib.pyplot
  from matplotlib.patches import Circle
  from sklearn.manifold import MDS, TSNE
  from yellowbrick.utils.timer import Timer
  from yellowbrick.utils.decorators import memoized
  from yellowbrick.exceptions import YellowbrickValueError
  from yellowbrick.cluster.base import ClusteringScoreVisualizer
  from yellowbrick.utils.helpers import prop_to_size, check_fitted
label_desc: Use image node_id 5 for calling a global function with example usage: intercluster_distance(estimator, X, y, ax, min_size, max_size, embedding, scoring, legend, legend_loc, legend_size, random_state, is_fitted, show) and returns: oz