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

arviz/plots/backends/bokeh/rankplot.py

@@ -1,149 +0,0 @@
-"""Bokeh rankplot."""
-
-import numpy as np
-
-from bokeh.models import Span
-from bokeh.models.annotations import Title
-from bokeh.models.tickers import FixedTicker
-
-from ....stats.density_utils import histogram
-from ...plot_utils import _scale_fig_size, compute_ranks
-from .. import show_layout
-from . import backend_kwarg_defaults, 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,
-):
-    """Bokeh rank plot."""
-    if ref_line_kwargs is None:
-        ref_line_kwargs = {}
-    ref_line_kwargs.setdefault("line_dash", "dashed")
-    ref_line_kwargs.setdefault("line_color", "black")
-
-    if bar_kwargs is None:
-        bar_kwargs = {}
-    bar_kwargs.setdefault("line_color", "white")
-
-    if vlines_kwargs is None:
-        vlines_kwargs = {}
-    vlines_kwargs.setdefault("line_width", 2)
-    vlines_kwargs.setdefault("line_dash", "solid")
-
-    if marker_vlines_kwargs is None:
-        marker_vlines_kwargs = {}
-    marker_vlines_kwargs.setdefault("marker", "circle")
-
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(
-            ("dpi", "plot.bokeh.figure.dpi"),
-        ),
-        **backend_kwargs,
-    }
-    figsize, *_ = _scale_fig_size(figsize, None, rows=rows, cols=cols)
-    if axes is None:
-        axes = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            figsize=figsize,
-            sharex=True,
-            sharey=True,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        axes = np.atleast_2d(axes)
-
-    for ax, (var_name, selection, isel, var_data) in zip(
-        (item for item in axes.flatten() if item is not None), 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)
-        counts_normalizer = all_counts.max() / 0.95
-        gap = 1
-        width = bin_ary[1] - bin_ary[0]
-
-        bar_kwargs.setdefault("width", width)
-        # Center the bins
-        bin_ary = (bin_ary[1:] + bin_ary[:-1]) / 2
-
-        y_ticks = []
-        if kind == "bars":
-            for idx, counts in enumerate(all_counts):
-                counts = counts / counts_normalizer
-                y_ticks.append(idx * gap)
-                ax.vbar(
-                    x=bin_ary,
-                    top=y_ticks[-1] + counts,
-                    bottom=y_ticks[-1],
-                    fill_color=colors[idx],
-                    **bar_kwargs,
-                )
-                if ref_line:
-                    hline = Span(location=y_ticks[-1] + counts.mean(), **ref_line_kwargs)
-                    ax.add_layout(hline)
-            if labels:
-                ax.yaxis.axis_label = "Chain"
-        elif kind == "vlines":
-            ymin = np.full(len(all_counts), all_counts.mean())
-            for idx, counts in enumerate(all_counts):
-                ax.scatter(
-                    bin_ary,
-                    counts,
-                    fill_color=colors[idx],
-                    line_color=colors[idx],
-                    **marker_vlines_kwargs,
-                )
-                x_locations = [(bin, bin) for bin in bin_ary]
-                y_locations = [(ymin[idx], counts_) for counts_ in counts]
-                ax.multi_line(x_locations, y_locations, line_color=colors[idx], **vlines_kwargs)
-
-            if ref_line:
-                hline = Span(location=all_counts.mean(), **ref_line_kwargs)
-                ax.add_layout(hline)
-
-        if labels:
-            ax.xaxis.axis_label = "Rank (all chains)"
-
-            ax.yaxis.ticker = FixedTicker(ticks=y_ticks)
-            ax.xaxis.major_label_overrides = dict(
-                zip(map(str, y_ticks), map(str, range(len(y_ticks))))
-            )
-
-        else:
-            ax.yaxis.major_tick_line_color = None
-            ax.yaxis.minor_tick_line_color = None
-
-            ax.xaxis.major_label_text_font_size = "0pt"
-            ax.yaxis.major_label_text_font_size = "0pt"
-
-        _title = Title()
-        _title.text = labeller.make_label_vert(var_name, selection, isel)
-        ax.title = _title
-
-    show_layout(axes, show)
-
-    return axes

arviz/plots/backends/bokeh/separationplot.py

@@ -1,107 +0,0 @@
-"""Bokeh separation plot."""
-
-import numpy as np
-
-from ...plot_utils import _scale_fig_size, vectorized_to_hex
-from .. import show_layout
-from . import backend_kwarg_defaults, 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", "#2a2eec")
-    # if color:
-    plot_kwargs["color"] = vectorized_to_hex(color)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if y_hat_line_kwargs is None:
-        y_hat_line_kwargs = {}
-
-    y_hat_line_kwargs.setdefault("color", "black")
-    y_hat_line_kwargs.setdefault("line_width", 2)
-
-    if exp_events_kwargs is None:
-        exp_events_kwargs = {}
-
-    exp_events_kwargs.setdefault("color", "black")
-    exp_events_kwargs.setdefault("size", 15)
-
-    if legend:
-        y_hat_line_kwargs.setdefault("legend_label", label_y_hat)
-        exp_events_kwargs.setdefault(
-            "legend_label",
-            "Expected events",
-        )
-
-    figsize, *_ = _scale_fig_size(figsize, textsize)
-
-    idx = np.argsort(y_hat)
-
-    backend_kwargs["x_range"] = (0, 1)
-    backend_kwargs["y_range"] = (0, 1)
-
-    if ax is None:
-        ax = create_axes_grid(1, figsize=figsize, squeeze=True, backend_kwargs=backend_kwargs)
-
-    for i, loc in enumerate(locs):
-        positive = not y[idx][i] == 0
-        alpha = 1 if positive else 0.3
-        ax.vbar(
-            loc,
-            top=1,
-            width=width,
-            fill_alpha=alpha,
-            line_alpha=alpha,
-            **plot_kwargs,
-        )
-
-    if y_hat_line:
-        ax.line(
-            np.linspace(0, 1, len(y_hat)),
-            y_hat[idx],
-            **y_hat_line_kwargs,
-        )
-
-    if expected_events:
-        expected_events = int(np.round(np.sum(y_hat)))
-        ax.triangle(
-            y_hat[idx][len(y_hat) - expected_events - 1],
-            0,
-            **exp_events_kwargs,
-        )
-
-    ax.axis.visible = False
-    ax.xgrid.grid_line_color = None
-    ax.ygrid.grid_line_color = None
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/traceplot.py

@@ -1,436 +0,0 @@
-"""Bokeh Traceplot."""
-
-import warnings
-from collections.abc import Iterable
-from itertools import cycle
-
-import bokeh.plotting as bkp
-import matplotlib.pyplot as plt
-import numpy as np
-from bokeh.models import ColumnDataSource, DataRange1d, Span
-from bokeh.models.glyphs import Scatter
-from bokeh.models.annotations import Title
-
-from ...distplot import plot_dist
-from ...plot_utils import _scale_fig_size
-from ...rankplot import plot_rank
-from .. import show_layout
-from . import backend_kwarg_defaults, dealiase_sel_kwargs
-from ....sel_utils import xarray_var_iter
-
-
-def plot_trace(
-    data,
-    var_names,
-    divergences,
-    kind,
-    figsize,
-    rug,
-    lines,
-    circ_var_names,  # pylint: disable=unused-argument
-    circ_var_units,  # pylint: disable=unused-argument
-    compact,
-    compact_prop,
-    combined,
-    chain_prop,
-    legend,
-    labeller,
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    hist_kwargs,
-    trace_kwargs,
-    rank_kwargs,
-    plotters,
-    divergence_data,
-    axes,
-    backend_kwargs,
-    backend_config,
-    show,
-):
-    """Bokeh traceplot."""
-    # If divergences are plotted they must be provided
-    if divergences is not False:
-        assert divergence_data is not None
-
-    if backend_config is None:
-        backend_config = {}
-
-    backend_config = {
-        **backend_kwarg_defaults(
-            ("bounds_y_range", "plot.bokeh.bounds_y_range"),
-        ),
-        **backend_config,
-    }
-
-    # Set plot default backend kwargs
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(
-            ("dpi", "plot.bokeh.figure.dpi"),
-        ),
-        **backend_kwargs,
-    }
-    dpi = backend_kwargs.pop("dpi")
-
-    if figsize is None:
-        figsize = (12, len(plotters) * 2)
-
-    figsize, _, _, _, linewidth, _ = _scale_fig_size(figsize, 10, rows=len(plotters), cols=2)
-
-    backend_kwargs.setdefault("height", int(figsize[1] * dpi // len(plotters)))
-    backend_kwargs.setdefault("width", int(figsize[0] * dpi // 2))
-
-    if lines is None:
-        lines = ()
-
-    num_chain_props = len(data.chain) + 1 if combined else len(data.chain)
-    if not compact:
-        chain_prop = (
-            {"line_color": plt.rcParams["axes.prop_cycle"].by_key()["color"]}
-            if chain_prop is None
-            else chain_prop
-        )
-    else:
-        chain_prop = (
-            {
-                "line_dash": ("solid", "dotted", "dashed", "dashdot"),
-            }
-            if chain_prop is None
-            else chain_prop
-        )
-        compact_prop = (
-            {"line_color": plt.rcParams["axes.prop_cycle"].by_key()["color"]}
-            if compact_prop is None
-            else compact_prop
-        )
-
-    if isinstance(chain_prop, str):
-        chain_prop = {chain_prop: plt.rcParams["axes.prop_cycle"].by_key()[chain_prop]}
-    if isinstance(chain_prop, tuple):
-        warnings.warn(
-            "chain_prop as a tuple will be deprecated in a future warning, use a dict instead",
-            FutureWarning,
-        )
-        chain_prop = {chain_prop[0]: chain_prop[1]}
-    chain_prop = {
-        prop_name: [prop for _, prop in zip(range(num_chain_props), cycle(props))]
-        for prop_name, props in chain_prop.items()
-    }
-
-    if isinstance(compact_prop, str):
-        compact_prop = {compact_prop: plt.rcParams["axes.prop_cycle"].by_key()[compact_prop]}
-    if isinstance(compact_prop, tuple):
-        warnings.warn(
-            "compact_prop as a tuple will be deprecated in a future warning, use a dict instead",
-            FutureWarning,
-        )
-        compact_prop = {compact_prop[0]: compact_prop[1]}
-
-    trace_kwargs = {} if trace_kwargs is None else trace_kwargs
-    trace_kwargs.setdefault("alpha", 0.35)
-
-    if hist_kwargs is None:
-        hist_kwargs = {}
-    hist_kwargs.setdefault("alpha", 0.35)
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-    if fill_kwargs is None:
-        fill_kwargs = {}
-    if rug_kwargs is None:
-        rug_kwargs = {}
-    if rank_kwargs is None:
-        rank_kwargs = {}
-
-    trace_kwargs.setdefault("line_width", linewidth)
-    plot_kwargs.setdefault("line_width", linewidth)
-
-    if rank_kwargs is None:
-        rank_kwargs = {}
-
-    if axes is None:
-        axes = []
-        backend_kwargs_copy = backend_kwargs.copy()
-        for i in range(len(plotters)):
-            if not i:
-                _axes = [bkp.figure(**backend_kwargs), bkp.figure(**backend_kwargs_copy)]
-                backend_kwargs_copy.setdefault("x_range", _axes[1].x_range)
-            else:
-                _axes = [
-                    bkp.figure(**backend_kwargs),
-                    bkp.figure(**backend_kwargs_copy),
-                ]
-            axes.append(_axes)
-
-    axes = np.atleast_2d(axes)
-
-    cds_data = {}
-    cds_var_groups = {}
-    draw_name = "draw"
-
-    for var_name, selection, isel, value in list(
-        xarray_var_iter(data, var_names=var_names, combined=True)
-    ):
-        if selection:
-            cds_name = "{}_ARVIZ_CDS_SELECTION_{}".format(
-                var_name,
-                "_".join(
-                    str(item)
-                    for key, value in selection.items()
-                    for item in (
-                        [key, value]
-                        if (isinstance(value, str) or not isinstance(value, Iterable))
-                        else [key, *value]
-                    )
-                ),
-            )
-        else:
-            cds_name = var_name
-
-        if var_name not in cds_var_groups:
-            cds_var_groups[var_name] = []
-        cds_var_groups[var_name].append(cds_name)
-
-        for chain_idx, _ in enumerate(data.chain.values):
-            if chain_idx not in cds_data:
-                cds_data[chain_idx] = {}
-            _data = value[chain_idx]
-            cds_data[chain_idx][cds_name] = _data
-
-    while any(key == draw_name for key in cds_data[0]):
-        draw_name += "w"
-
-    for chain in cds_data.values():
-        chain[draw_name] = data.draw.values
-
-    cds_data = {chain_idx: ColumnDataSource(cds) for chain_idx, cds in cds_data.items()}
-
-    for idx, (var_name, selection, isel, value) in enumerate(plotters):
-        value = np.atleast_2d(value)
-
-        if len(value.shape) == 2:
-            y_name = (
-                var_name
-                if not selection
-                else "{}_ARVIZ_CDS_SELECTION_{}".format(
-                    var_name,
-                    "_".join(
-                        str(item)
-                        for key, value in selection.items()
-                        for item in (
-                            (key, value)
-                            if (isinstance(value, str) or not isinstance(value, Iterable))
-                            else (key, *value)
-                        )
-                    ),
-                )
-            )
-            if rug:
-                rug_kwargs["y"] = y_name
-            _plot_chains_bokeh(
-                ax_density=axes[idx, 0],
-                ax_trace=axes[idx, 1],
-                data=cds_data,
-                x_name=draw_name,
-                y_name=y_name,
-                chain_prop=chain_prop,
-                combined=combined,
-                rug=rug,
-                kind=kind,
-                legend=legend,
-                trace_kwargs=trace_kwargs,
-                hist_kwargs=hist_kwargs,
-                plot_kwargs=plot_kwargs,
-                fill_kwargs=fill_kwargs,
-                rug_kwargs=rug_kwargs,
-                rank_kwargs=rank_kwargs,
-            )
-        else:
-            for y_name in cds_var_groups[var_name]:
-                if rug:
-                    rug_kwargs["y"] = y_name
-                _plot_chains_bokeh(
-                    ax_density=axes[idx, 0],
-                    ax_trace=axes[idx, 1],
-                    data=cds_data,
-                    x_name=draw_name,
-                    y_name=y_name,
-                    chain_prop=chain_prop,
-                    combined=combined,
-                    rug=rug,
-                    kind=kind,
-                    legend=legend,
-                    trace_kwargs=trace_kwargs,
-                    hist_kwargs=hist_kwargs,
-                    plot_kwargs=plot_kwargs,
-                    fill_kwargs=fill_kwargs,
-                    rug_kwargs=rug_kwargs,
-                    rank_kwargs=rank_kwargs,
-                )
-
-        for col in (0, 1):
-            _title = Title()
-            _title.text = labeller.make_label_vert(var_name, selection, isel)
-            axes[idx, col].title = _title
-            axes[idx, col].y_range = DataRange1d(
-                bounds=backend_config["bounds_y_range"], min_interval=0.1
-            )
-
-        for _, _, vlines in (j for j in lines if j[0] == var_name and j[1] == selection):
-            if isinstance(vlines, (float, int)):
-                line_values = [vlines]
-            else:
-                line_values = np.atleast_1d(vlines).ravel()
-
-            for line_value in line_values:
-                vline = Span(
-                    location=line_value,
-                    dimension="height",
-                    line_color="black",
-                    line_width=1.5,
-                    line_alpha=0.75,
-                )
-                hline = Span(
-                    location=line_value,
-                    dimension="width",
-                    line_color="black",
-                    line_width=1.5,
-                    line_alpha=trace_kwargs["alpha"],
-                )
-
-                axes[idx, 0].renderers.append(vline)
-                axes[idx, 1].renderers.append(hline)
-
-        if legend:
-            for col in (0, 1):
-                axes[idx, col].legend.location = "top_left"
-                axes[idx, col].legend.click_policy = "hide"
-        else:
-            for col in (0, 1):
-                if axes[idx, col].legend:
-                    axes[idx, col].legend.visible = False
-
-        if divergences:
-            div_density_kwargs = {}
-            div_density_kwargs.setdefault("size", 14)
-            div_density_kwargs.setdefault("line_color", "red")
-            div_density_kwargs.setdefault("line_width", 2)
-            div_density_kwargs.setdefault("line_alpha", 0.50)
-            div_density_kwargs.setdefault("angle", np.pi / 2)
-
-            div_trace_kwargs = {}
-            div_trace_kwargs.setdefault("size", 14)
-            div_trace_kwargs.setdefault("line_color", "red")
-            div_trace_kwargs.setdefault("line_width", 2)
-            div_trace_kwargs.setdefault("line_alpha", 0.50)
-            div_trace_kwargs.setdefault("angle", np.pi / 2)
-
-            div_selection = {k: v for k, v in selection.items() if k in divergence_data.dims}
-            divs = divergence_data.sel(**div_selection).values
-            divs = np.atleast_2d(divs)
-
-            for chain, chain_divs in enumerate(divs):
-                div_idxs = np.arange(len(chain_divs))[chain_divs]
-                if div_idxs.size > 0:
-                    values = value[chain, div_idxs]
-                    tmp_cds = ColumnDataSource({"y": values, "x": div_idxs})
-                    if divergences == "top":
-                        y_div_trace = value.max()
-                    else:
-                        y_div_trace = value.min()
-                    glyph_density = Scatter(x="y", y=0.0, marker="dash", **div_density_kwargs)
-                    if kind == "trace":
-                        glyph_trace = Scatter(
-                            x="x", y=y_div_trace, marker="dash", **div_trace_kwargs
-                        )
-                        axes[idx, 1].add_glyph(tmp_cds, glyph_trace)
-
-                    axes[idx, 0].add_glyph(tmp_cds, glyph_density)
-
-    show_layout(axes, show)
-
-    return axes
-
-
-def _plot_chains_bokeh(
-    ax_density,
-    ax_trace,
-    data,
-    x_name,
-    y_name,
-    chain_prop,
-    combined,
-    rug,
-    kind,
-    legend,
-    trace_kwargs,
-    hist_kwargs,
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    rank_kwargs,
-):
-    marker = trace_kwargs.pop("marker", True)
-    for chain_idx, cds in data.items():
-        if kind == "trace":
-            if legend:
-                trace_kwargs["legend_label"] = f"chain {chain_idx}"
-            ax_trace.line(
-                x=x_name,
-                y=y_name,
-                source=cds,
-                **dealiase_sel_kwargs(trace_kwargs, chain_prop, chain_idx),
-            )
-            if marker:
-                ax_trace.scatter(
-                    x=x_name,
-                    y=y_name,
-                    marker="circle",
-                    source=cds,
-                    radius=0.30,
-                    alpha=0.5,
-                    **dealiase_sel_kwargs({}, chain_prop, chain_idx),
-                )
-        if not combined:
-            rug_kwargs["cds"] = cds
-            if legend:
-                plot_kwargs["legend_label"] = f"chain {chain_idx}"
-            plot_dist(
-                cds.data[y_name],
-                ax=ax_density,
-                rug=rug,
-                hist_kwargs=hist_kwargs,
-                plot_kwargs=dealiase_sel_kwargs(plot_kwargs, chain_prop, chain_idx),
-                fill_kwargs=fill_kwargs,
-                rug_kwargs=rug_kwargs,
-                backend="bokeh",
-                backend_kwargs={},
-                show=False,
-            )
-
-    if kind == "rank_bars":
-        value = np.array([item.data[y_name] for item in data.values()])
-        plot_rank(value, kind="bars", ax=ax_trace, backend="bokeh", show=False, **rank_kwargs)
-    elif kind == "rank_vlines":
-        value = np.array([item.data[y_name] for item in data.values()])
-        plot_rank(value, kind="vlines", ax=ax_trace, backend="bokeh", show=False, **rank_kwargs)
-
-    if combined:
-        rug_kwargs["cds"] = data
-        if legend:
-            plot_kwargs["legend_label"] = "combined chains"
-        plot_dist(
-            np.concatenate([item.data[y_name] for item in data.values()]).flatten(),
-            ax=ax_density,
-            rug=rug,
-            hist_kwargs=hist_kwargs,
-            plot_kwargs=dealiase_sel_kwargs(plot_kwargs, chain_prop, -1),
-            fill_kwargs=fill_kwargs,
-            rug_kwargs=rug_kwargs,
-            backend="bokeh",
-            backend_kwargs={},
-            show=False,
-        )