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

arviz/plots/backends/matplotlib/compareplot.py

@@ -1,135 +0,0 @@
-"""Matplotlib Compareplot."""
-
-import matplotlib.pyplot as plt
-
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-
-def plot_compare(
-    ax,
-    comp_df,
-    legend,
-    title,
-    figsize,
-    plot_ic_diff,
-    plot_standard_error,
-    insample_dev,
-    yticks_pos,
-    yticks_labels,
-    plot_kwargs,
-    information_criterion,
-    textsize,
-    step,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib compare plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if figsize is None:
-        figsize = (6, len(comp_df))
-
-    figsize, ax_labelsize, _, 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)
-
-    if plot_standard_error:
-        ax.errorbar(
-            x=comp_df[information_criterion],
-            y=yticks_pos[::2],
-            xerr=comp_df.se,
-            label="ELPD",
-            color=plot_kwargs.get("color_ic", "k"),
-            fmt=plot_kwargs.get("marker_ic", "o"),
-            mfc=plot_kwargs.get("marker_fc", "white"),
-            mew=linewidth,
-            lw=linewidth,
-        )
-    else:
-        ax.plot(
-            comp_df[information_criterion],
-            yticks_pos[::2],
-            label="ELPD",
-            color=plot_kwargs.get("color_ic", "k"),
-            marker=plot_kwargs.get("marker_ic", "o"),
-            mfc=plot_kwargs.get("marker_fc", "white"),
-            mew=linewidth,
-            lw=0,
-            zorder=3,
-        )
-
-    if plot_ic_diff:
-        ax.set_yticks(yticks_pos)
-        ax.errorbar(
-            x=comp_df[information_criterion].iloc[1:],
-            y=yticks_pos[1::2],
-            xerr=comp_df.dse[1:],
-            label="ELPD difference",
-            color=plot_kwargs.get("color_dse", "grey"),
-            fmt=plot_kwargs.get("marker_dse", "^"),
-            mew=linewidth,
-            elinewidth=linewidth,
-        )
-
-    else:
-        ax.set_yticks(yticks_pos[::2])
-
-    scale = comp_df["scale"].iloc[0]
-
-    if insample_dev:
-        p_ic = comp_df[f"p_{information_criterion.split('_')[1]}"]
-        if scale == "log":
-            correction = p_ic
-        elif scale == "negative_log":
-            correction = -p_ic
-        elif scale == "deviance":
-            correction = -(2 * p_ic)
-        ax.plot(
-            comp_df[information_criterion] + correction,
-            yticks_pos[::2],
-            label="In-sample ELPD",
-            color=plot_kwargs.get("color_insample_dev", "k"),
-            marker=plot_kwargs.get("marker_insample_dev", "o"),
-            mew=linewidth,
-            lw=0,
-        )
-
-    ax.axvline(
-        comp_df[information_criterion].iloc[0],
-        ls=plot_kwargs.get("ls_min_ic", "--"),
-        color=plot_kwargs.get("color_ls_min_ic", "grey"),
-        lw=linewidth,
-    )
-    if legend:
-        ax.legend(bbox_to_anchor=(1.01, 1), loc="upper left", ncol=1, fontsize=ax_labelsize)
-
-    if title:
-        ax.set_title(
-            f"Model comparison\n{'higher' if scale == 'log' else 'lower'} is better",
-            fontsize=ax_labelsize,
-        )
-
-    if scale == "negative_log":
-        scale = "-log"
-
-    ax.set_xlabel(f"{information_criterion} ({scale})", fontsize=ax_labelsize)
-    ax.set_ylabel("ranked models", fontsize=ax_labelsize)
-    ax.set_yticklabels(yticks_labels)
-    ax.set_ylim(-1 + step, 0 - step)
-    ax.tick_params(labelsize=xt_labelsize)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/densityplot.py

@@ -1,194 +0,0 @@
-"""Matplotlib Densityplot."""
-
-from itertools import cycle
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ....stats import hdi
-from ....stats.density_utils import get_bins, kde
-from ...plot_utils import _scale_fig_size, calculate_point_estimate
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-
-def plot_density(
-    ax,
-    all_labels,
-    to_plot,
-    colors,
-    bw,
-    circular,
-    figsize,
-    length_plotters,
-    rows,
-    cols,
-    textsize,
-    labeller,
-    hdi_prob,
-    point_estimate,
-    hdi_markers,
-    outline,
-    shade,
-    n_data,
-    data_labels,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib densityplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if colors == "cycle":
-        colors = [
-            prop
-            for _, prop in zip(
-                range(n_data), cycle(plt.rcParams["axes.prop_cycle"].by_key()["color"])
-            )
-        ]
-    elif isinstance(colors, str):
-        colors = [colors for _ in range(n_data)]
-
-    (figsize, _, titlesize, xt_labelsize, linewidth, markersize) = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", False)
-    if ax is None:
-        _, ax = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            backend_kwargs=backend_kwargs,
-        )
-
-    axis_map = dict(zip(all_labels, np.ravel(ax)))
-
-    for m_idx, plotters in enumerate(to_plot):
-        for var_name, selection, isel, values in plotters:
-            label = labeller.make_label_vert(var_name, selection, isel)
-            _d_helper(
-                values.flatten(),
-                label,
-                colors[m_idx],
-                bw,
-                circular,
-                titlesize,
-                xt_labelsize,
-                linewidth,
-                markersize,
-                hdi_prob,
-                point_estimate,
-                hdi_markers,
-                outline,
-                shade,
-                axis_map[label],
-            )
-
-    if n_data > 1:
-        for m_idx, label in enumerate(data_labels):
-            np.ravel(ax).item(0).plot([], label=label, c=colors[m_idx], markersize=markersize)
-        np.ravel(ax).item(0).legend(fontsize=xt_labelsize)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax
-
-
-def _d_helper(
-    vec,
-    vname,
-    color,
-    bw,
-    circular,
-    titlesize,
-    xt_labelsize,
-    linewidth,
-    markersize,
-    hdi_prob,
-    point_estimate,
-    hdi_markers,
-    outline,
-    shade,
-    ax,
-):
-    """Plot an individual dimension.
-
-    Parameters
-    ----------
-    vec : array
-        1D array from trace
-    vname : str
-        variable name
-    color : str
-        matplotlib color
-    bw: float or str, optional
-        If numeric, indicates the bandwidth and must be positive.
-        If str, indicates the method to estimate the bandwidth and must be
-        one of "scott", "silverman", "isj" or "experimental" when `circular` is False
-        and "taylor" (for now) when `circular` is True.
-    titlesize : float
-        font size for title
-    xt_labelsize : float
-       fontsize for xticks
-    linewidth : float
-        Thickness of lines
-    markersize : float
-        Size of markers
-    hdi_prob : float
-        Probability for the highest density interval. Defaults to 0.94
-    point_estimate : Optional[str]
-        Plot point estimate per variable. Values should be 'mean', 'median', 'mode' or None.
-        Defaults to 'auto' i.e. it falls back to default set in rcParams.
-    shade : float
-        Alpha blending value for the shaded area under the curve, between 0 (no shade) and 1
-        (opaque). Defaults to 0.
-    ax : matplotlib axes
-    """
-    if vec.dtype.kind == "f":
-        if hdi_prob != 1:
-            hdi_ = hdi(vec, hdi_prob, multimodal=False)
-            new_vec = vec[(vec >= hdi_[0]) & (vec <= hdi_[1])]
-        else:
-            new_vec = vec
-
-        x, density = kde(new_vec, circular=circular, bw=bw)
-        density *= hdi_prob
-        xmin, xmax = x[0], x[-1]
-        ymin, ymax = density[0], density[-1]
-
-        if outline:
-            ax.plot(x, density, color=color, lw=linewidth)
-            ax.plot([xmin, xmin], [-ymin / 100, ymin], color=color, ls="-", lw=linewidth)
-            ax.plot([xmax, xmax], [-ymax / 100, ymax], color=color, ls="-", lw=linewidth)
-
-        if shade:
-            ax.fill_between(x, density, color=color, alpha=shade)
-
-    else:
-        xmin, xmax = hdi(vec, hdi_prob, multimodal=False)
-        bins = get_bins(vec)
-        if outline:
-            ax.hist(vec, bins=bins, color=color, histtype="step", align="left")
-        if shade:
-            ax.hist(vec, bins=bins, color=color, alpha=shade)
-
-    if hdi_markers:
-        ax.plot(xmin, 0, hdi_markers, color=color, markeredgecolor="k", markersize=markersize)
-        ax.plot(xmax, 0, hdi_markers, color=color, markeredgecolor="k", markersize=markersize)
-
-    if point_estimate is not None:
-        est = calculate_point_estimate(point_estimate, vec, bw)
-        ax.plot(est, 0, "o", color=color, markeredgecolor="k", markersize=markersize)
-
-    ax.set_yticks([])
-    ax.set_title(vname, fontsize=titlesize, wrap=True)
-    for pos in ["left", "right", "top"]:
-        ax.spines[pos].set_visible(False)
-    ax.tick_params(labelsize=xt_labelsize)

arviz/plots/backends/matplotlib/distcomparisonplot.py

@@ -1,119 +0,0 @@
-"""Matplotlib Density Comparison plot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ...distplot import plot_dist
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show
-
-
-def plot_dist_comparison(
-    ax,
-    nvars,
-    ngroups,
-    figsize,
-    dc_plotters,
-    legend,
-    groups,
-    textsize,
-    labeller,
-    prior_kwargs,
-    posterior_kwargs,
-    observed_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib Density Comparison plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if prior_kwargs is None:
-        prior_kwargs = {}
-
-    if posterior_kwargs is None:
-        posterior_kwargs = {}
-
-    if observed_kwargs is None:
-        observed_kwargs = {}
-
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    (figsize, _, _, _, linewidth, _) = _scale_fig_size(figsize, textsize, 2 * nvars, ngroups)
-
-    backend_kwargs.setdefault("figsize", figsize)
-
-    posterior_kwargs.setdefault("plot_kwargs", {})
-    posterior_kwargs["plot_kwargs"]["color"] = posterior_kwargs["plot_kwargs"].get("color", "C0")
-    posterior_kwargs["plot_kwargs"].setdefault("linewidth", linewidth)
-    posterior_kwargs.setdefault("hist_kwargs", {})
-    posterior_kwargs["hist_kwargs"].setdefault("alpha", 0.5)
-
-    prior_kwargs.setdefault("plot_kwargs", {})
-    prior_kwargs["plot_kwargs"]["color"] = prior_kwargs["plot_kwargs"].get("color", "C1")
-    prior_kwargs["plot_kwargs"].setdefault("linewidth", linewidth)
-    prior_kwargs.setdefault("hist_kwargs", {})
-    prior_kwargs["hist_kwargs"].setdefault("alpha", 0.5)
-
-    observed_kwargs.setdefault("plot_kwargs", {})
-    observed_kwargs["plot_kwargs"]["color"] = observed_kwargs["plot_kwargs"].get("color", "C2")
-    observed_kwargs["plot_kwargs"].setdefault("linewidth", linewidth)
-    observed_kwargs.setdefault("hist_kwargs", {})
-    observed_kwargs["hist_kwargs"].setdefault("alpha", 0.5)
-
-    if ax is None:
-        axes = np.empty((nvars, ngroups + 1), dtype=object)
-        fig = plt.figure(**backend_kwargs)
-        gs = fig.add_gridspec(ncols=ngroups, nrows=nvars * 2)
-        for i in range(nvars):
-            for j in range(ngroups):
-                axes[i, j] = fig.add_subplot(gs[2 * i, j])
-            axes[i, -1] = fig.add_subplot(gs[2 * i + 1, :])
-
-    else:
-        axes = ax
-        if ax.shape != (nvars, ngroups + 1):
-            raise ValueError(
-                f"Found {axes.shape} shape of axes, "
-                f"which is not equal to data shape {(nvars, ngroups + 1)}."
-            )
-
-    for idx, plotter in enumerate(dc_plotters):
-        group = groups[idx]
-        kwargs = (
-            prior_kwargs
-            if group.startswith("prior")
-            else posterior_kwargs if group.startswith("posterior") else observed_kwargs
-        )
-        for idx2, (
-            var_name,
-            sel,
-            isel,
-            data,
-        ) in enumerate(plotter):
-            label = f"{group}"
-            plot_dist(
-                data,
-                label=label if legend else None,
-                ax=axes[idx2, idx],
-                **kwargs,
-            )
-            plot_dist(
-                data,
-                label=label if legend else None,
-                ax=axes[idx2, -1],
-                **kwargs,
-            )
-            if idx == 0:
-                axes[idx2, -1].set_xlabel(labeller.make_label_vert(var_name, sel, isel))
-
-    if backend_show(show):
-        plt.show()
-
-    return axes

arviz/plots/backends/matplotlib/distplot.py

@@ -1,178 +0,0 @@
-"""Matplotlib distplot."""
-
-import matplotlib.pyplot as plt
-from matplotlib import _pylab_helpers
-import numpy as np
-
-from ....stats.density_utils import get_bins
-from ...kdeplot import plot_kde
-from ...plot_utils import _scale_fig_size, _init_kwargs_dict
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_dist(
-    values,
-    values2,
-    color,
-    kind,
-    cumulative,
-    label,
-    rotated,
-    rug,
-    bw,
-    quantiles,
-    contour,
-    fill_last,
-    figsize,
-    textsize,
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    contour_kwargs,
-    contourf_kwargs,
-    pcolormesh_kwargs,
-    hist_kwargs,
-    is_circular,
-    ax,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib distplot."""
-    backend_kwargs = _init_kwargs_dict(backend_kwargs)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, *_ = _scale_fig_size(figsize, textsize)
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-    backend_kwargs.setdefault("subplot_kw", {})
-    backend_kwargs["subplot_kw"].setdefault("polar", is_circular)
-
-    if ax is None:
-        fig_manager = _pylab_helpers.Gcf.get_active()
-        if fig_manager is not None:
-            ax = fig_manager.canvas.figure.gca()
-        else:
-            _, ax = create_axes_grid(
-                1,
-                backend_kwargs=backend_kwargs,
-            )
-
-    if kind == "hist":
-        hist_kwargs = matplotlib_kwarg_dealiaser(hist_kwargs, "hist")
-        hist_kwargs.setdefault("cumulative", cumulative)
-        hist_kwargs.setdefault("color", color)
-        hist_kwargs.setdefault("label", label)
-        hist_kwargs.setdefault("rwidth", 0.9)
-        hist_kwargs.setdefault("density", True)
-
-        if rotated:
-            hist_kwargs.setdefault("orientation", "horizontal")
-        else:
-            hist_kwargs.setdefault("orientation", "vertical")
-
-        ax = _histplot_mpl_op(
-            values=values,
-            values2=values2,
-            rotated=rotated,
-            ax=ax,
-            hist_kwargs=hist_kwargs,
-            is_circular=is_circular,
-        )
-
-    elif kind == "kde":
-        plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, "plot")
-        plot_kwargs.setdefault("color", color)
-        legend = label is not None
-
-        ax = plot_kde(
-            values,
-            values2,
-            cumulative=cumulative,
-            rug=rug,
-            label=label,
-            bw=bw,
-            quantiles=quantiles,
-            rotated=rotated,
-            contour=contour,
-            legend=legend,
-            fill_last=fill_last,
-            textsize=textsize,
-            plot_kwargs=plot_kwargs,
-            fill_kwargs=fill_kwargs,
-            rug_kwargs=rug_kwargs,
-            contour_kwargs=contour_kwargs,
-            contourf_kwargs=contourf_kwargs,
-            pcolormesh_kwargs=pcolormesh_kwargs,
-            ax=ax,
-            backend="matplotlib",
-            backend_kwargs=backend_kwargs,
-            is_circular=is_circular,
-            show=show,
-        )
-
-    if backend_show(show):
-        plt.show()
-
-    return ax
-
-
-def _histplot_mpl_op(values, values2, rotated, ax, hist_kwargs, is_circular):
-    """Add a histogram for the data to the axes."""
-    bins = hist_kwargs.pop("bins", None)
-
-    if is_circular == "degrees":
-        if bins is None:
-            bins = get_bins(values)
-        values = np.deg2rad(values)
-        bins = np.deg2rad(bins)
-
-    elif is_circular:
-        labels = [
-            "0",
-            f"{np.pi/4:.2f}",
-            f"{np.pi/2:.2f}",
-            f"{3*np.pi/4:.2f}",
-            f"{np.pi:.2f}",
-            f"{-3*np.pi/4:.2f}",
-            f"{-np.pi/2:.2f}",
-            f"{-np.pi/4:.2f}",
-        ]
-
-        ax.set_xticklabels(labels)
-
-    if values2 is not None:
-        raise NotImplementedError("Insert hexbin plot here")
-
-    if bins is None:
-        bins = get_bins(values)
-
-    if values.dtype.kind == "i":
-        hist_kwargs.setdefault("align", "left")
-    else:
-        hist_kwargs.setdefault("align", "mid")
-
-    n, bins, _ = ax.hist(np.asarray(values).flatten(), bins=bins, **hist_kwargs)
-
-    if values.dtype.kind == "i":
-        ticks = bins[:-1]
-    else:
-        ticks = (bins[1:] + bins[:-1]) / 2
-
-    if rotated:
-        ax.set_yticks(ticks)
-    elif not is_circular:
-        ax.set_xticks(ticks)
-
-    if is_circular:
-        ax.set_ylim(0, 1.5 * n.max())
-        ax.set_yticklabels([])
-
-    if hist_kwargs.get("label") is not None:
-        ax.legend()
-
-    return ax