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

arviz/plots/backends/bokeh/violinplot.py

@@ -1,164 +0,0 @@
-"""Bokeh Violinplot."""
-
-import numpy as np
-from bokeh.models.annotations import Title
-
-from ....stats import hdi
-from ....stats.density_utils import get_bins, histogram, kde
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_violin(
-    ax,
-    plotters,
-    figsize,
-    rows,
-    cols,
-    sharex,
-    sharey,
-    shade_kwargs,
-    shade,
-    rug,
-    side,
-    rug_kwargs,
-    bw,
-    textsize,
-    labeller,
-    circular,
-    hdi_prob,
-    quartiles,
-    backend_kwargs,
-    show,
-):
-    """Bokeh violin plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(
-            ("dpi", "plot.bokeh.figure.dpi"),
-        ),
-        **backend_kwargs,
-    }
-    (figsize, *_, linewidth, _) = _scale_fig_size(figsize, textsize, rows, cols)
-
-    shade_kwargs = {} if shade_kwargs is None else shade_kwargs
-    rug_kwargs = {} if rug_kwargs is None else rug_kwargs
-    rug_kwargs.setdefault("fill_alpha", 0.1)
-    rug_kwargs.setdefault("line_alpha", 0.1)
-    if ax is None:
-        ax = create_axes_grid(
-            len(plotters),
-            rows,
-            cols,
-            sharex=sharex,
-            sharey=sharey,
-            figsize=figsize,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        ax = np.atleast_2d(ax)
-
-    for (var_name, selection, isel, x), ax_ in zip(
-        plotters, (item for item in ax.flatten() if item is not None)
-    ):
-        val = x.flatten()
-        if val[0].dtype.kind == "i":
-            dens = cat_hist(val, rug, side, shade, ax_, **shade_kwargs)
-        else:
-            dens = _violinplot(val, rug, side, shade, bw, circular, ax_, **shade_kwargs)
-        if rug:
-            rug_x = -np.abs(np.random.normal(scale=max(dens) / 3.5, size=len(val)))
-            ax_.scatter(rug_x, val, **rug_kwargs)
-
-        per = np.nanpercentile(val, [25, 75, 50])
-        hdi_probs = hdi(val, hdi_prob, multimodal=False, skipna=True)
-
-        if quartiles:
-            ax_.line(
-                [0, 0], per[:2], line_width=linewidth * 3, line_color="black", line_cap="round"
-            )
-        ax_.line([0, 0], hdi_probs, line_width=linewidth, line_color="black", line_cap="round")
-        ax_.scatter(
-            0,
-            per[-1],
-            marker="circle",
-            line_color="white",
-            fill_color="white",
-            size=linewidth * 1.5,
-            line_width=linewidth,
-        )
-
-        _title = Title()
-        _title.align = "center"
-        _title.text = labeller.make_label_vert(var_name, selection, isel)
-        ax_.title = _title
-        ax_.xaxis.major_tick_line_color = None
-        ax_.xaxis.minor_tick_line_color = None
-        ax_.xaxis.major_label_text_font_size = "0pt"
-
-    show_layout(ax, show)
-
-    return ax
-
-
-def _violinplot(val, rug, side, shade, bw, circular, ax, **shade_kwargs):
-    """Auxiliary function to plot violinplots."""
-    if bw == "default":
-        bw = "taylor" if circular else "experimental"
-    x, density = kde(val, circular=circular, bw=bw)
-
-    if rug and side == "both":
-        side = "right"
-
-    if side == "left":
-        dens = -density
-    elif side == "right":
-        x = x[::-1]
-        dens = density[::-1]
-    elif side == "both":
-        x = np.concatenate([x, x[::-1]])
-        dens = np.concatenate([-density, density[::-1]])
-
-    ax.harea(y=x, x1=dens, x2=np.zeros_like(dens), fill_alpha=shade, **shade_kwargs)
-
-    return density
-
-
-def cat_hist(val, rug, side, shade, ax, **shade_kwargs):
-    """Auxiliary function to plot discrete-violinplots."""
-    bins = get_bins(val)
-    _, binned_d, _ = histogram(val, bins=bins)
-
-    bin_edges = np.linspace(np.min(val), np.max(val), len(bins))
-    heights = np.diff(bin_edges)
-    centers = bin_edges[:-1] + heights.mean() / 2
-    bar_length = 0.5 * binned_d
-
-    if rug and side == "both":
-        side = "right"
-
-    if side == "right":
-        left = 0
-        right = bar_length
-    elif side == "left":
-        left = -bar_length
-        right = 0
-    elif side == "both":
-        left = -bar_length
-        right = bar_length
-
-    ax.hbar(
-        y=centers,
-        left=left,
-        right=right,
-        height=heights,
-        fill_alpha=shade,
-        line_alpha=shade,
-        line_color=None,
-        **shade_kwargs
-    )
-
-    return binned_d

arviz/plots/backends/matplotlib/__init__.py

@@ -1,124 +0,0 @@
-# pylint: disable=wrong-import-position
-"""Matplotlib Plotting Backend."""
-import matplotlib as mpl
-
-from matplotlib.cbook import normalize_kwargs
-from matplotlib.pyplot import subplots
-from numpy import ndenumerate
-
-from ....rcparams import rcParams
-
-
-def backend_kwarg_defaults(*args, **kwargs):
-    """Get default kwargs for backend.
-
-    For args add a tuple with key and rcParam key pair.
-    """
-    defaults = {**kwargs}
-    # add needed default args from arviz.rcParams
-    for key, arg in args:
-        defaults.setdefault(key, rcParams[arg])
-    return defaults
-
-
-def backend_show(show):
-    """Set default behaviour for show if not explicitly defined."""
-    if show is None:
-        show = rcParams["plot.matplotlib.show"]
-    return show
-
-
-def create_axes_grid(length_plotters, rows=1, cols=1, backend_kwargs=None):
-    """Create figure and axes for grids with multiple plots.
-
-    Parameters
-    ----------
-    length_plotters : int
-        Number of axes required
-    rows : int
-        Number of rows
-    cols : int
-        Number of columns
-    backend_kwargs: dict, optional
-        kwargs for backend figure.
-
-    Returns
-    -------
-    fig : matplotlib figure
-    ax : matplotlib axes
-    """
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {**backend_kwarg_defaults(), **backend_kwargs}
-
-    fig, axes = subplots(rows, cols, **backend_kwargs)
-    extra = (rows * cols) - length_plotters
-    if extra > 0:
-        for (row, col), ax in ndenumerate(axes):
-            if (row * cols + col + 1) > length_plotters:
-                ax.set_axis_off()
-    return fig, axes
-
-
-def matplotlib_kwarg_dealiaser(args, kind):
-    """De-aliase the kwargs passed to plots."""
-    if args is None:
-        return {}
-    matplotlib_kwarg_dealiaser_dict = {
-        "scatter": mpl.collections.PathCollection,
-        "plot": mpl.lines.Line2D,
-        "hist": mpl.patches.Patch,
-        "bar": mpl.patches.Rectangle,
-        "hexbin": mpl.collections.PolyCollection,
-        "fill_between": mpl.collections.PolyCollection,
-        "hlines": mpl.collections.LineCollection,
-        "text": mpl.text.Text,
-        "contour": mpl.contour.ContourSet,
-        "pcolormesh": mpl.collections.QuadMesh,
-    }
-    return normalize_kwargs(args, getattr(matplotlib_kwarg_dealiaser_dict[kind], "_alias_map", {}))
-
-
-def dealiase_sel_kwargs(kwargs, prop_dict, idx):
-    """Generate kwargs dict from kwargs and prop_dict.
-
-    Gets property at position ``idx`` for each property in prop_dict and adds it to
-    ``kwargs``. Values in prop_dict are dealiased and overwrite values in
-    kwargs with the same key .
-
-    Parameters
-    ----------
-    kwargs : dict
-    prop_dict : dict of {str : array_like}
-    idx : int
-    """
-    return {
-        **kwargs,
-        **matplotlib_kwarg_dealiaser(
-            {prop: props[idx] for prop, props in prop_dict.items()}, "plot"
-        ),
-    }
-
-
-from .autocorrplot import plot_autocorr
-from .bpvplot import plot_bpv
-from .compareplot import plot_compare
-from .densityplot import plot_density
-from .distplot import plot_dist
-from .elpdplot import plot_elpd
-from .energyplot import plot_energy
-from .essplot import plot_ess
-from .forestplot import plot_forest
-from .hdiplot import plot_hdi
-from .kdeplot import plot_kde
-from .khatplot import plot_khat
-from .loopitplot import plot_loo_pit
-from .mcseplot import plot_mcse
-from .pairplot import plot_pair
-from .parallelplot import plot_parallel
-from .posteriorplot import plot_posterior
-from .ppcplot import plot_ppc
-from .rankplot import plot_rank
-from .traceplot import plot_trace
-from .violinplot import plot_violin

arviz/plots/backends/matplotlib/autocorrplot.py

@@ -1,72 +0,0 @@
-"""Matplotlib Autocorrplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ....stats import autocorr
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-
-def plot_autocorr(
-    axes,
-    plotters,
-    max_lag,
-    figsize,
-    rows,
-    cols,
-    combined,
-    textsize,
-    labeller,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib autocorrplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, _, titlesize, xt_labelsize, linewidth, _ = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("sharex", True)
-    backend_kwargs.setdefault("sharey", True)
-    backend_kwargs.setdefault("squeeze", True)
-
-    if axes is None:
-        _, axes = create_axes_grid(
-            len(plotters),
-            rows,
-            cols,
-            backend_kwargs=backend_kwargs,
-        )
-
-    for (var_name, selection, isel, x), ax in zip(plotters, np.ravel(axes)):
-        x_prime = x
-        if combined:
-            x_prime = x.flatten()
-        c_i = 1.96 / x_prime.size**0.5
-        y = autocorr(x_prime)
-
-        ax.fill_between([0, max_lag], -c_i, c_i, color="0.75")
-        ax.vlines(x=np.arange(0, max_lag), ymin=0, ymax=y[0:max_lag], lw=linewidth)
-
-        ax.set_title(
-            labeller.make_label_vert(var_name, selection, isel), fontsize=titlesize, wrap=True
-        )
-        ax.tick_params(labelsize=xt_labelsize)
-
-    if np.asarray(axes).size > 0:
-        np.asarray(axes).item(0).set_xlim(0, max_lag)
-        np.asarray(axes).item(0).set_ylim(-1, 1)
-
-    if backend_show(show):
-        plt.show()
-
-    return axes

arviz/plots/backends/matplotlib/bfplot.py

@@ -1,78 +0,0 @@
-import matplotlib.pyplot as plt
-
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-from ...distplot import plot_dist
-from ...plot_utils import _scale_fig_size
-
-
-def plot_bf(
-    ax,
-    bf_10,
-    bf_01,
-    prior,
-    posterior,
-    ref_val,
-    prior_at_ref_val,
-    posterior_at_ref_val,
-    var_name,
-    colors,
-    figsize,
-    textsize,
-    plot_kwargs,
-    hist_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib Bayes Factor plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    if hist_kwargs is None:
-        hist_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, _, _, _, linewidth, _ = _scale_fig_size(figsize, textsize, 1, 1)
-
-    plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, "plot")
-    plot_kwargs.setdefault("linewidth", linewidth)
-    hist_kwargs.setdefault("alpha", 0.5)
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", True)
-
-    if ax is None:
-        _, ax = create_axes_grid(1, backend_kwargs=backend_kwargs)
-
-    plot_dist(
-        prior,
-        color=colors[0],
-        label="Prior",
-        ax=ax,
-        plot_kwargs=plot_kwargs,
-        hist_kwargs=hist_kwargs,
-    )
-    plot_dist(
-        posterior,
-        color=colors[1],
-        label="Posterior",
-        ax=ax,
-        plot_kwargs=plot_kwargs,
-        hist_kwargs=hist_kwargs,
-    )
-
-    ax.plot(ref_val, posterior_at_ref_val, "ko", lw=1.5)
-    ax.plot(ref_val, prior_at_ref_val, "ko", lw=1.5)
-    ax.axvline(ref_val, color="k", ls="--")
-    ax.set_xlabel(var_name)
-    ax.set_ylabel("Density")
-    ax.set_title(f"The BF_10 is {bf_10:.2f}\nThe BF_01 is {bf_01:.2f}")
-    plt.legend()
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/bpvplot.py

@@ -1,177 +0,0 @@
-"""Matplotib Bayesian p-value Posterior predictive plot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy import stats
-
-from ....stats.density_utils import kde
-from ....stats.stats_utils import smooth_data
-from ...kdeplot import plot_kde
-from ...plot_utils import (
-    _scale_fig_size,
-    is_valid_quantile,
-    sample_reference_distribution,
-)
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_bpv(
-    ax,
-    length_plotters,
-    rows,
-    cols,
-    obs_plotters,
-    pp_plotters,
-    total_pp_samples,
-    kind,
-    t_stat,
-    bpv,
-    plot_mean,
-    reference,
-    mse,
-    n_ref,
-    hdi_prob,
-    color,
-    figsize,
-    textsize,
-    labeller,
-    plot_ref_kwargs,
-    backend_kwargs,
-    show,
-    smoothing,
-):
-    """Matplotlib bpv plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, ax_labelsize, _, _, linewidth, markersize = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", True)
-
-    if (kind == "u_value") and (reference == "analytical"):
-        plot_ref_kwargs = matplotlib_kwarg_dealiaser(plot_ref_kwargs, "fill_between")
-    else:
-        plot_ref_kwargs = matplotlib_kwarg_dealiaser(plot_ref_kwargs, "plot")
-
-    if kind == "p_value" and reference == "analytical":
-        plot_ref_kwargs.setdefault("color", "k")
-        plot_ref_kwargs.setdefault("linestyle", "--")
-    elif kind == "u_value" and reference == "analytical":
-        plot_ref_kwargs.setdefault("color", "k")
-        plot_ref_kwargs.setdefault("alpha", 0.2)
-    else:
-        plot_ref_kwargs.setdefault("alpha", 0.1)
-        plot_ref_kwargs.setdefault("color", color)
-
-    if ax is None:
-        _, axes = create_axes_grid(length_plotters, rows, cols, backend_kwargs=backend_kwargs)
-    else:
-        axes = np.asarray(ax)
-        if axes.size < length_plotters:
-            raise ValueError(
-                f"Found {length_plotters} variables to plot but {axes.size} axes instances. "
-                "Axes instances must at minimum be equal to variables."
-            )
-
-    for i, ax_i in enumerate(np.ravel(axes)[:length_plotters]):
-        var_name, selection, isel, obs_vals = obs_plotters[i]
-        pp_var_name, _, _, pp_vals = pp_plotters[i]
-
-        obs_vals = obs_vals.flatten()
-        pp_vals = pp_vals.reshape(total_pp_samples, -1)
-
-        if (obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i") and smoothing is True:
-            obs_vals, pp_vals = smooth_data(obs_vals, pp_vals)
-
-        if kind == "p_value":
-            tstat_pit = np.mean(pp_vals <= obs_vals, axis=-1)
-            x_s, tstat_pit_dens = kde(tstat_pit)
-            ax_i.plot(x_s, tstat_pit_dens, linewidth=linewidth, color=color)
-            ax_i.set_yticks([])
-            if reference is not None:
-                dist = stats.beta(obs_vals.size / 2, obs_vals.size / 2)
-                if reference == "analytical":
-                    lwb = dist.ppf((1 - 0.9999) / 2)
-                    upb = 1 - lwb
-                    x = np.linspace(lwb, upb, 500)
-                    dens_ref = dist.pdf(x)
-                    ax_i.plot(x, dens_ref, zorder=1, **plot_ref_kwargs)
-                elif reference == "samples":
-                    x_ss, u_dens = sample_reference_distribution(
-                        dist,
-                        (
-                            tstat_pit_dens.size,
-                            n_ref,
-                        ),
-                    )
-                    ax_i.plot(x_ss, u_dens, linewidth=linewidth, **plot_ref_kwargs)
-
-        elif kind == "u_value":
-            tstat_pit = np.mean(pp_vals <= obs_vals, axis=0)
-            x_s, tstat_pit_dens = kde(tstat_pit)
-            ax_i.plot(x_s, tstat_pit_dens, color=color)
-            if reference is not None:
-                if reference == "analytical":
-                    n_obs = obs_vals.size
-                    hdi_ = stats.beta(n_obs / 2, n_obs / 2).ppf((1 - hdi_prob) / 2)
-                    hdi_odds = (hdi_ / (1 - hdi_), (1 - hdi_) / hdi_)
-                    ax_i.axhspan(*hdi_odds, **plot_ref_kwargs)
-                    ax_i.axhline(1, color="w", zorder=1)
-                elif reference == "samples":
-                    dist = stats.uniform(0, 1)
-                    x_ss, u_dens = sample_reference_distribution(dist, (tstat_pit_dens.size, n_ref))
-                    ax_i.plot(x_ss, u_dens, linewidth=linewidth, **plot_ref_kwargs)
-            if mse:
-                ax_i.plot(0, 0, label=f"mse={np.mean((1 - tstat_pit_dens)**2) * 100:.2f}")
-                ax_i.legend()
-
-            ax_i.set_ylim(0, None)
-            ax_i.set_xlim(0, 1)
-        else:
-            if t_stat in ["mean", "median", "std"]:
-                if t_stat == "mean":
-                    tfunc = np.mean
-                elif t_stat == "median":
-                    tfunc = np.median
-                elif t_stat == "std":
-                    tfunc = np.std
-                obs_vals = tfunc(obs_vals)
-                pp_vals = tfunc(pp_vals, axis=1)
-            elif hasattr(t_stat, "__call__"):
-                obs_vals = t_stat(obs_vals.flatten())
-                pp_vals = t_stat(pp_vals)
-            elif is_valid_quantile(t_stat):
-                t_stat = float(t_stat)
-                obs_vals = np.quantile(obs_vals, q=t_stat)
-                pp_vals = np.quantile(pp_vals, q=t_stat, axis=1)
-            else:
-                raise ValueError(f"T statistics {t_stat} not implemented")
-
-            plot_kde(pp_vals, ax=ax_i, plot_kwargs={"color": color})
-            ax_i.set_yticks([])
-            if bpv:
-                p_value = np.mean(pp_vals <= obs_vals)
-                ax_i.plot(obs_vals, 0, label=f"bpv={p_value:.2f}", alpha=0)
-                ax_i.legend()
-
-            if plot_mean:
-                ax_i.plot(
-                    obs_vals.mean(), 0, "o", color=color, markeredgecolor="k", markersize=markersize
-                )
-
-        ax_i.set_title(
-            labeller.make_pp_label(var_name, pp_var_name, selection, isel), fontsize=ax_labelsize
-        )
-
-    if backend_show(show):
-        plt.show()
-
-    return axes