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

arviz/plots/backends/matplotlib/ppcplot.py

@@ -1,478 +0,0 @@
-"""Matplotlib Posterior predictive plot."""
-
-import logging
-import platform
-
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib import animation, get_backend
-
-from ....stats.density_utils import get_bins, histogram, kde
-from ...kdeplot import plot_kde
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-_log = logging.getLogger(__name__)
-
-
-def plot_ppc(
-    ax,
-    length_plotters,
-    rows,
-    cols,
-    figsize,
-    animated,
-    obs_plotters,
-    pp_plotters,
-    predictive_dataset,
-    pp_sample_ix,
-    kind,
-    alpha,
-    colors,
-    textsize,
-    mean,
-    observed,
-    observed_rug,
-    jitter,
-    total_pp_samples,
-    legend,
-    labeller,
-    group,
-    animation_kwargs,
-    num_pp_samples,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib ppc plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if animation_kwargs is None:
-        animation_kwargs = {}
-    if platform.system() == "Linux":
-        animation_kwargs.setdefault("blit", True)
-    else:
-        animation_kwargs.setdefault("blit", False)
-
-    if alpha is None:
-        if animated:
-            alpha = 1
-        else:
-            if kind.lower() == "scatter":
-                alpha = 0.7
-            else:
-                alpha = 0.2
-
-    if jitter is None:
-        jitter = 0.0
-    if jitter < 0.0:
-        raise ValueError("jitter must be >=0")
-
-    if animated:
-        try:
-            shell = get_ipython().__class__.__name__
-            if shell == "ZMQInteractiveShell" and get_backend() != "nbAgg":
-                raise Warning(
-                    "To run animations inside a notebook you have to use the nbAgg backend. "
-                    "Try with `%matplotlib notebook` or  `%matplotlib  nbAgg`. You can switch "
-                    "back to the default backend with `%matplotlib  inline` or "
-                    "`%matplotlib  auto`."
-                )
-        except NameError:
-            pass
-
-        if animation_kwargs["blit"] and platform.system() != "Linux":
-            _log.warning(
-                "If you experience problems rendering the animation try setting "
-                "`animation_kwargs({'blit':False}) or changing the plotting backend "
-                "(e.g. to TkAgg)"
-            )
-
-    (figsize, ax_labelsize, _, xt_labelsize, linewidth, markersize) = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", True)
-    if ax is None:
-        fig, axes = create_axes_grid(length_plotters, rows, cols, backend_kwargs=backend_kwargs)
-    else:
-        axes = np.ravel(ax)
-        if len(axes) != length_plotters:
-            raise ValueError(
-                "Found {} variables to plot but {} axes instances. They must be equal.".format(
-                    length_plotters, len(axes)
-                )
-            )
-        if animated:
-            fig = axes[0].get_figure()
-            if not all((ax.get_figure() is fig for ax in axes)):
-                raise ValueError("All axes must be on the same figure for animation to work")
-
-    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]
-        dtype = predictive_dataset[pp_var_name].dtype.kind
-
-        if dtype not in ["i", "f"]:
-            raise ValueError(
-                f"The data type of the predictive data must be one of 'i' or 'f', but is '{dtype}'"
-            )
-
-        # flatten non-specified dimensions
-        obs_vals = obs_vals.flatten()
-        pp_vals = pp_vals.reshape(total_pp_samples, -1)
-        pp_sampled_vals = pp_vals[pp_sample_ix]
-
-        if kind == "kde":
-            plot_kwargs = {"color": colors[0], "alpha": alpha, "linewidth": 0.5 * linewidth}
-            if dtype == "i":
-                plot_kwargs["drawstyle"] = "steps-pre"
-            ax_i.plot([], color=colors[0], label=f"{group.capitalize()} predictive")
-            if observed:
-                if dtype == "f":
-                    plot_kde(
-                        obs_vals,
-                        rug=observed_rug,
-                        label="Observed",
-                        plot_kwargs={"color": colors[1], "linewidth": linewidth, "zorder": 3},
-                        fill_kwargs={"alpha": 0},
-                        ax=ax_i,
-                        legend=legend,
-                    )
-                else:
-                    bins = get_bins(obs_vals)
-                    _, hist, bin_edges = histogram(obs_vals, bins=bins)
-                    hist = np.concatenate((hist[:1], hist))
-                    ax_i.plot(
-                        bin_edges,
-                        hist,
-                        label="Observed",
-                        color=colors[1],
-                        linewidth=linewidth,
-                        zorder=3,
-                        drawstyle=plot_kwargs["drawstyle"],
-                    )
-
-            pp_densities = []
-            pp_xs = []
-            for vals in pp_sampled_vals:
-                vals = np.array([vals]).flatten()
-                if dtype == "f":
-                    pp_x, pp_density = kde(vals)
-                    pp_densities.append(pp_density)
-                    pp_xs.append(pp_x)
-                else:
-                    bins = get_bins(vals)
-                    _, hist, bin_edges = histogram(vals, bins=bins)
-                    hist = np.concatenate((hist[:1], hist))
-                    pp_densities.append(hist)
-                    pp_xs.append(bin_edges)
-
-            if animated:
-                animate, init = _set_animation(
-                    pp_sampled_vals, ax_i, dtype=dtype, kind=kind, plot_kwargs=plot_kwargs
-                )
-
-            else:
-                if dtype == "f":
-                    ax_i.plot(np.transpose(pp_xs), np.transpose(pp_densities), **plot_kwargs)
-                else:
-                    for x_s, y_s in zip(pp_xs, pp_densities):
-                        ax_i.plot(x_s, y_s, **plot_kwargs)
-
-            if mean:
-                label = f"{group.capitalize()} predictive mean"
-                if dtype == "f":
-                    rep = len(pp_densities)
-                    len_density = len(pp_densities[0])
-
-                    new_x = np.linspace(np.min(pp_xs), np.max(pp_xs), len_density)
-                    new_d = np.zeros((rep, len_density))
-                    bins = np.digitize(pp_xs, new_x, right=True)
-                    new_x -= (new_x[1] - new_x[0]) / 2
-                    for irep in range(rep):
-                        new_d[irep][bins[irep]] = pp_densities[irep]
-                    ax_i.plot(
-                        new_x,
-                        new_d.mean(0),
-                        color=colors[2],
-                        linestyle="--",
-                        linewidth=linewidth * 1.5,
-                        zorder=2,
-                        label=label,
-                    )
-                else:
-                    vals = pp_vals.flatten()
-                    bins = get_bins(vals)
-                    _, hist, bin_edges = histogram(vals, bins=bins)
-                    hist = np.concatenate((hist[:1], hist))
-                    ax_i.plot(
-                        bin_edges,
-                        hist,
-                        color=colors[2],
-                        linewidth=linewidth * 1.5,
-                        label=label,
-                        zorder=2,
-                        linestyle="--",
-                        drawstyle=plot_kwargs["drawstyle"],
-                    )
-            ax_i.tick_params(labelsize=xt_labelsize)
-            ax_i.set_yticks([])
-
-        elif kind == "cumulative":
-            drawstyle = "default" if dtype == "f" else "steps-pre"
-            if observed:
-                ax_i.plot(
-                    *_empirical_cdf(obs_vals),
-                    color=colors[1],
-                    linewidth=linewidth,
-                    label="Observed",
-                    drawstyle=drawstyle,
-                    zorder=3,
-                )
-                if observed_rug:
-                    ax_i.plot(
-                        obs_vals,
-                        np.zeros_like(obs_vals) - 0.1,
-                        ls="",
-                        marker="|",
-                        color=colors[1],
-                    )
-            if animated:
-                animate, init = _set_animation(
-                    pp_sampled_vals,
-                    ax_i,
-                    kind=kind,
-                    alpha=alpha,
-                    drawstyle=drawstyle,
-                    linewidth=linewidth,
-                )
-
-            else:
-                pp_densities = np.empty((2 * len(pp_sampled_vals), pp_sampled_vals[0].size))
-                for idx, vals in enumerate(pp_sampled_vals):
-                    vals = np.array([vals]).flatten()
-                    pp_x, pp_density = _empirical_cdf(vals)
-                    pp_densities[2 * idx] = pp_x
-                    pp_densities[2 * idx + 1] = pp_density
-
-                ax_i.plot(
-                    *pp_densities,
-                    alpha=alpha,
-                    color=colors[0],
-                    drawstyle=drawstyle,
-                    linewidth=linewidth,
-                )
-            ax_i.plot([], color=colors[0], label=f"{group.capitalize()} predictive")
-            if mean:
-                ax_i.plot(
-                    *_empirical_cdf(pp_vals.flatten()),
-                    color=colors[2],
-                    linestyle="--",
-                    linewidth=linewidth * 1.5,
-                    drawstyle=drawstyle,
-                    label=f"{group.capitalize()} predictive mean",
-                )
-            ax_i.set_yticks([0, 0.5, 1])
-
-        elif kind == "scatter":
-            if mean:
-                if dtype == "f":
-                    plot_kde(
-                        pp_vals.flatten(),
-                        plot_kwargs={
-                            "color": colors[2],
-                            "linestyle": "--",
-                            "linewidth": linewidth * 1.5,
-                            "zorder": 3,
-                        },
-                        label=f"{group.capitalize()} predictive mean",
-                        ax=ax_i,
-                        legend=legend,
-                    )
-                else:
-                    vals = pp_vals.flatten()
-                    bins = get_bins(vals)
-                    _, hist, bin_edges = histogram(vals, bins=bins)
-                    hist = np.concatenate((hist[:1], hist))
-                    ax_i.plot(
-                        bin_edges,
-                        hist,
-                        color=colors[2],
-                        linewidth=linewidth * 1.5,
-                        label=f"{group.capitalize()} predictive mean",
-                        zorder=3,
-                        linestyle="--",
-                        drawstyle="steps-pre",
-                    )
-
-            _, limit = ax_i.get_ylim()
-            limit *= 1.05
-            y_rows = np.linspace(0, limit, num_pp_samples + 1)
-            jitter_scale = y_rows[1] - y_rows[0]
-            scale_low = 0
-            scale_high = jitter_scale * jitter
-
-            if observed:
-                obs_yvals = np.zeros_like(obs_vals, dtype=np.float64)
-                if jitter:
-                    obs_yvals += np.random.uniform(
-                        low=scale_low, high=scale_high, size=len(obs_vals)
-                    )
-                ax_i.plot(
-                    obs_vals,
-                    obs_yvals,
-                    "o",
-                    color=colors[1],
-                    markersize=markersize,
-                    alpha=alpha,
-                    label="Observed",
-                    zorder=4,
-                )
-
-            if animated:
-                animate, init = _set_animation(
-                    pp_sampled_vals,
-                    ax_i,
-                    kind=kind,
-                    color=colors[0],
-                    height=y_rows.mean() * 0.5,
-                    markersize=markersize,
-                )
-
-            else:
-                for vals, y in zip(pp_sampled_vals, y_rows[1:]):
-                    vals = np.ravel(vals)
-                    yvals = np.full_like(vals, y, dtype=np.float64)
-                    if jitter:
-                        yvals += np.random.uniform(low=scale_low, high=scale_high, size=len(vals))
-                    ax_i.plot(
-                        vals,
-                        yvals,
-                        "o",
-                        zorder=2,
-                        color=colors[0],
-                        markersize=markersize,
-                        alpha=alpha,
-                    )
-
-            ax_i.plot([], color=colors[0], marker="o", label=f"{group.capitalize()} predictive")
-
-            ax_i.set_yticks([])
-
-        ax_i.set_xlabel(
-            labeller.make_pp_label(var_name, pp_var_name, selection, isel), fontsize=ax_labelsize
-        )
-
-        if legend:
-            if i == 0:
-                ax_i.legend(fontsize=xt_labelsize * 0.75)
-
-    if backend_show(show):
-        plt.show()
-
-    if animated:
-        ani = animation.FuncAnimation(
-            fig, animate, np.arange(0, num_pp_samples), init_func=init, **animation_kwargs
-        )
-        return axes, ani
-    else:
-        return axes
-
-
-def _set_animation(
-    pp_sampled_vals,
-    ax,
-    dtype=None,
-    kind="density",
-    alpha=None,
-    color=None,
-    drawstyle=None,
-    linewidth=None,
-    height=None,
-    markersize=None,
-    plot_kwargs=None,
-):
-    if kind == "kde":
-        length = len(pp_sampled_vals)
-        if dtype == "f":
-            x_vals, y_vals = kde(pp_sampled_vals[0])
-            max_max = max(max(kde(pp_sampled_vals[i])[1]) for i in range(length))
-            ax.set_ylim(0, max_max)
-            (line,) = ax.plot(x_vals, y_vals, **plot_kwargs)
-
-            def animate(i):
-                x_vals, y_vals = kde(pp_sampled_vals[i])
-                line.set_data(x_vals, y_vals)
-                return (line,)
-
-        else:
-            vals = pp_sampled_vals[0]
-            bins = get_bins(vals)
-            _, y_vals, x_vals = histogram(vals, bins=bins)
-            (line,) = ax.plot(x_vals[:-1], y_vals, **plot_kwargs)
-
-            max_max = max(
-                max(histogram(pp_sampled_vals[i], bins=get_bins(pp_sampled_vals[i]))[1])
-                for i in range(length)
-            )
-
-            ax.set_ylim(0, max_max)
-
-            def animate(i):
-                pp_vals = pp_sampled_vals[i]
-                _, y_vals, x_vals = histogram(pp_vals, bins=get_bins(pp_vals))
-                line.set_data(x_vals[:-1], y_vals)
-                return (line,)
-
-    elif kind == "cumulative":
-        x_vals, y_vals = _empirical_cdf(pp_sampled_vals[0])
-        (line,) = ax.plot(
-            x_vals, y_vals, alpha=alpha, color=color, drawstyle=drawstyle, linewidth=linewidth
-        )
-
-        def animate(i):
-            x_vals, y_vals = _empirical_cdf(pp_sampled_vals[i])
-            line.set_data(x_vals, y_vals)
-            return (line,)
-
-    elif kind == "scatter":
-        x_vals = pp_sampled_vals[0]
-        y_vals = np.full_like(x_vals, height, dtype=np.float64)
-        (line,) = ax.plot(
-            x_vals, y_vals, "o", zorder=2, color=color, markersize=markersize, alpha=alpha
-        )
-
-        def animate(i):
-            line.set_xdata(np.ravel(pp_sampled_vals[i]))
-            return (line,)
-
-    def init():
-        if kind != "scatter":
-            line.set_data([], [])
-        else:
-            line.set_xdata([])
-        return (line,)
-
-    return animate, init
-
-
-def _empirical_cdf(data):
-    """Compute empirical cdf of a numpy array.
-
-    Parameters
-    ----------
-    data : np.array
-        1d array
-
-    Returns
-    -------
-    np.array, np.array
-        x and y coordinates for the empirical cdf of the data
-    """
-    return np.sort(data), np.linspace(0, 1, len(data))

arviz/plots/backends/matplotlib/rankplot.py

@@ -1,119 +0,0 @@
-"""Matplotlib rankplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ....stats.density_utils import histogram
-from ...plot_utils import _scale_fig_size, compute_ranks
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-
-def plot_rank(
-    axes,
-    length_plotters,
-    rows,
-    cols,
-    figsize,
-    plotters,
-    bins,
-    kind,
-    colors,
-    ref_line,
-    labels,
-    labeller,
-    ref_line_kwargs,
-    bar_kwargs,
-    vlines_kwargs,
-    marker_vlines_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib rankplot.."""
-    if ref_line_kwargs is None:
-        ref_line_kwargs = {}
-    ref_line_kwargs.setdefault("linestyle", "--")
-    ref_line_kwargs.setdefault("color", "k")
-
-    if bar_kwargs is None:
-        bar_kwargs = {}
-    bar_kwargs.setdefault("align", "center")
-
-    if vlines_kwargs is None:
-        vlines_kwargs = {}
-    vlines_kwargs.setdefault("lw", 2)
-
-    if marker_vlines_kwargs is None:
-        marker_vlines_kwargs = {}
-        marker_vlines_kwargs.setdefault("marker", "o")
-        marker_vlines_kwargs.setdefault("lw", 0)
-
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, ax_labelsize, titlesize, _, _, _ = _scale_fig_size(figsize, None, rows=rows, cols=cols)
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", True)
-    if axes is None:
-        _, axes = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            backend_kwargs=backend_kwargs,
-        )
-
-    for ax, (var_name, selection, isel, var_data) in zip(np.ravel(axes), plotters):
-        ranks = compute_ranks(var_data)
-        bin_ary = np.histogram_bin_edges(ranks, bins=bins, range=(0, ranks.size))
-        all_counts = np.empty((len(ranks), len(bin_ary) - 1))
-        for idx, row in enumerate(ranks):
-            _, all_counts[idx], _ = histogram(row, bins=bin_ary)
-        gap = 2 / ranks.size
-        width = bin_ary[1] - bin_ary[0]
-
-        bar_kwargs.setdefault("width", width)
-        bar_kwargs.setdefault("edgecolor", ax.get_facecolor())
-        # Center the bins
-        bin_ary = (bin_ary[1:] + bin_ary[:-1]) / 2
-
-        y_ticks = []
-        if kind == "bars":
-            for idx, counts in enumerate(all_counts):
-                y_ticks.append(idx * gap)
-                ax.bar(
-                    bin_ary,
-                    counts,
-                    bottom=y_ticks[-1],
-                    color=colors[idx],
-                    **bar_kwargs,
-                )
-                if ref_line:
-                    ax.axhline(y=y_ticks[-1] + counts.mean(), **ref_line_kwargs)
-            if labels:
-                ax.set_ylabel("Chain", fontsize=ax_labelsize)
-        elif kind == "vlines":
-            ymin = all_counts.mean()
-
-            for idx, counts in enumerate(all_counts):
-                ax.plot(bin_ary, counts, color=colors[idx], **marker_vlines_kwargs)
-                ax.vlines(bin_ary, ymin, counts, colors=colors[idx], **vlines_kwargs)
-            ax.set_ylim(0, all_counts.mean() * 2)
-            if ref_line:
-                ax.axhline(y=ymin, **ref_line_kwargs)
-
-        if labels:
-            ax.set_xlabel("Rank (all chains)", fontsize=ax_labelsize)
-            ax.set_yticks(y_ticks)
-            ax.set_yticklabels(np.arange(len(y_ticks)))
-            ax.set_title(labeller.make_label_vert(var_name, selection, isel), fontsize=titlesize)
-        else:
-            ax.set_yticks([])
-
-    if backend_show(show):
-        plt.show()
-
-    return axes

arviz/plots/backends/matplotlib/separationplot.py

@@ -1,97 +0,0 @@
-"""Matplotlib separation plot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid
-
-
-def plot_separation(
-    y,
-    y_hat,
-    y_hat_line,
-    label_y_hat,
-    expected_events,
-    figsize,
-    textsize,
-    color,
-    legend,
-    locs,
-    width,
-    ax,
-    plot_kwargs,
-    y_hat_line_kwargs,
-    exp_events_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib separation plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-
-    # plot_kwargs.setdefault("color", "C0")
-    # if color:
-    plot_kwargs["color"] = color
-
-    if y_hat_line_kwargs is None:
-        y_hat_line_kwargs = {}
-
-    y_hat_line_kwargs.setdefault("color", "k")
-
-    if exp_events_kwargs is None:
-        exp_events_kwargs = {}
-
-    exp_events_kwargs.setdefault("color", "k")
-    exp_events_kwargs.setdefault("marker", "^")
-    exp_events_kwargs.setdefault("s", 100)
-    exp_events_kwargs.setdefault("zorder", 2)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, *_) = _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)
-
-    idx = np.argsort(y_hat)
-
-    for i, loc in enumerate(locs):
-        positive = not y[idx][i] == 0
-        alpha = 1 if positive else 0.3
-        ax.bar(loc, 1, width=width, alpha=alpha, **plot_kwargs)
-
-    if y_hat_line:
-        ax.plot(np.linspace(0, 1, len(y_hat)), y_hat[idx], label=label_y_hat, **y_hat_line_kwargs)
-
-    if expected_events:
-        expected_events = int(np.round(np.sum(y_hat)))
-        ax.scatter(
-            y_hat[idx][len(y_hat) - expected_events - 1],
-            0,
-            label="Expected events",
-            **exp_events_kwargs
-        )
-
-    if legend and (expected_events or y_hat_line):
-        handles, labels = ax.get_legend_handles_labels()
-        labels_dict = dict(zip(labels, handles))
-        ax.legend(labels_dict.values(), labels_dict.keys())
-
-    ax.set_xticks([])
-    ax.set_yticks([])
-    ax.set_xlim(0, 1)
-    ax.set_ylim(0, 1)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax