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

arviz/plots/backends/matplotlib/loopitplot.py

@@ -1,144 +0,0 @@
-"""Matplotlib loopitplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.colors import hsv_to_rgb, rgb_to_hsv, to_hex, to_rgb
-from xarray import DataArray
-
-from ....stats.density_utils import kde
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_loo_pit(
-    ax,
-    figsize,
-    ecdf,
-    loo_pit,
-    loo_pit_ecdf,
-    unif_ecdf,
-    p975,
-    p025,
-    fill_kwargs,
-    ecdf_fill,
-    use_hdi,
-    x_vals,
-    hdi_kwargs,
-    hdi_odds,
-    n_unif,
-    unif,
-    plot_unif_kwargs,
-    loo_pit_kde,
-    legend,
-    labeller,
-    y_hat,
-    y,
-    color,
-    textsize,
-    hdi_prob,
-    plot_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib loo pit plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, _, _, xt_labelsize, linewidth, _) = _scale_fig_size(figsize, textsize, 1, 1)
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-
-    if ax is None:
-        _, ax = create_axes_grid(1, backend_kwargs=backend_kwargs)
-
-    plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, "plot")
-    plot_kwargs["color"] = to_hex(color)
-    plot_kwargs.setdefault("linewidth", linewidth * 1.4)
-    if isinstance(y, str):
-        xlabel = y
-    elif isinstance(y, DataArray) and y.name is not None:
-        xlabel = y.name
-    elif isinstance(y_hat, str):
-        xlabel = y_hat
-    elif isinstance(y_hat, DataArray) and y_hat.name is not None:
-        xlabel = y_hat.name
-    else:
-        xlabel = ""
-    label = "LOO-PIT ECDF" if ecdf else "LOO-PIT"
-    xlabel = labeller.var_name_to_str(y)
-
-    plot_kwargs.setdefault("label", label)
-    plot_kwargs.setdefault("zorder", 5)
-
-    plot_unif_kwargs = matplotlib_kwarg_dealiaser(plot_unif_kwargs, "plot")
-    light_color = rgb_to_hsv(to_rgb(plot_kwargs.get("color")))
-    light_color[1] /= 2  # pylint: disable=unsupported-assignment-operation
-    light_color[2] += (1 - light_color[2]) / 2  # pylint: disable=unsupported-assignment-operation
-    plot_unif_kwargs.setdefault("color", to_hex(hsv_to_rgb(light_color)))
-    plot_unif_kwargs.setdefault("alpha", 0.5)
-    plot_unif_kwargs.setdefault("linewidth", 0.6 * linewidth)
-
-    if ecdf:
-        n_data_points = loo_pit.size
-        plot_kwargs.setdefault("drawstyle", "steps-mid" if n_data_points < 100 else "default")
-        plot_unif_kwargs.setdefault("drawstyle", "steps-mid" if n_data_points < 100 else "default")
-
-        if ecdf_fill:
-            if fill_kwargs is None:
-                fill_kwargs = {}
-            fill_kwargs.setdefault("color", to_hex(hsv_to_rgb(light_color)))
-            fill_kwargs.setdefault("alpha", 0.5)
-            fill_kwargs.setdefault(
-                "step", "mid" if plot_kwargs["drawstyle"] == "steps-mid" else None
-            )
-            fill_kwargs.setdefault("label", f"{hdi_prob * 100:.3g}% credible interval")
-    elif use_hdi:
-        if hdi_kwargs is None:
-            hdi_kwargs = {}
-        hdi_kwargs.setdefault("color", to_hex(hsv_to_rgb(light_color)))
-        hdi_kwargs.setdefault("alpha", 0.35)
-        hdi_kwargs.setdefault("label", "Uniform HDI")
-
-    if ecdf:
-        ax.plot(
-            np.hstack((0, loo_pit, 1)), np.hstack((0, loo_pit - loo_pit_ecdf, 0)), **plot_kwargs
-        )
-
-        if ecdf_fill:
-            ax.fill_between(unif_ecdf, p975 - unif_ecdf, p025 - unif_ecdf, **fill_kwargs)
-        else:
-            ax.plot(unif_ecdf, p975 - unif_ecdf, unif_ecdf, p025 - unif_ecdf, **plot_unif_kwargs)
-    else:
-        x_ss = np.empty((n_unif, len(loo_pit_kde)))
-        u_dens = np.empty((n_unif, len(loo_pit_kde)))
-        if use_hdi:
-            ax.axhspan(*hdi_odds, **hdi_kwargs)
-
-            # Adds horizontal reference line
-            ax.axhline(1, color="w", zorder=1)
-        else:
-            for idx in range(n_unif):
-                x_s, unif_density = kde(unif[idx, :])
-                x_ss[idx] = x_s
-                u_dens[idx] = unif_density
-            ax.plot(x_ss.T, u_dens.T, **plot_unif_kwargs)
-        ax.plot(x_vals, loo_pit_kde, **plot_kwargs)
-        ax.set_xlim(0, 1)
-        ax.set_ylim(0, None)
-    ax.set_xlabel(xlabel)
-    ax.tick_params(labelsize=xt_labelsize)
-    if legend:
-        if not (use_hdi or (ecdf and ecdf_fill)):
-            label = f"{hdi_prob * 100:.3g}% credible interval" if ecdf else "Uniform"
-            ax.plot([], label=label, **plot_unif_kwargs)
-        ax.legend()
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/mcseplot.py

@@ -1,161 +0,0 @@
-"""Matplotlib mcseplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.stats import rankdata
-
-from ....stats.stats_utils import quantile as _quantile
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_mcse(
-    ax,
-    plotters,
-    length_plotters,
-    rows,
-    cols,
-    figsize,
-    errorbar,
-    rug,
-    data,
-    probs,
-    kwargs,
-    extra_methods,
-    mean_mcse,
-    sd_mcse,
-    textsize,
-    labeller,
-    text_kwargs,
-    rug_kwargs,
-    extra_kwargs,
-    idata,
-    rug_kind,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib mcseplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, ax_labelsize, titlesize, xt_labelsize, _linewidth, _markersize) = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-
-    kwargs = matplotlib_kwarg_dealiaser(kwargs, "plot")
-    kwargs.setdefault("linestyle", "none")
-    kwargs.setdefault("linewidth", _linewidth)
-    kwargs.setdefault("markersize", _markersize)
-    kwargs.setdefault("marker", "_" if errorbar else "o")
-    kwargs.setdefault("zorder", 3)
-
-    extra_kwargs = matplotlib_kwarg_dealiaser(extra_kwargs, "plot")
-    extra_kwargs.setdefault("linestyle", "-")
-    extra_kwargs.setdefault("linewidth", _linewidth / 2)
-    extra_kwargs.setdefault("color", "k")
-    extra_kwargs.setdefault("alpha", 0.5)
-    text_x = None
-    text_va = None
-    if extra_methods:
-        text_kwargs = matplotlib_kwarg_dealiaser(text_kwargs, "text")
-        text_x = text_kwargs.pop("x", 1)
-        text_kwargs.setdefault("fontsize", xt_labelsize * 0.7)
-        text_kwargs.setdefault("alpha", extra_kwargs["alpha"])
-        text_kwargs.setdefault("color", extra_kwargs["color"])
-        text_kwargs.setdefault("horizontalalignment", "right")
-        text_va = text_kwargs.pop("verticalalignment", None)
-
-    if ax is None:
-        _, ax = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            backend_kwargs=backend_kwargs,
-        )
-
-    for (var_name, selection, isel, x), ax_ in zip(plotters, np.ravel(ax)):
-        if errorbar or rug:
-            values = data[var_name].sel(**selection).values.flatten()
-        if errorbar:
-            quantile_values = _quantile(values, probs)
-            ax_.errorbar(probs, quantile_values, yerr=x, **kwargs)
-        else:
-            ax_.plot(probs, x, label="quantile", **kwargs)
-            if extra_methods:
-                mean_mcse_i = mean_mcse[var_name].sel(**selection).values.item()
-                sd_mcse_i = sd_mcse[var_name].sel(**selection).values.item()
-                ax_.axhline(mean_mcse_i, **extra_kwargs)
-                ax_.annotate(
-                    "mean",
-                    (text_x, mean_mcse_i),
-                    va=(
-                        text_va
-                        if text_va is not None
-                        else "bottom" if mean_mcse_i > sd_mcse_i else "top"
-                    ),
-                    **text_kwargs,
-                )
-                ax_.axhline(sd_mcse_i, **extra_kwargs)
-                ax_.annotate(
-                    "sd",
-                    (text_x, sd_mcse_i),
-                    va=(
-                        text_va
-                        if text_va is not None
-                        else "bottom" if sd_mcse_i >= mean_mcse_i else "top"
-                    ),
-                    **text_kwargs,
-                )
-        if rug:
-            rug_kwargs = matplotlib_kwarg_dealiaser(rug_kwargs, "plot")
-            if not hasattr(idata, "sample_stats"):
-                raise ValueError("InferenceData object must contain sample_stats for rug plot")
-            if not hasattr(idata.sample_stats, rug_kind):
-                raise ValueError(f"InferenceData does not contain {rug_kind} data")
-            rug_kwargs.setdefault("marker", "|")
-            rug_kwargs.setdefault("linestyle", rug_kwargs.pop("ls", "None"))
-            rug_kwargs.setdefault("color", rug_kwargs.pop("c", kwargs.get("color", "C0")))
-            rug_kwargs.setdefault("space", 0.1)
-            rug_kwargs.setdefault("markersize", rug_kwargs.pop("ms", 2 * _markersize))
-
-            mask = idata.sample_stats[rug_kind].values.flatten()
-            values = rankdata(values, method="average")[mask]
-            y_min, y_max = ax_.get_ylim()
-            y_min = y_min if errorbar else 0
-            rug_space = (y_max - y_min) * rug_kwargs.pop("space")
-            rug_x, rug_y = values / (len(mask) - 1), np.full_like(values, y_min) - rug_space
-            ax_.plot(rug_x, rug_y, **rug_kwargs)
-            ax_.axhline(y_min, color="k", linewidth=_linewidth, alpha=0.7)
-
-        ax_.set_title(
-            labeller.make_label_vert(var_name, selection, isel), fontsize=titlesize, wrap=True
-        )
-        ax_.tick_params(labelsize=xt_labelsize)
-        ax_.set_xlabel("Quantile", fontsize=ax_labelsize, wrap=True)
-        ax_.set_ylabel(
-            r"Value $\pm$ MCSE for quantiles" if errorbar else "MCSE for quantiles",
-            fontsize=ax_labelsize,
-            wrap=True,
-        )
-        ax_.set_xlim(0, 1)
-        if rug:
-            ax_.yaxis.get_major_locator().set_params(nbins="auto", steps=[1, 2, 5, 10])
-            y_min, y_max = ax_.get_ylim()
-            yticks = ax_.get_yticks()
-            yticks = yticks[(yticks >= y_min) & (yticks < y_max)]
-            ax_.set_yticks(yticks)
-            ax_.set_yticklabels([f"{ytick:.3g}" for ytick in yticks])
-        elif not errorbar:
-            ax_.set_ylim(bottom=0)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/pairplot.py

@@ -1,355 +0,0 @@
-"""Matplotlib pairplot."""
-
-import warnings
-from copy import deepcopy
-
-import matplotlib.pyplot as plt
-import numpy as np
-from mpl_toolkits.axes_grid1 import make_axes_locatable
-
-from ....rcparams import rcParams
-from ...distplot import plot_dist
-from ...kdeplot import plot_kde
-from ...plot_utils import _scale_fig_size, calculate_point_estimate, _init_kwargs_dict
-from . import backend_kwarg_defaults, backend_show, matplotlib_kwarg_dealiaser
-
-
-def plot_pair(
-    ax,
-    plotters,
-    numvars,
-    figsize,
-    textsize,
-    kind,
-    scatter_kwargs,
-    kde_kwargs,
-    hexbin_kwargs,
-    gridsize,
-    colorbar,
-    divergences,
-    diverging_mask,
-    divergences_kwargs,
-    flat_var_names,
-    flat_ref_slices,
-    flat_var_labels,
-    backend_kwargs,
-    marginal_kwargs,
-    show,
-    marginals,
-    point_estimate,
-    point_estimate_kwargs,
-    point_estimate_marker_kwargs,
-    reference_values,
-    reference_values_kwargs,
-):
-    """Matplotlib pairplot."""
-    backend_kwargs = _init_kwargs_dict(backend_kwargs)
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    scatter_kwargs = matplotlib_kwarg_dealiaser(scatter_kwargs, "scatter")
-
-    scatter_kwargs.setdefault("marker", ".")
-    scatter_kwargs.setdefault("lw", 0)
-    # Sets the default zorder higher than zorder of grid, which is 0.5
-    scatter_kwargs.setdefault("zorder", 0.6)
-
-    kde_kwargs = _init_kwargs_dict(kde_kwargs)
-
-    hexbin_kwargs = matplotlib_kwarg_dealiaser(hexbin_kwargs, "hexbin")
-    hexbin_kwargs.setdefault("mincnt", 1)
-
-    divergences_kwargs = matplotlib_kwarg_dealiaser(divergences_kwargs, "plot")
-    divergences_kwargs.setdefault("marker", "o")
-    divergences_kwargs.setdefault("markeredgecolor", "k")
-    divergences_kwargs.setdefault("color", "C1")
-    divergences_kwargs.setdefault("lw", 0)
-
-    marginal_kwargs = _init_kwargs_dict(marginal_kwargs)
-
-    point_estimate_kwargs = matplotlib_kwarg_dealiaser(point_estimate_kwargs, "fill_between")
-    point_estimate_kwargs.setdefault("color", "k")
-
-    if kind != "kde":
-        kde_kwargs.setdefault("contourf_kwargs", {})
-        kde_kwargs["contourf_kwargs"].setdefault("alpha", 0)
-        kde_kwargs.setdefault("contour_kwargs", {})
-        kde_kwargs["contour_kwargs"].setdefault("colors", "k")
-
-    if reference_values:
-        difference = set(flat_var_names).difference(set(reference_values.keys()))
-
-        if difference:
-            warnings.warn(
-                "Argument reference_values does not include reference value for: {}".format(
-                    ", ".join(difference)
-                ),
-                UserWarning,
-            )
-
-    reference_values_kwargs = matplotlib_kwarg_dealiaser(reference_values_kwargs, "plot")
-
-    reference_values_kwargs.setdefault("color", "C2")
-    reference_values_kwargs.setdefault("markeredgecolor", "k")
-    reference_values_kwargs.setdefault("marker", "o")
-
-    point_estimate_marker_kwargs = matplotlib_kwarg_dealiaser(
-        point_estimate_marker_kwargs, "scatter"
-    )
-    point_estimate_marker_kwargs.setdefault("marker", "s")
-    point_estimate_marker_kwargs.setdefault("color", "k")
-
-    # pylint: disable=too-many-nested-blocks
-    if numvars == 2:
-        (figsize, ax_labelsize, _, xt_labelsize, linewidth, markersize) = _scale_fig_size(
-            figsize, textsize, numvars - 1, numvars - 1
-        )
-        backend_kwargs.setdefault("figsize", figsize)
-
-        marginal_kwargs.setdefault("plot_kwargs", {})
-        marginal_kwargs["plot_kwargs"].setdefault("linewidth", linewidth)
-
-        point_estimate_marker_kwargs.setdefault("s", markersize + 50)
-
-        # Flatten data
-        x = plotters[0][-1].flatten()
-        y = plotters[1][-1].flatten()
-        if ax is None:
-            if marginals:
-                # Instantiate figure and grid
-                widths = [2, 2, 2, 1]
-                heights = [1.4, 2, 2, 2]
-                fig = plt.figure(**backend_kwargs)
-                grid = plt.GridSpec(
-                    4,
-                    4,
-                    hspace=0.1,
-                    wspace=0.1,
-                    figure=fig,
-                    width_ratios=widths,
-                    height_ratios=heights,
-                )
-                # Set up main plot
-                ax = fig.add_subplot(grid[1:, :-1])
-                # Set up top KDE
-                ax_hist_x = fig.add_subplot(grid[0, :-1], sharex=ax)
-                ax_hist_x.set_yticks([])
-                # Set up right KDE
-                ax_hist_y = fig.add_subplot(grid[1:, -1], sharey=ax)
-                ax_hist_y.set_xticks([])
-                ax_return = np.array([[ax_hist_x, None], [ax, ax_hist_y]])
-
-                for val, ax_, rotate in ((x, ax_hist_x, False), (y, ax_hist_y, True)):
-                    plot_dist(val, textsize=xt_labelsize, rotated=rotate, ax=ax_, **marginal_kwargs)
-
-                # Personalize axes
-                ax_hist_x.tick_params(labelleft=False, labelbottom=False)
-                ax_hist_y.tick_params(labelleft=False, labelbottom=False)
-            else:
-                fig, ax = plt.subplots(numvars - 1, numvars - 1, **backend_kwargs)
-        else:
-            if marginals:
-                assert ax.shape == (numvars, numvars)
-                if ax[0, 1] is not None and ax[0, 1].get_figure() is not None:
-                    ax[0, 1].remove()
-                ax_return = ax
-                ax_hist_x = ax[0, 0]
-                ax_hist_y = ax[1, 1]
-                ax = ax[1, 0]
-                for val, ax_, rotate in ((x, ax_hist_x, False), (y, ax_hist_y, True)):
-                    plot_dist(val, textsize=xt_labelsize, rotated=rotate, ax=ax_, **marginal_kwargs)
-            else:
-                ax = np.atleast_2d(ax)[0, 0]
-
-        if "scatter" in kind:
-            ax.scatter(x, y, **scatter_kwargs)
-        if "kde" in kind:
-            plot_kde(x, y, ax=ax, **kde_kwargs)
-        if "hexbin" in kind:
-            hexbin = ax.hexbin(
-                x,
-                y,
-                gridsize=gridsize,
-                **hexbin_kwargs,
-            )
-            ax.grid(False)
-
-        if kind == "hexbin" and colorbar:
-            cbar = ax.figure.colorbar(hexbin, ticks=[hexbin.norm.vmin, hexbin.norm.vmax], ax=ax)
-            cbar.ax.set_yticklabels(["low", "high"], fontsize=ax_labelsize)
-
-        if divergences:
-            ax.plot(
-                x[diverging_mask],
-                y[diverging_mask],
-                **divergences_kwargs,
-            )
-
-        if point_estimate:
-            pe_x = calculate_point_estimate(point_estimate, x)
-            pe_y = calculate_point_estimate(point_estimate, y)
-            if marginals:
-                ax_hist_x.axvline(pe_x, **point_estimate_kwargs)
-                ax_hist_y.axhline(pe_y, **point_estimate_kwargs)
-
-            ax.axvline(pe_x, **point_estimate_kwargs)
-            ax.axhline(pe_y, **point_estimate_kwargs)
-
-            ax.scatter(pe_x, pe_y, **point_estimate_marker_kwargs)
-
-        if reference_values:
-            ax.plot(
-                np.array(reference_values[flat_var_names[0]])[flat_ref_slices[0]],
-                np.array(reference_values[flat_var_names[1]])[flat_ref_slices[1]],
-                **reference_values_kwargs,
-            )
-        ax.set_xlabel(f"{flat_var_labels[0]}", fontsize=ax_labelsize, wrap=True)
-        ax.set_ylabel(f"{flat_var_labels[1]}", fontsize=ax_labelsize, wrap=True)
-        ax.tick_params(labelsize=xt_labelsize)
-
-    else:
-        not_marginals = int(not marginals)
-        num_subplot_cols = numvars - not_marginals
-        max_plots = (
-            num_subplot_cols**2
-            if rcParams["plot.max_subplots"] is None
-            else rcParams["plot.max_subplots"]
-        )
-        cols_to_plot = np.sum(np.arange(1, num_subplot_cols + 1).cumsum() <= max_plots)
-        if cols_to_plot < num_subplot_cols:
-            vars_to_plot = cols_to_plot
-            warnings.warn(
-                "rcParams['plot.max_subplots'] ({max_plots}) is smaller than the number "
-                "of resulting pair plots with these variables, generating only a "
-                "{side}x{side} grid".format(max_plots=max_plots, side=vars_to_plot),
-                UserWarning,
-            )
-        else:
-            vars_to_plot = numvars - not_marginals
-
-        (figsize, ax_labelsize, _, xt_labelsize, _, markersize) = _scale_fig_size(
-            figsize, textsize, vars_to_plot, vars_to_plot
-        )
-        backend_kwargs.setdefault("figsize", figsize)
-        point_estimate_marker_kwargs.setdefault("s", markersize + 50)
-
-        if ax is None:
-            if backend_kwargs.pop("sharex", None) is not None:
-                warnings.warn(
-                    "'sharex' keyword is ignored. For non-standard sharing, provide 'ax'.",
-                    UserWarning,
-                )
-            if backend_kwargs.pop("sharey", None) is not None:
-                warnings.warn(
-                    "'sharey' keyword is ignored. For non-standard sharing, provide 'ax'.",
-                    UserWarning,
-                )
-            backend_kwargs["sharex"] = "col"
-            if not_marginals:
-                backend_kwargs["sharey"] = "row"
-            fig, ax = plt.subplots(
-                vars_to_plot,
-                vars_to_plot,
-                **backend_kwargs,
-            )
-            if backend_kwargs.get("sharey") is None:
-                for j in range(0, vars_to_plot):
-                    for i in range(0, j):
-                        ax[j, i].axes.sharey(ax[j, 0])
-
-        hexbin_values = []
-        for i in range(0, vars_to_plot):
-            var1 = plotters[i][-1].flatten()
-
-            for j in range(0, vars_to_plot):
-                var2 = plotters[j + not_marginals][-1].flatten()
-                if i > j:
-                    if ax[j, i].get_figure() is not None:
-                        ax[j, i].remove()
-                    continue
-
-                elif i == j and marginals:
-                    loc = "right"
-                    plot_dist(var1, ax=ax[i, j], **marginal_kwargs)
-
-                else:
-                    if i == j:
-                        loc = "left"
-
-                    if "scatter" in kind:
-                        ax[j, i].scatter(var1, var2, **scatter_kwargs)
-
-                    if "kde" in kind:
-                        plot_kde(
-                            var1,
-                            var2,
-                            ax=ax[j, i],
-                            **deepcopy(kde_kwargs),
-                        )
-
-                    if "hexbin" in kind:
-                        ax[j, i].grid(False)
-                        hexbin = ax[j, i].hexbin(var1, var2, gridsize=gridsize, **hexbin_kwargs)
-
-                    if divergences:
-                        ax[j, i].plot(
-                            var1[diverging_mask], var2[diverging_mask], **divergences_kwargs
-                        )
-
-                    if kind == "hexbin" and colorbar:
-                        hexbin_values.append(hexbin.norm.vmin)
-                        hexbin_values.append(hexbin.norm.vmax)
-                        divider = make_axes_locatable(ax[-1, -1])
-                        cax = divider.append_axes(loc, size="7%", pad="5%")
-                        cbar = fig.colorbar(
-                            hexbin, ticks=[hexbin.norm.vmin, hexbin.norm.vmax], cax=cax
-                        )
-                        cbar.ax.set_yticklabels(["low", "high"], fontsize=ax_labelsize)
-
-                    if point_estimate:
-                        pe_x = calculate_point_estimate(point_estimate, var1)
-                        pe_y = calculate_point_estimate(point_estimate, var2)
-                        ax[j, i].axvline(pe_x, **point_estimate_kwargs)
-                        ax[j, i].axhline(pe_y, **point_estimate_kwargs)
-
-                        if marginals:
-                            ax[j - 1, i].axvline(pe_x, **point_estimate_kwargs)
-                            pe_last = calculate_point_estimate(point_estimate, plotters[-1][-1])
-                            ax[-1, -1].axvline(pe_last, **point_estimate_kwargs)
-
-                        ax[j, i].scatter(pe_x, pe_y, **point_estimate_marker_kwargs)
-
-                    if reference_values:
-                        x_name = flat_var_names[i]
-                        y_name = flat_var_names[j + not_marginals]
-                        if (x_name not in difference) and (y_name not in difference):
-                            ax[j, i].plot(
-                                np.array(reference_values[x_name])[flat_ref_slices[i]],
-                                np.array(reference_values[y_name])[
-                                    flat_ref_slices[j + not_marginals]
-                                ],
-                                **reference_values_kwargs,
-                            )
-
-                if j != vars_to_plot - 1:
-                    plt.setp(ax[j, i].get_xticklabels(), visible=False)
-                else:
-                    ax[j, i].set_xlabel(f"{flat_var_labels[i]}", fontsize=ax_labelsize, wrap=True)
-                if i != 0:
-                    plt.setp(ax[j, i].get_yticklabels(), visible=False)
-                else:
-                    ax[j, i].set_ylabel(
-                        f"{flat_var_labels[j + not_marginals]}",
-                        fontsize=ax_labelsize,
-                        wrap=True,
-                    )
-                ax[j, i].tick_params(labelsize=xt_labelsize)
-
-    if backend_show(show):
-        plt.show()
-
-    if marginals and numvars == 2:
-        return ax_return
-    return ax