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

arviz/plots/backends/bokeh/loopitplot.py

@@ -1,211 +0,0 @@
-"""Bokeh loopitplot."""
-
-import numpy as np
-from bokeh.models import BoxAnnotation
-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 show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-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,  # pylint: disable=unused-argument
-    y_hat,
-    y,
-    color,
-    textsize,
-    labeller,
-    hdi_prob,
-    plot_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Bokeh loo pit plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, *_, linewidth, _) = _scale_fig_size(figsize, textsize, 1, 1)
-
-    if ax is None:
-        backend_kwargs.setdefault("x_range", (0, 1))
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    plot_kwargs = {} if plot_kwargs is None else plot_kwargs
-    plot_kwargs.setdefault("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(xlabel)
-
-    plot_kwargs.setdefault("legend_label", label)
-
-    plot_unif_kwargs = {} if plot_unif_kwargs is None else plot_unif_kwargs
-    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("legend_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)
-
-    if ecdf:
-        if plot_kwargs.get("drawstyle") == "steps-mid":
-            ax.step(
-                np.hstack((0, loo_pit, 1)),
-                np.hstack((0, loo_pit - loo_pit_ecdf, 0)),
-                line_color=plot_kwargs.get("color", "black"),
-                line_alpha=plot_kwargs.get("alpha", 1.0),
-                line_width=plot_kwargs.get("linewidth", 3.0),
-                mode="center",
-            )
-        else:
-            ax.line(
-                np.hstack((0, loo_pit, 1)),
-                np.hstack((0, loo_pit - loo_pit_ecdf, 0)),
-                line_color=plot_kwargs.get("color", "black"),
-                line_alpha=plot_kwargs.get("alpha", 1.0),
-                line_width=plot_kwargs.get("linewidth", 3.0),
-            )
-
-        if ecdf_fill:
-            if (
-                fill_kwargs.get("drawstyle") == "steps-mid"
-                or fill_kwargs.get("drawstyle") != "steps-mid"
-            ):
-                # use step patch when you find out how to do that
-                ax.patch(
-                    np.concatenate((unif_ecdf, unif_ecdf[::-1])),
-                    np.concatenate((p975 - unif_ecdf, (p025 - unif_ecdf)[::-1])),
-                    fill_color=fill_kwargs.get("color"),
-                    fill_alpha=fill_kwargs.get("alpha", 1.0),
-                )
-        elif fill_kwargs is not None and fill_kwargs.get("drawstyle") == "steps-mid":
-            ax.step(
-                unif_ecdf,
-                p975 - unif_ecdf,
-                line_color=plot_unif_kwargs.get("color", "black"),
-                line_alpha=plot_unif_kwargs.get("alpha", 1.0),
-                line_width=plot_kwargs.get("linewidth", 1.0),
-                mode="center",
-            )
-            ax.step(
-                unif_ecdf,
-                p025 - unif_ecdf,
-                line_color=plot_unif_kwargs.get("color", "black"),
-                line_alpha=plot_unif_kwargs.get("alpha", 1.0),
-                line_width=plot_unif_kwargs.get("linewidth", 1.0),
-                mode="center",
-            )
-        else:
-            ax.line(
-                unif_ecdf,
-                p975 - unif_ecdf,
-                line_color=plot_unif_kwargs.get("color", "black"),
-                line_alpha=plot_unif_kwargs.get("alpha", 1.0),
-                line_width=plot_unif_kwargs.get("linewidth", 1.0),
-            )
-            ax.line(
-                unif_ecdf,
-                p025 - unif_ecdf,
-                line_color=plot_unif_kwargs.get("color", "black"),
-                line_alpha=plot_unif_kwargs.get("alpha", 1.0),
-                line_width=plot_unif_kwargs.get("linewidth", 1.0),
-            )
-    else:
-        if use_hdi:
-            patch = BoxAnnotation(
-                bottom=hdi_odds[1],
-                top=hdi_odds[0],
-                fill_alpha=hdi_kwargs.pop("alpha"),
-                fill_color=hdi_kwargs.pop("color"),
-                **hdi_kwargs,
-            )
-            patch.level = "underlay"
-            ax.add_layout(patch)
-
-            # Adds horizontal reference line
-            ax.line([0, 1], [1, 1], line_color="white", line_width=1.5)
-        else:
-            for idx in range(n_unif):
-                x_s, unif_density = kde(unif[idx, :])
-                ax.line(
-                    x_s,
-                    unif_density,
-                    line_color=plot_unif_kwargs.get("color", "black"),
-                    line_alpha=plot_unif_kwargs.get("alpha", 0.1),
-                    line_width=plot_unif_kwargs.get("linewidth", 1.0),
-                )
-        ax.line(
-            x_vals,
-            loo_pit_kde,
-            line_color=plot_kwargs.get("color", "black"),
-            line_alpha=plot_kwargs.get("alpha", 1.0),
-            line_width=plot_kwargs.get("linewidth", 3.0),
-        )
-
-    # Sets xlim(0, 1)
-    ax.xaxis.axis_label = xlabel
-    ax.line(0, 0)
-    ax.line(1, 0)
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/mcseplot.py

@@ -1,184 +0,0 @@
-"""Bokeh mcseplot."""
-
-import numpy as np
-from bokeh.models import ColumnDataSource, Span
-from bokeh.models.glyphs import Scatter
-from bokeh.models.annotations import Title
-from scipy.stats import rankdata
-
-from ....stats.stats_utils import quantile as _quantile
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_mcse(
-    ax,
-    plotters,
-    length_plotters,
-    rows,
-    cols,
-    figsize,
-    errorbar,
-    rug,
-    data,
-    probs,
-    kwargs,  # pylint: disable=unused-argument
-    extra_methods,
-    mean_mcse,
-    sd_mcse,
-    textsize,
-    labeller,
-    text_kwargs,  # pylint: disable=unused-argument
-    rug_kwargs,
-    extra_kwargs,
-    idata,
-    rug_kind,
-    backend_kwargs,
-    show,
-):
-    """Bokeh mcse plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, *_, _linewidth, _markersize) = _scale_fig_size(figsize, textsize, rows, cols)
-
-    extra_kwargs = {} if extra_kwargs is None else extra_kwargs
-    extra_kwargs.setdefault("linewidth", _linewidth / 2)
-    extra_kwargs.setdefault("color", "black")
-    extra_kwargs.setdefault("alpha", 0.5)
-
-    if ax is None:
-        ax = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            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)
-    ):
-        if errorbar or rug:
-            values = data[var_name].sel(**selection).values.flatten()
-        if errorbar:
-            quantile_values = _quantile(values, probs)
-            ax_.scatter(probs, quantile_values, marker="dash")
-            ax_.multi_line(
-                list(zip(probs, probs)),
-                [(quant - err, quant + err) for quant, err in zip(quantile_values, x)],
-            )
-        else:
-            ax_.scatter(probs, x, marker="circle")
-            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()
-                hline_mean = Span(
-                    location=mean_mcse_i,
-                    dimension="width",
-                    line_color=extra_kwargs["color"],
-                    line_width=extra_kwargs["linewidth"] * 2,
-                    line_alpha=extra_kwargs["alpha"],
-                )
-
-                ax_.renderers.append(hline_mean)
-
-                hline_sd = Span(
-                    location=sd_mcse_i,
-                    dimension="width",
-                    line_color="black",
-                    line_width=extra_kwargs["linewidth"],
-                    line_alpha=extra_kwargs["alpha"],
-                )
-
-                ax_.renderers.append(hline_sd)
-
-        if rug:
-            if rug_kwargs is None:
-                rug_kwargs = {}
-            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("space", 0.1)
-
-            _rug_kwargs = {}
-            _rug_kwargs.setdefault("size", 8)
-            _rug_kwargs.setdefault("line_color", rug_kwargs.get("line_color", "black"))
-            _rug_kwargs.setdefault("line_width", 1)
-            _rug_kwargs.setdefault("line_alpha", 0.35)
-            _rug_kwargs.setdefault("angle", np.pi / 2)
-
-            mask = idata.sample_stats[rug_kind].values.flatten()
-            values = rankdata(values, method="average")[mask]
-            if errorbar:
-                rug_x, rug_y = (
-                    values / (len(mask) - 1),
-                    np.full_like(
-                        values,
-                        min(
-                            0,
-                            min(quantile_values)
-                            - (max(quantile_values) - min(quantile_values)) * 0.05,
-                        ),
-                    ),
-                )
-
-                hline = Span(
-                    location=min(
-                        0,
-                        min(quantile_values) - (max(quantile_values) - min(quantile_values)) * 0.05,
-                    ),
-                    dimension="width",
-                    line_color="black",
-                    line_width=_linewidth,
-                    line_alpha=0.7,
-                )
-
-            else:
-                rug_x, rug_y = (
-                    values / (len(mask) - 1),
-                    np.full_like(
-                        values,
-                        0,
-                    ),
-                )
-
-                hline = Span(
-                    location=0,
-                    dimension="width",
-                    line_color="black",
-                    line_width=_linewidth,
-                    line_alpha=0.7,
-                )
-
-            ax_.renderers.append(hline)
-
-            glyph = Scatter(x="rug_x", y="rug_y", marker="dash", **_rug_kwargs)
-            cds_rug = ColumnDataSource({"rug_x": np.asarray(rug_x), "rug_y": np.asarray(rug_y)})
-            ax_.add_glyph(cds_rug, glyph)
-
-        title = Title()
-        title.text = labeller.make_label_vert(var_name, selection, isel)
-        ax_.title = title
-
-        ax_.xaxis.axis_label = "Quantile"
-        ax_.yaxis.axis_label = (
-            r"Value $\pm$ MCSE for quantiles" if errorbar else "MCSE for quantiles"
-        )
-
-        if not errorbar:
-            ax_.y_range._property_values["start"] = -0.05  # pylint: disable=protected-access
-            ax_.y_range._property_values["end"] = 1  # pylint: disable=protected-access
-
-    show_layout(ax, show)
-
-    return ax