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

arviz/plots/backends/matplotlib/dotplot.py

@@ -1,116 +0,0 @@
-"""Matplotlib dotplot."""
-
-import math
-import warnings
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib import _pylab_helpers
-
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, create_axes_grid, backend_show
-from ...plot_utils import plot_point_interval
-from ...dotplot import wilkinson_algorithm, layout_stacks
-
-
-def plot_dot(
-    values,
-    binwidth,
-    dotsize,
-    stackratio,
-    hdi_prob,
-    quartiles,
-    rotated,
-    dotcolor,
-    intervalcolor,
-    markersize,
-    markercolor,
-    marker,
-    figsize,
-    linewidth,
-    point_estimate,
-    nquantiles,
-    point_interval,
-    ax,
-    show,
-    backend_kwargs,
-    plot_kwargs,
-):
-    """Matplotlib dotplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {**backend_kwarg_defaults(), **backend_kwargs}
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-
-    (figsize, _, _, _, auto_linewidth, auto_markersize) = _scale_fig_size(figsize, None)
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-        plot_kwargs.setdefault("color", dotcolor)
-
-    if linewidth is None:
-        linewidth = auto_linewidth
-
-    if markersize is None:
-        markersize = auto_markersize
-
-    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 point_interval:
-        ax = plot_point_interval(
-            ax,
-            values,
-            point_estimate,
-            hdi_prob,
-            quartiles,
-            linewidth,
-            markersize,
-            markercolor,
-            marker,
-            rotated,
-            intervalcolor,
-            "matplotlib",
-        )
-
-    if nquantiles > values.shape[0]:
-        warnings.warn(
-            "nquantiles must be less than or equal to the number of data points", UserWarning
-        )
-        nquantiles = values.shape[0]
-    else:
-        qlist = np.linspace(1 / (2 * nquantiles), 1 - 1 / (2 * nquantiles), nquantiles)
-        values = np.quantile(values, qlist)
-
-    if binwidth is None:
-        binwidth = math.sqrt((values[-1] - values[0] + 1) ** 2 / (2 * nquantiles * np.pi))
-
-    ## Wilkinson's Algorithm
-    stack_locs, stack_count = wilkinson_algorithm(values, binwidth)
-    x, y = layout_stacks(stack_locs, stack_count, binwidth, stackratio, rotated)
-
-    for x_i, y_i in zip(x, y):
-        dot = plt.Circle((x_i, y_i), dotsize * binwidth / 2, **plot_kwargs)
-        ax.add_patch(dot)
-
-    if rotated:
-        ax.tick_params(bottom=False, labelbottom=False)
-    else:
-        ax.tick_params(left=False, labelleft=False)
-
-    ax.set_aspect("equal", adjustable="datalim")
-    ax.autoscale()
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/ecdfplot.py

@@ -1,70 +0,0 @@
-"""Matplotlib ecdfplot."""
-
-import matplotlib.pyplot as plt
-from matplotlib.colors import to_hex
-
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, create_axes_grid, backend_show
-
-
-def plot_ecdf(
-    x_coord,
-    y_coord,
-    x_bands,
-    lower,
-    higher,
-    plot_kwargs,
-    fill_kwargs,
-    plot_outline_kwargs,
-    figsize,
-    fill_band,
-    ax,
-    show,
-    backend_kwargs,
-):
-    """Matplotlib ecdfplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, _, _, _, _, _) = _scale_fig_size(figsize, None)
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-
-    if ax is None:
-        _, ax = create_axes_grid(1, backend_kwargs=backend_kwargs)
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-
-    plot_kwargs.setdefault("where", "post")
-
-    if fill_band:
-        if fill_kwargs is None:
-            fill_kwargs = {}
-        fill_kwargs.setdefault("step", "post")
-        fill_kwargs.setdefault("color", to_hex("C0"))
-        fill_kwargs.setdefault("alpha", 0.2)
-    else:
-        if plot_outline_kwargs is None:
-            plot_outline_kwargs = {}
-        plot_outline_kwargs.setdefault("where", "post")
-        plot_outline_kwargs.setdefault("color", to_hex("C0"))
-        plot_outline_kwargs.setdefault("alpha", 0.2)
-
-    ax.step(x_coord, y_coord, **plot_kwargs)
-
-    if x_bands is not None:
-        if fill_band:
-            ax.fill_between(x_bands, lower, higher, **fill_kwargs)
-        else:
-            ax.plot(x_bands, lower, x_bands, higher, **plot_outline_kwargs)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/elpdplot.py

@@ -1,189 +0,0 @@
-"""Matplotlib ELPDPlot."""
-
-import warnings
-
-from matplotlib import cm
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.lines import Line2D
-
-from ....rcparams import rcParams
-from ...plot_utils import _scale_fig_size, color_from_dim, set_xticklabels
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_elpd(
-    ax,
-    models,
-    pointwise_data,
-    numvars,
-    figsize,
-    textsize,
-    plot_kwargs,
-    xlabels,
-    coord_labels,
-    xdata,
-    threshold,
-    legend,
-    color,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib elpd plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-    backend_kwargs.setdefault("constrained_layout", not xlabels)
-
-    plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, "scatter")
-
-    markersize = None
-
-    if isinstance(color, str) and color in pointwise_data[0].dims:
-        colors, color_mapping = color_from_dim(pointwise_data[0], color)
-        cmap_name = plot_kwargs.pop("cmap", plt.rcParams["image.cmap"])
-        markersize = plot_kwargs.pop("s", plt.rcParams["lines.markersize"])
-        cmap = getattr(cm, cmap_name)
-        handles = [
-            Line2D([], [], color=cmap(float_color), label=coord, ms=markersize, lw=0, **plot_kwargs)
-            for coord, float_color in color_mapping.items()
-        ]
-        plot_kwargs.setdefault("cmap", cmap_name)
-        plot_kwargs.setdefault("s", markersize**2)
-        plot_kwargs.setdefault("c", colors)
-    else:
-        legend = False
-    plot_kwargs.setdefault("c", color)
-
-    # flatten data (data must be flattened after selecting, labeling and coloring)
-    pointwise_data = [pointwise.values.flatten() for pointwise in pointwise_data]
-
-    if numvars == 2:
-        (figsize, ax_labelsize, titlesize, xt_labelsize, _, markersize) = _scale_fig_size(
-            figsize, textsize, numvars - 1, numvars - 1
-        )
-        plot_kwargs.setdefault("s", markersize**2)
-        backend_kwargs.setdefault("figsize", figsize)
-        backend_kwargs["squeeze"] = True
-        if ax is None:
-            fig, ax = create_axes_grid(
-                1,
-                backend_kwargs=backend_kwargs,
-            )
-        else:
-            fig = ax.get_figure()
-
-        ydata = pointwise_data[0] - pointwise_data[1]
-        ax.scatter(xdata, ydata, **plot_kwargs)
-        if threshold is not None:
-            diff_abs = np.abs(ydata - ydata.mean())
-            bool_ary = diff_abs > threshold * ydata.std()
-            if coord_labels is None:
-                coord_labels = xdata.astype(str)
-            outliers = np.nonzero(bool_ary)[0]
-            for outlier in outliers:
-                label = coord_labels[outlier]
-                ax.text(
-                    outlier,
-                    ydata[outlier],
-                    label,
-                    horizontalalignment="center",
-                    verticalalignment="bottom" if ydata[outlier] > 0 else "top",
-                    fontsize=0.8 * xt_labelsize,
-                )
-
-        ax.set_title("{} - {}".format(*models), fontsize=titlesize, wrap=True)
-        ax.set_ylabel("ELPD difference", fontsize=ax_labelsize, wrap=True)
-        ax.tick_params(labelsize=xt_labelsize)
-        if xlabels:
-            set_xticklabels(ax, coord_labels)
-            fig.autofmt_xdate()
-            fig.tight_layout()
-        if legend:
-            ncols = len(handles) // 6 + 1
-            ax.legend(handles=handles, ncol=ncols, title=color)
-
-    else:
-        max_plots = (
-            numvars**2 if rcParams["plot.max_subplots"] is None else rcParams["plot.max_subplots"]
-        )
-        vars_to_plot = np.sum(np.arange(numvars).cumsum() < max_plots)
-        if vars_to_plot < numvars:
-            warnings.warn(
-                "rcParams['plot.max_subplots'] ({max_plots}) is smaller than the number "
-                "of resulting ELPD pairwise plots with these variables, generating only a "
-                "{side}x{side} grid".format(max_plots=max_plots, side=vars_to_plot),
-                UserWarning,
-            )
-            numvars = vars_to_plot
-
-        (figsize, ax_labelsize, titlesize, xt_labelsize, _, markersize) = _scale_fig_size(
-            figsize, textsize, numvars - 2, numvars - 2
-        )
-        plot_kwargs.setdefault("s", markersize**2)
-
-        if ax is None:
-            fig, ax = plt.subplots(
-                numvars - 1,
-                numvars - 1,
-                figsize=figsize,
-                squeeze=False,
-                constrained_layout=not xlabels,
-                sharey="row",
-                sharex="col",
-            )
-        else:
-            fig = ax.ravel()[0].get_figure()
-
-        for i in range(0, numvars - 1):
-            var1 = pointwise_data[i]
-
-            for j in range(0, numvars - 1):
-                if j < i:
-                    ax[j, i].axis("off")
-                    continue
-
-                var2 = pointwise_data[j + 1]
-                ax[j, i].scatter(xdata, var1 - var2, **plot_kwargs)
-                if threshold is not None:
-                    ydata = var1 - var2
-                    diff_abs = np.abs(ydata - ydata.mean())
-                    bool_ary = diff_abs > threshold * ydata.std()
-                    if coord_labels is None:
-                        coord_labels = xdata.astype(str)
-                    outliers = np.nonzero(bool_ary)[0]
-                    for outlier in outliers:
-                        label = coord_labels[outlier]
-                        ax[j, i].text(
-                            outlier,
-                            ydata[outlier],
-                            label,
-                            horizontalalignment="center",
-                            verticalalignment="bottom" if ydata[outlier] > 0 else "top",
-                            fontsize=0.8 * xt_labelsize,
-                        )
-
-                if i == 0:
-                    ax[j, i].set_ylabel("ELPD difference", fontsize=ax_labelsize, wrap=True)
-
-                ax[j, i].tick_params(labelsize=xt_labelsize)
-                ax[j, i].set_title(f"{models[i]} - {models[j + 1]}", fontsize=titlesize, wrap=True)
-        if xlabels:
-            for i in range(len(ax)):
-                set_xticklabels(ax[-1, i], coord_labels)
-            fig.autofmt_xdate()
-            fig.tight_layout()
-        if legend:
-            ncols = len(handles) // 6 + 1
-            ax[0, 1].legend(
-                handles=handles, ncol=ncols, title=color, bbox_to_anchor=(0, 1), loc="upper left"
-            )
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/energyplot.py

@@ -1,113 +0,0 @@
-"""Matplotlib energyplot."""
-
-from itertools import cycle
-
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.pyplot import rcParams as mpl_rcParams
-
-from ....stats import bfmi as e_bfmi
-from ...kdeplot import plot_kde
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_energy(
-    ax,
-    energy,
-    kind,
-    bfmi,
-    figsize,
-    textsize,
-    fill_alpha,
-    fill_color,
-    fill_kwargs,
-    plot_kwargs,
-    bw,
-    legend,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib energy 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)
-
-    fill_kwargs = matplotlib_kwarg_dealiaser(fill_kwargs, "hexbin")
-    types = "hist" if kind == "hist" else "plot"
-    plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, types)
-
-    _colors = [
-        prop for _, prop in zip(range(10), cycle(mpl_rcParams["axes.prop_cycle"].by_key()["color"]))
-    ]
-    if (fill_color[0].startswith("C") and len(fill_color[0]) == 2) and (
-        fill_color[1].startswith("C") and len(fill_color[1]) == 2
-    ):
-        fill_color = tuple((_colors[int(color[1:]) % 10] for color in fill_color))
-    elif fill_color[0].startswith("C") and len(fill_color[0]) == 2:
-        fill_color = tuple([_colors[int(fill_color[0][1:]) % 10]] + list(fill_color[1:]))
-    elif fill_color[1].startswith("C") and len(fill_color[1]) == 2:
-        fill_color = tuple(list(fill_color[1:]) + [_colors[int(fill_color[0][1:]) % 10]])
-
-    series = zip(
-        fill_alpha,
-        fill_color,
-        ("Marginal Energy", "Energy transition"),
-        (energy - energy.mean(), np.diff(energy)),
-    )
-
-    if kind == "kde":
-        for alpha, color, label, value in series:
-            fill_kwargs["alpha"] = alpha
-            fill_kwargs["color"] = color
-            plot_kwargs.setdefault("color", color)
-            plot_kwargs.setdefault("alpha", 0)
-            plot_kwargs.setdefault("linewidth", linewidth)
-            plot_kde(
-                value,
-                bw=bw,
-                label=label,
-                textsize=xt_labelsize,
-                fill_kwargs=fill_kwargs,
-                plot_kwargs=plot_kwargs,
-                ax=ax,
-                legend=False,
-            )
-    elif kind == "hist":
-        for alpha, color, label, value in series:
-            ax.hist(
-                value.flatten(),
-                bins="auto",
-                density=True,
-                alpha=alpha,
-                label=label,
-                color=color,
-                **plot_kwargs,
-            )
-
-    else:
-        raise ValueError(f"Plot type {kind} not recognized.")
-
-    if bfmi:
-        for idx, val in enumerate(e_bfmi(energy)):
-            ax.plot([], label=f"chain {idx:>2} BFMI = {val:.2f}", alpha=0)
-    if legend:
-        ax.legend()
-
-    ax.set_xticks([])
-    ax.set_yticks([])
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/essplot.py

@@ -1,180 +0,0 @@
-"""Matplotlib energyplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.stats import rankdata
-
-from ...plot_utils import _scale_fig_size
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_ess(
-    ax,
-    plotters,
-    xdata,
-    ess_tail_dataset,
-    mean_ess,
-    sd_ess,
-    idata,
-    data,
-    kind,
-    extra_methods,
-    textsize,
-    rows,
-    cols,
-    figsize,
-    kwargs,
-    extra_kwargs,
-    text_kwargs,
-    n_samples,
-    relative,
-    min_ess,
-    labeller,
-    ylabel,
-    rug,
-    rug_kind,
-    rug_kwargs,
-    hline_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib ess plot."""
-    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")
-    _linestyle = "-" if kind == "evolution" else "none"
-    kwargs.setdefault("linestyle", _linestyle)
-    kwargs.setdefault("linewidth", _linewidth)
-    kwargs.setdefault("markersize", _markersize)
-    kwargs.setdefault("marker", "o")
-    kwargs.setdefault("zorder", 3)
-
-    extra_kwargs = matplotlib_kwarg_dealiaser(extra_kwargs, "plot")
-    if kind == "evolution":
-        extra_kwargs = {
-            **extra_kwargs,
-            **{key: item for key, item in kwargs.items() if key not in extra_kwargs},
-        }
-        kwargs.setdefault("label", "bulk")
-        extra_kwargs.setdefault("label", "tail")
-    else:
-        extra_kwargs.setdefault("linewidth", _linewidth / 2)
-        extra_kwargs.setdefault("color", "k")
-        extra_kwargs.setdefault("alpha", 0.5)
-    kwargs.setdefault("label", kind)
-
-    hline_kwargs = matplotlib_kwarg_dealiaser(hline_kwargs, "plot")
-    hline_kwargs.setdefault("linewidth", _linewidth)
-    hline_kwargs.setdefault("linestyle", "--")
-    hline_kwargs.setdefault("color", "gray")
-    hline_kwargs.setdefault("alpha", 0.7)
-    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(
-            len(plotters),
-            rows,
-            cols,
-            backend_kwargs=backend_kwargs,
-        )
-
-    for (var_name, selection, isel, x), ax_ in zip(plotters, np.ravel(ax)):
-        ax_.plot(xdata, x, **kwargs)
-        if kind == "evolution":
-            ess_tail = ess_tail_dataset[var_name].sel(**selection)
-            ax_.plot(xdata, ess_tail, **extra_kwargs)
-        elif 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))
-
-            values = data[var_name].sel(**selection).values.flatten()
-            mask = idata.sample_stats[rug_kind].values.flatten()
-            values = rankdata(values, method="average")[mask]
-            rug_space = np.max(x) * rug_kwargs.pop("space")
-            rug_x, rug_y = values / (len(mask) - 1), np.zeros_like(values) - rug_space
-            ax_.plot(rug_x, rug_y, **rug_kwargs)
-            ax_.axhline(0, color="k", linewidth=_linewidth, alpha=0.7)
-        if extra_methods:
-            mean_ess_i = mean_ess[var_name].sel(**selection).values.item()
-            sd_ess_i = sd_ess[var_name].sel(**selection).values.item()
-            ax_.axhline(mean_ess_i, **extra_kwargs)
-            ax_.annotate(
-                "mean",
-                (text_x, mean_ess_i),
-                va=(
-                    text_va
-                    if text_va is not None
-                    else "bottom" if mean_ess_i >= sd_ess_i else "top"
-                ),
-                **text_kwargs,
-            )
-            ax_.axhline(sd_ess_i, **extra_kwargs)
-            ax_.annotate(
-                "sd",
-                (text_x, sd_ess_i),
-                va=text_va if text_va is not None else "bottom" if sd_ess_i > mean_ess_i else "top",
-                **text_kwargs,
-            )
-
-        if relative and kind == "evolution":
-            thin_xdata = np.linspace(xdata.min(), xdata.max(), 100)
-            ax_.plot(thin_xdata, min_ess / thin_xdata, **hline_kwargs)
-        else:
-            hline = min_ess / n_samples if relative else min_ess
-            ax_.axhline(hline, **hline_kwargs)
-
-        ax_.set_title(
-            labeller.make_label_vert(var_name, selection, isel), fontsize=titlesize, wrap=True
-        )
-        ax_.tick_params(labelsize=xt_labelsize)
-        ax_.set_xlabel(
-            "Total number of draws" if kind == "evolution" else "Quantile", fontsize=ax_labelsize
-        )
-        ax_.set_ylabel(
-            ylabel.format("Relative ESS" if relative else "ESS"), fontsize=ax_labelsize, wrap=True
-        )
-        if kind == "evolution":
-            ax_.legend(title="Method", fontsize=xt_labelsize, title_fontsize=xt_labelsize)
-        else:
-            ax_.set_xlim(0, 1)
-        if rug:
-            ax_.yaxis.get_major_locator().set_params(nbins="auto", steps=[1, 2, 5, 10])
-            _, ymax = ax_.get_ylim()
-            yticks = ax_.get_yticks().astype(np.int64)
-            yticks = yticks[(yticks >= 0) & (yticks < ymax)]
-            ax_.set_yticks(yticks)
-            ax_.set_yticklabels(yticks)
-        else:
-            ax_.set_ylim(bottom=0)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax