arviz 0.23.3__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

arviz/plots/loopitplot.py

@@ -1,224 +0,0 @@
-"""Plot LOO-PIT predictive checks of inference data."""
-
-import numpy as np
-from scipy import stats
-
-from ..labels import BaseLabeller
-from ..rcparams import rcParams
-from ..stats import loo_pit as _loo_pit
-from ..stats.density_utils import kde
-from .plot_utils import get_plotting_function
-
-
-def plot_loo_pit(
-    idata=None,
-    y=None,
-    y_hat=None,
-    log_weights=None,
-    ecdf=False,
-    ecdf_fill=True,
-    n_unif=100,
-    use_hdi=False,
-    hdi_prob=None,
-    figsize=None,
-    textsize=None,
-    labeller=None,
-    color="C0",
-    legend=True,
-    ax=None,
-    plot_kwargs=None,
-    plot_unif_kwargs=None,
-    hdi_kwargs=None,
-    fill_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    """Plot Leave-One-Out (LOO) probability integral transformation (PIT) predictive checks.
-
-    Parameters
-    ----------
-    idata : InferenceData
-        :class:`arviz.InferenceData` object.
-    y : array, DataArray or str
-        Observed data. If str, ``idata`` must be present and contain the observed data group
-    y_hat : array, DataArray or str
-        Posterior predictive samples for ``y``. It must have the same shape as y plus an
-        extra dimension at the end of size n_samples (chains and draws stacked). If str or
-        None, ``idata`` must contain the posterior predictive group. If None, ``y_hat`` is taken
-        equal to y, thus, y must be str too.
-    log_weights : array or DataArray
-        Smoothed log_weights. It must have the same shape as ``y_hat``
-    ecdf : bool, optional
-        Plot the difference between the LOO-PIT Empirical Cumulative Distribution Function
-        (ECDF) and the uniform CDF instead of LOO-PIT kde.
-        In this case, instead of overlaying uniform distributions, the beta ``hdi_prob``
-        around the theoretical uniform CDF is shown. This approximation only holds
-        for large S and ECDF values not very close to 0 nor 1. For more information, see
-        `Vehtari et al. (2021)`, `Appendix G <https://avehtari.github.io/rhat_ess/rhat_ess.html>`_.
-    ecdf_fill : bool, optional
-        Use :meth:`matplotlib.axes.Axes.fill_between` to mark the area
-        inside the credible interval. Otherwise, plot the
-        border lines.
-    n_unif : int, optional
-        Number of datasets to simulate and overlay from the uniform distribution.
-    use_hdi : bool, optional
-        Compute expected hdi values instead of overlaying the sampled uniform distributions.
-    hdi_prob : float, optional
-        Probability for the highest density interval. Works with ``use_hdi=True`` or ``ecdf=True``.
-    figsize : (float, float), optional
-        If None, size is (8 + numvars, 8 + numvars)
-    textsize : int, optional
-        Text size for labels. If None it will be autoscaled based on ``figsize``.
-    labeller : Labeller, optional
-        Class providing the method ``make_pp_label`` to generate the labels in the plot titles.
-        Read the :ref:`label_guide` for more details and usage examples.
-    color : str or array_like, optional
-        Color of the LOO-PIT estimated pdf plot. If ``plot_unif_kwargs`` has no "color" key,
-        a slightly lighter color than this argument will be used for the uniform kde lines.
-        This will ensure that LOO-PIT kde and uniform kde have different default colors.
-    legend : bool, optional
-        Show the legend of the figure.
-    ax : axes, optional
-        Matplotlib axes or bokeh figures.
-    plot_kwargs : dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.plot`
-        for LOO-PIT line (kde or ECDF)
-    plot_unif_kwargs : dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.plot` for
-        overlaid uniform distributions or for beta credible interval
-        lines if ``ecdf=True``
-    hdi_kwargs : dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.axhspan`
-    fill_kwargs : dict, optional
-        Additional kwargs passed to :meth:`matplotlib.axes.Axes.fill_between`
-    backend : str, optional
-        Select plotting backend {"matplotlib","bokeh"}. Default "matplotlib".
-    backend_kwargs : bool, optional
-        These are kwargs specific to the backend being used, passed to
-        :func:`matplotlib.pyplot.subplots` or
-        :func:`bokeh.plotting.figure`. For additional documentation
-        check the plotting method of the backend.
-    show : bool, optional
-        Call backend show function.
-
-    Returns
-    -------
-    axes : matplotlib_axes or bokeh_figures
-
-    See Also
-    --------
-    plot_bpv : Plot Bayesian p-value for observed data and Posterior/Prior predictive.
-    loo_pit : Compute leave one out (PSIS-LOO) probability integral transform (PIT) values.
-
-    References
-    ----------
-    * Gabry et al. (2017) see https://arxiv.org/abs/1709.01449
-    * https://mc-stan.org/bayesplot/reference/PPC-loo.html
-    * Gelman et al. BDA (2014) Section 6.3
-
-    Examples
-    --------
-    Plot LOO-PIT predictive checks overlaying the KDE of the LOO-PIT values to several
-    realizations of uniform variable sampling with the same number of observations.
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> idata = az.load_arviz_data("radon")
-        >>> az.plot_loo_pit(idata=idata, y="y")
-
-    Fill the area containing the 94% highest density interval of the difference between uniform
-    variables empirical CDF and the real uniform CDF. A LOO-PIT ECDF clearly outside of these
-    theoretical boundaries indicates that the observations and the posterior predictive
-    samples do not follow the same distribution.
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_loo_pit(idata=idata, y="y", ecdf=True)
-
-    """
-    if ecdf and use_hdi:
-        raise ValueError("use_hdi is incompatible with ecdf plot")
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    loo_pit = _loo_pit(idata=idata, y=y, y_hat=y_hat, log_weights=log_weights)
-    loo_pit = loo_pit.flatten() if isinstance(loo_pit, np.ndarray) else loo_pit.values.flatten()
-
-    loo_pit_ecdf = None
-    unif_ecdf = None
-    p975 = None
-    p025 = None
-    loo_pit_kde = None
-    hdi_odds = None
-    unif = None
-    x_vals = None
-
-    if hdi_prob is None:
-        hdi_prob = rcParams["stats.ci_prob"]
-    elif not 1 >= hdi_prob > 0:
-        raise ValueError("The value of hdi_prob should be in the interval (0, 1]")
-
-    if ecdf:
-        loo_pit.sort()
-        n_data_points = loo_pit.size
-        loo_pit_ecdf = np.arange(n_data_points) / n_data_points
-        # ideal unnormalized ECDF of uniform distribution with n_data_points points
-        # it is used indistinctively as x or p(u<x) because for u~U(0,1) they are equal
-        unif_ecdf = np.arange(n_data_points + 1)
-        p975 = stats.beta.ppf(0.5 + hdi_prob / 2, unif_ecdf + 1, n_data_points - unif_ecdf + 1)
-        p025 = stats.beta.ppf(0.5 - hdi_prob / 2, unif_ecdf + 1, n_data_points - unif_ecdf + 1)
-        unif_ecdf = unif_ecdf / n_data_points
-    else:
-        x_vals, loo_pit_kde = kde(loo_pit)
-
-        unif = np.random.uniform(size=(n_unif, loo_pit.size))
-        if use_hdi:
-            n_obs = loo_pit.size
-            hdi_ = stats.beta(n_obs / 2, n_obs / 2).ppf((1 - hdi_prob) / 2)
-            hdi_odds = (hdi_ / (1 - hdi_), (1 - hdi_) / hdi_)
-
-    loo_pit_kwargs = dict(
-        ax=ax,
-        figsize=figsize,
-        ecdf=ecdf,
-        loo_pit=loo_pit,
-        loo_pit_ecdf=loo_pit_ecdf,
-        unif_ecdf=unif_ecdf,
-        p975=p975,
-        p025=p025,
-        fill_kwargs=fill_kwargs,
-        ecdf_fill=ecdf_fill,
-        use_hdi=use_hdi,
-        x_vals=x_vals,
-        hdi_kwargs=hdi_kwargs,
-        hdi_odds=hdi_odds,
-        n_unif=n_unif,
-        unif=unif,
-        plot_unif_kwargs=plot_unif_kwargs,
-        loo_pit_kde=loo_pit_kde,
-        textsize=textsize,
-        labeller=labeller,
-        color=color,
-        legend=legend,
-        y_hat=y_hat,
-        y=y,
-        hdi_prob=hdi_prob,
-        plot_kwargs=plot_kwargs,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_loo_pit", "loopitplot", backend)
-    axes = plot(**loo_pit_kwargs)
-
-    return axes

arviz/plots/mcseplot.py

@@ -1,194 +0,0 @@
-"""Plot quantile MC standard error."""
-
-import numpy as np
-import xarray as xr
-
-from ..data import convert_to_dataset
-from ..labels import BaseLabeller
-from ..sel_utils import xarray_var_iter
-from ..stats import mcse
-from ..rcparams import rcParams
-from ..utils import _var_names, get_coords
-from .plot_utils import default_grid, filter_plotters_list, get_plotting_function
-
-
-def plot_mcse(
-    idata,
-    var_names=None,
-    filter_vars=None,
-    coords=None,
-    errorbar=False,
-    grid=None,
-    figsize=None,
-    textsize=None,
-    extra_methods=False,
-    rug=False,
-    rug_kind="diverging",
-    n_points=20,
-    labeller=None,
-    ax=None,
-    rug_kwargs=None,
-    extra_kwargs=None,
-    text_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-    **kwargs
-):
-    """Plot quantile or local Monte Carlo Standard Error.
-
-    Parameters
-    ----------
-    idata : obj
-        Any object that can be converted to an :class:`arviz.InferenceData` object
-        Refer to documentation of :func:`arviz.convert_to_dataset` for details
-    var_names : list of variable names, optional
-        Variables to be plotted. Prefix the variables by ``~`` when you want to exclude
-        them from the plot.
-    filter_vars : {None, "like", "regex"}, optional, default=None
-        If `None` (default), interpret var_names as the real variables names. If "like",
-        interpret var_names as substrings of the real variables names. If "regex",
-        interpret var_names as regular expressions on the real variables names. A la
-        `pandas.filter`.
-    coords : dict, optional
-        Coordinates of var_names to be plotted. Passed to :meth:`xarray.Dataset.sel`
-    errorbar : bool, optional
-        Plot quantile value +/- mcse instead of plotting mcse.
-    grid : tuple
-        Number of rows and columns. Defaults to None, the rows and columns are
-        automatically inferred.
-    figsize : (float, float), optional
-        Figure size. If None it will be defined automatically.
-    textsize : float, optional
-        Text size scaling factor for labels, titles and lines. If None it will be autoscaled based
-        on figsize.
-    extra_methods : bool, optional
-        Plot mean and sd MCSE as horizontal lines. Only taken into account when
-        ``errorbar=False``.
-    rug : bool
-        Plot rug plot of values diverging or that reached the max tree depth.
-    rug_kind : bool
-        Variable in sample stats to use as rug mask. Must be a boolean variable.
-    n_points : int
-        Number of points for which to plot their quantile/local ess or number of subsets
-        in the evolution plot.
-    labeller : Labeller, optional
-        Class providing the method `make_label_vert` to generate the labels in the plot titles.
-        Read the :ref:`label_guide` for more details and usage examples.
-    ax : 2D array-like of matplotlib_axes or bokeh_figures, optional
-        A 2D array of locations into which to plot the densities. If not supplied, Arviz will create
-        its own array of plot areas (and return it).
-    rug_kwargs : dict
-        kwargs passed to rug plot in
-        :meth:`mpl:matplotlib.axes.Axes.plot` or :class:`bokeh:bokeh.models.glyphs.Scatter`.
-    extra_kwargs : dict, optional
-        kwargs passed as extra method lines in
-        :meth:`mpl:matplotlib.axes.Axes.axhline` or :class:`bokeh:bokeh.models.Span`
-    text_kwargs : dict, optional
-        kwargs passed to :meth:`mpl:matplotlib.axes.Axes.annotate` for extra methods lines labels.
-        It accepts the additional key ``x`` to set ``xy=(text_kwargs["x"], mcse)``.
-        text_kwargs are ignored for the bokeh plotting backend.
-    backend : str, optional
-        Select plotting backend {"matplotlib","bokeh"}. Default "matplotlib".
-    backend_kwargs : bool, optional
-        These are kwargs specific to the backend being passed to
-        :func:`matplotlib.pyplot.subplots` or :func:`bokeh.plotting.figure`.
-    show: bool, optional
-        Call backend show function.
-    **kwargs
-        Passed as-is to :meth:`mpl:matplotlib.axes.Axes.hist` or
-        :meth:`mpl:matplotlib.axes.Axes.plot` in matplotlib depending on the value of `kind`.
-
-    Returns
-    -------
-    axes : matplotlib axes or bokeh figures
-
-    See Also
-    --------
-    :func:`arviz.mcse`: Calculate Markov Chain Standard Error statistic.
-
-    References
-    ----------
-    .. [1] Vehtari et al. (2021). Rank-normalization, folding, and
-        localization: An improved Rhat for assessing convergence of
-        MCMC. Bayesian analysis, 16(2):667-718.
-
-    Examples
-    --------
-    Plot quantile Monte Carlo Standard Error.
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> idata = az.load_arviz_data("centered_eight")
-        >>> coords = {"school": ["Deerfield", "Lawrenceville"]}
-        >>> az.plot_mcse(
-        ...     idata, var_names=["mu", "theta"], coords=coords
-        ... )
-
-    """
-    mean_mcse = None
-    sd_mcse = None
-
-    if coords is None:
-        coords = {}
-    if "chain" in coords or "draw" in coords:
-        raise ValueError("chain and draw are invalid coordinates for this kind of plot")
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    data = get_coords(convert_to_dataset(idata, group="posterior"), coords)
-    var_names = _var_names(var_names, data, filter_vars)
-
-    probs = np.linspace(1 / n_points, 1 - 1 / n_points, n_points)
-    mcse_dataset = xr.concat(
-        [mcse(data, var_names=var_names, method="quantile", prob=p) for p in probs], dim="mcse_dim"
-    )
-
-    plotters = filter_plotters_list(
-        list(xarray_var_iter(mcse_dataset, var_names=var_names, skip_dims={"mcse_dim"})),
-        "plot_mcse",
-    )
-    length_plotters = len(plotters)
-    rows, cols = default_grid(length_plotters, grid=grid)
-
-    if extra_methods:
-        mean_mcse = mcse(data, var_names=var_names, method="mean")
-        sd_mcse = mcse(data, var_names=var_names, method="sd")
-
-    mcse_kwargs = dict(
-        ax=ax,
-        plotters=plotters,
-        length_plotters=length_plotters,
-        rows=rows,
-        cols=cols,
-        figsize=figsize,
-        errorbar=errorbar,
-        rug=rug,
-        data=data,
-        probs=probs,
-        kwargs=kwargs,
-        extra_methods=extra_methods,
-        mean_mcse=mean_mcse,
-        sd_mcse=sd_mcse,
-        textsize=textsize,
-        labeller=labeller,
-        text_kwargs=text_kwargs,
-        rug_kwargs=rug_kwargs,
-        extra_kwargs=extra_kwargs,
-        idata=idata,
-        rug_kind=rug_kind,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_mcse", "mcseplot", backend)
-    ax = plot(**mcse_kwargs)
-    return ax

arviz/plots/pairplot.py

@@ -1,281 +0,0 @@
-"""Plot a scatter, kde and/or hexbin of sampled parameters."""
-
-import warnings
-from typing import List, Optional, Union
-
-import numpy as np
-
-from ..data import convert_to_dataset
-from ..labels import BaseLabeller
-from ..sel_utils import xarray_to_ndarray, xarray_var_iter
-from .plot_utils import get_plotting_function
-from ..rcparams import rcParams
-from ..utils import _var_names, get_coords
-
-
-def plot_pair(
-    data,
-    group="posterior",
-    var_names: Optional[List[str]] = None,
-    filter_vars: Optional[str] = None,
-    combine_dims=None,
-    coords=None,
-    marginals=False,
-    figsize=None,
-    textsize=None,
-    kind: Union[str, List[str]] = "scatter",
-    gridsize="auto",
-    divergences=False,
-    colorbar=False,
-    labeller=None,
-    ax=None,
-    divergences_kwargs=None,
-    scatter_kwargs=None,
-    kde_kwargs=None,
-    hexbin_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    marginal_kwargs=None,
-    point_estimate=None,
-    point_estimate_kwargs=None,
-    point_estimate_marker_kwargs=None,
-    reference_values=None,
-    reference_values_kwargs=None,
-    show=None,
-):
-    """
-    Plot a scatter, kde and/or hexbin matrix with (optional) marginals on the diagonal.
-
-    Parameters
-    ----------
-    data: obj
-        Any object that can be converted to an :class:`arviz.InferenceData` object.
-        Refer to documentation of :func:`arviz.convert_to_dataset` for details
-    group: str, optional
-        Specifies which InferenceData group should be plotted.  Defaults to 'posterior'.
-    var_names: list of variable names, optional
-        Variables to be plotted, if None all variable are plotted. Prefix the
-        variables by ``~`` when you want to exclude them from the plot.
-    filter_vars: {None, "like", "regex"}, optional, default=None
-        If `None` (default), interpret var_names as the real variables names. If "like",
-        interpret var_names as substrings of the real variables names. If "regex",
-        interpret var_names as regular expressions on the real variables names. A la
-        ``pandas.filter``.
-    combine_dims : set_like of str, optional
-        List of dimensions to reduce. Defaults to reducing only the "chain" and "draw" dimensions.
-        See the :ref:`this section <common_combine_dims>` for usage examples.
-    coords: mapping, optional
-        Coordinates of var_names to be plotted. Passed to :meth:`xarray.Dataset.sel`.
-    marginals: bool, optional
-        If True pairplot will include marginal distributions for every variable
-    figsize: figure size tuple
-        If None, size is (8 + numvars, 8 + numvars)
-    textsize: int
-        Text size for labels. If None it will be autoscaled based on ``figsize``.
-    kind : str or List[str]
-        Type of plot to display (scatter, kde and/or hexbin)
-    gridsize: int or (int, int), optional
-        Only works for ``kind=hexbin``. The number of hexagons in the x-direction.
-        The corresponding number of hexagons in the y-direction is chosen
-        such that the hexagons are approximately regular. Alternatively, gridsize
-        can be a tuple with two elements specifying the number of hexagons
-        in the x-direction and the y-direction.
-    divergences: Boolean
-        If True divergences will be plotted in a different color, only if group is either 'prior'
-        or 'posterior'.
-    colorbar: bool
-        If True a colorbar will be included as part of the plot (Defaults to False).
-        Only works when ``kind=hexbin``
-    labeller : labeller instance, optional
-        Class providing the method ``make_label_vert`` to generate the labels in the plot.
-        Read the :ref:`label_guide` for more details and usage examples.
-    ax: axes, optional
-        Matplotlib axes or bokeh figures.
-    divergences_kwargs: dicts, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.scatter` for divergences
-    scatter_kwargs:
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.scatter` when using scatter kind
-    kde_kwargs: dict, optional
-        Additional keywords passed to :func:`arviz.plot_kde` when using kde kind
-    hexbin_kwargs: dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.hexbin` when
-        using hexbin kind
-    backend: str, optional
-        Select plotting backend {"matplotlib","bokeh"}. Default "matplotlib".
-    backend_kwargs: bool, optional
-        These are kwargs specific to the backend being used, passed to
-        :func:`matplotlib.pyplot.subplots` or
-        :func:`bokeh.plotting.figure`.
-    marginal_kwargs: dict, optional
-        Additional keywords passed to :func:`arviz.plot_dist`, modifying the
-        marginal distributions plotted in the diagonal.
-    point_estimate: str, optional
-        Select point estimate from 'mean', 'mode' or 'median'. The point estimate will be
-        plotted using a scatter marker and vertical/horizontal lines.
-    point_estimate_kwargs: dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.axvline`,
-        :meth:`matplotlib.axes.Axes.axhline` (matplotlib) or
-        :class:`bokeh:bokeh.models.Span` (bokeh)
-    point_estimate_marker_kwargs: dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.scatter`
-        or :meth:`bokeh:bokeh.plotting.Figure.square` in point
-        estimate plot. Not available in bokeh
-    reference_values: dict, optional
-        Reference values for the plotted variables. The Reference values will be plotted
-        using a scatter marker
-    reference_values_kwargs: dict, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.plot` or
-        :meth:`bokeh:bokeh.plotting.Figure.circle` in reference values plot
-    show: bool, optional
-        Call backend show function.
-
-    Returns
-    -------
-    axes: matplotlib axes or bokeh figures
-
-    Examples
-    --------
-    KDE Pair Plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> centered = az.load_arviz_data('centered_eight')
-        >>> coords = {'school': ['Choate', 'Deerfield']}
-        >>> az.plot_pair(centered,
-        >>>             var_names=['theta', 'mu', 'tau'],
-        >>>             kind='kde',
-        >>>             coords=coords,
-        >>>             divergences=True,
-        >>>             textsize=18)
-
-    Hexbin pair plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_pair(centered,
-        >>>             var_names=['theta', 'mu'],
-        >>>             coords=coords,
-        >>>             textsize=18,
-        >>>             kind='hexbin')
-
-    Pair plot showing divergences and select variables with regular expressions
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_pair(centered,
-        ...             var_names=['^t', 'mu'],
-        ...             filter_vars="regex",
-        ...             coords=coords,
-        ...             divergences=True,
-        ...             textsize=18)
-    """
-    valid_kinds = ["scatter", "kde", "hexbin"]
-    kind_boolean: Union[bool, List[bool]]
-    if isinstance(kind, str):
-        kind_boolean = kind in valid_kinds
-    else:
-        kind_boolean = [kind[i] in valid_kinds for i in range(len(kind))]
-    if not np.all(kind_boolean):
-        raise ValueError(f"Plot type {kind} not recognized. Plot type must be in {valid_kinds}")
-
-    if coords is None:
-        coords = {}
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    # Get posterior draws and combine chains
-    dataset = convert_to_dataset(data, group=group)
-    var_names = _var_names(var_names, dataset, filter_vars)
-    plotters = list(
-        xarray_var_iter(
-            get_coords(dataset, coords), var_names=var_names, skip_dims=combine_dims, combined=True
-        )
-    )
-    flat_var_names = []
-    flat_ref_slices = []
-    flat_var_labels = []
-    for var_name, sel, isel, _ in plotters:
-        dims = [dim for dim in dataset[var_name].dims if dim not in ["chain", "draw"]]
-        flat_var_names.append(var_name)
-        flat_ref_slices.append(tuple(isel[dim] if dim in isel else slice(None) for dim in dims))
-        flat_var_labels.append(labeller.make_label_vert(var_name, sel, isel))
-
-    divergent_data = None
-    diverging_mask = None
-
-    # Assigning divergence group based on group param
-    if group == "posterior":
-        divergent_group = "sample_stats"
-    elif group == "prior":
-        divergent_group = "sample_stats_prior"
-    else:
-        divergences = False
-
-    # Get diverging draws and combine chains
-    if divergences:
-        if hasattr(data, divergent_group) and hasattr(getattr(data, divergent_group), "diverging"):
-            divergent_data = convert_to_dataset(data, group=divergent_group)
-            _, diverging_mask = xarray_to_ndarray(
-                divergent_data, var_names=("diverging",), combined=True
-            )
-            diverging_mask = np.squeeze(diverging_mask)
-        else:
-            divergences = False
-            warnings.warn(
-                "Divergences data not found, plotting without divergences. "
-                "Make sure the sample method provides divergences data and "
-                "that it is present in the `diverging` field of `sample_stats` "
-                "or `sample_stats_prior` or set divergences=False",
-                UserWarning,
-            )
-
-    if gridsize == "auto":
-        gridsize = int(dataset.sizes["draw"] ** 0.35)
-
-    numvars = len(flat_var_names)
-
-    if numvars < 2:
-        raise ValueError("Number of variables to be plotted must be 2 or greater.")
-
-    pairplot_kwargs = dict(
-        ax=ax,
-        plotters=plotters,
-        numvars=numvars,
-        figsize=figsize,
-        textsize=textsize,
-        kind=kind,
-        scatter_kwargs=scatter_kwargs,
-        kde_kwargs=kde_kwargs,
-        hexbin_kwargs=hexbin_kwargs,
-        gridsize=gridsize,
-        colorbar=colorbar,
-        divergences=divergences,
-        diverging_mask=diverging_mask,
-        divergences_kwargs=divergences_kwargs,
-        flat_var_names=flat_var_names,
-        flat_ref_slices=flat_ref_slices,
-        flat_var_labels=flat_var_labels,
-        backend_kwargs=backend_kwargs,
-        marginal_kwargs=marginal_kwargs,
-        show=show,
-        marginals=marginals,
-        point_estimate=point_estimate,
-        point_estimate_kwargs=point_estimate_kwargs,
-        point_estimate_marker_kwargs=point_estimate_marker_kwargs,
-        reference_values=reference_values,
-        reference_values_kwargs=reference_values_kwargs,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_pair", "pairplot", backend)
-    ax = plot(**pairplot_kwargs)
-    return ax