def intercluster_distance(model, 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, **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
    ----------
    model : 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.

    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.

    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(
        model, 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, **kwargs
    )

    oz.fit(X, y)
    oz.poof()
    return oz