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

arviz/plots/backends/bokeh/dotplot.py

@@ -1,113 +0,0 @@
-"""Bokeh dotplot."""
-
-import math
-import warnings
-import numpy as np
-
-from ...plot_utils import _scale_fig_size, vectorized_to_hex
-from .. import show_layout
-from . import create_axes_grid
-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,
-):
-    """Bokeh dotplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs.setdefault("match_aspect", True)
-
-    (figsize, _, _, _, auto_linewidth, auto_markersize) = _scale_fig_size(figsize, None)
-    dotcolor = vectorized_to_hex(dotcolor)
-    intervalcolor = vectorized_to_hex(intervalcolor)
-    markercolor = vectorized_to_hex(markercolor)
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-    else:
-        plot_kwargs = plot_kwargs.copy()
-    plot_kwargs.setdefault("color", dotcolor)
-    plot_kwargs.setdefault("marker", "circle")
-
-    if linewidth is None:
-        linewidth = auto_linewidth
-
-    if markersize is None:
-        markersize = auto_markersize
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    if point_interval:
-        ax = plot_point_interval(
-            ax,
-            values,
-            point_estimate,
-            hdi_prob,
-            quartiles,
-            linewidth,
-            markersize,
-            markercolor,
-            marker,
-            rotated,
-            intervalcolor,
-            "bokeh",
-        )
-
-    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)
-
-    ax.scatter(x, y, radius=dotsize * (binwidth / 2), **plot_kwargs, radius_dimension="y")
-    if rotated:
-        ax.xaxis.major_tick_line_color = None
-        ax.xaxis.minor_tick_line_color = None
-        ax.xaxis.major_label_text_font_size = "0pt"
-    else:
-        ax.yaxis.major_tick_line_color = None
-        ax.yaxis.minor_tick_line_color = None
-        ax.yaxis.major_label_text_font_size = "0pt"
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/ecdfplot.py

@@ -1,73 +0,0 @@
-"""Bokeh ecdfplot."""
-
-from matplotlib.colors import to_hex
-
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-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,
-):
-    """Bokeh ecdfplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    (figsize, *_) = _scale_fig_size(figsize, None)
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    if plot_kwargs is None:
-        plot_kwargs = {}
-
-    plot_kwargs.setdefault("mode", "after")
-
-    if fill_band:
-        if fill_kwargs is None:
-            fill_kwargs = {}
-        fill_kwargs.setdefault("fill_color", to_hex("C0"))
-        fill_kwargs.setdefault("fill_alpha", 0.2)
-    else:
-        if plot_outline_kwargs is None:
-            plot_outline_kwargs = {}
-        plot_outline_kwargs.setdefault("color", to_hex("C0"))
-        plot_outline_kwargs.setdefault("alpha", 0.2)
-
-    if x_bands is not None:
-        ax.step(x_coord, y_coord, **plot_kwargs)
-
-        if fill_band:
-            ax.varea(x_bands, lower, higher, **fill_kwargs)
-        else:
-            ax.line(x_bands, lower, **plot_outline_kwargs)
-            ax.line(x_bands, higher, **plot_outline_kwargs)
-    else:
-        ax.step(x_coord, y_coord, **plot_kwargs)
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/elpdplot.py

@@ -1,203 +0,0 @@
-"""Bokeh ELPDPlot."""
-
-import warnings
-
-import bokeh.plotting as bkp
-import numpy as np
-from bokeh.models import ColumnDataSource
-from bokeh.models.annotations import Title
-from bokeh.models.glyphs import Scatter
-from ....rcparams import _validate_bokeh_marker, rcParams
-from ...plot_utils import _scale_fig_size, color_from_dim, vectorized_to_hex
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_elpd(
-    ax,
-    models,
-    pointwise_data,
-    numvars,
-    figsize,
-    textsize,
-    plot_kwargs,
-    xlabels,
-    coord_labels,
-    xdata,
-    threshold,
-    legend,  # pylint: disable=unused-argument
-    color,
-    backend_kwargs,
-    show,
-):
-    """Bokeh elpd plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(
-            ("dpi", "plot.bokeh.figure.dpi"),
-        ),
-        **backend_kwargs,
-    }
-
-    plot_kwargs = {} if plot_kwargs is None else plot_kwargs
-    plot_kwargs.setdefault("marker", rcParams["plot.bokeh.marker"])
-    if isinstance(color, str) and color in pointwise_data[0].dims:
-        colors, _ = color_from_dim(pointwise_data[0], color)
-        plot_kwargs.setdefault("color", vectorized_to_hex(colors))
-    plot_kwargs.setdefault("color", vectorized_to_hex(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, _, _, _, _, markersize) = _scale_fig_size(
-            figsize, textsize, numvars - 1, numvars - 1
-        )
-        plot_kwargs.setdefault("s", markersize)
-
-        if ax is None:
-            ax = create_axes_grid(
-                1,
-                figsize=figsize,
-                squeeze=True,
-                backend_kwargs=backend_kwargs,
-            )
-        ydata = pointwise_data[0] - pointwise_data[1]
-        _plot_atomic_elpd(
-            ax, xdata, ydata, *models, threshold, coord_labels, xlabels, True, True, plot_kwargs
-        )
-
-    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, _, _, _, _, markersize) = _scale_fig_size(
-            figsize, textsize, numvars - 2, numvars - 2
-        )
-        plot_kwargs.setdefault("s", markersize)
-
-        if ax is None:
-            dpi = backend_kwargs.pop("dpi")
-            ax = []
-            for row in range(numvars - 1):
-                ax_row = []
-                for col in range(numvars - 1):
-                    if row == 0 and col == 0:
-                        ax_first = bkp.figure(
-                            width=int(figsize[0] / (numvars - 1) * dpi),
-                            height=int(figsize[1] / (numvars - 1) * dpi),
-                            **backend_kwargs,
-                        )
-                        ax_row.append(ax_first)
-                    elif row < col:
-                        ax_row.append(None)
-                    else:
-                        ax_row.append(
-                            bkp.figure(
-                                width=int(figsize[0] / (numvars - 1) * dpi),
-                                height=int(figsize[1] / (numvars - 1) * dpi),
-                                x_range=ax_first.x_range,
-                                y_range=ax_first.y_range,
-                                **backend_kwargs,
-                            )
-                        )
-                ax.append(ax_row)
-            ax = np.array(ax)
-
-        for i in range(0, numvars - 1):
-            var1 = pointwise_data[i]
-
-            for j in range(0, numvars - 1):
-                if j < i:
-                    continue
-
-                var2 = pointwise_data[j + 1]
-                ydata = var1 - var2
-                _plot_atomic_elpd(
-                    ax[j, i],
-                    xdata,
-                    ydata,
-                    models[i],
-                    models[j + 1],
-                    threshold,
-                    coord_labels,
-                    xlabels,
-                    j == numvars - 2,
-                    i == 0,
-                    plot_kwargs,
-                )
-
-    show_layout(ax, show)
-
-    return ax
-
-
-def _plot_atomic_elpd(
-    ax_,
-    xdata,
-    ydata,
-    model1,
-    model2,
-    threshold,
-    coord_labels,
-    xlabels,
-    xlabels_shown,
-    ylabels_shown,
-    plot_kwargs,
-):
-    marker = _validate_bokeh_marker(plot_kwargs.get("marker"))
-    sizes = np.ones(len(xdata)) * plot_kwargs.get("s")
-    glyph = Scatter(
-        x="xdata",
-        y="ydata",
-        size="sizes",
-        line_color=plot_kwargs.get("color", "black"),
-        marker=marker,
-    )
-    source = ColumnDataSource(dict(xdata=xdata, ydata=ydata, sizes=sizes))
-    ax_.add_glyph(source, glyph)
-    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(
-                x=[outlier],
-                y=[ydata[outlier]],
-                text=label,
-                text_color="black",
-            )
-    if ylabels_shown:
-        ax_.yaxis.axis_label = "ELPD difference"
-    else:
-        ax_.yaxis.minor_tick_line_color = None
-        ax_.yaxis.major_label_text_font_size = "0pt"
-
-    if xlabels_shown:
-        if xlabels:
-            ax_.xaxis.ticker = np.arange(0, len(coord_labels))
-            ax_.xaxis.major_label_overrides = {
-                str(key): str(value)
-                for key, value in zip(np.arange(0, len(coord_labels)), list(coord_labels))
-            }
-    else:
-        ax_.xaxis.minor_tick_line_color = None
-        ax_.xaxis.major_label_text_font_size = "0pt"
-    title = Title()
-    title.text = f"{model1} - {model2}"
-    ax_.title = title

arviz/plots/backends/bokeh/energyplot.py

@@ -1,155 +0,0 @@
-"""Bokeh energyplot."""
-
-from itertools import cycle
-
-import numpy as np
-from bokeh.models import Label
-from bokeh.models.annotations import Legend
-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, vectorized_to_hex
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-from .distplot import _histplot_bokeh_op
-
-
-def plot_energy(
-    ax,
-    energy,
-    kind,
-    bfmi,
-    figsize,
-    textsize,
-    fill_alpha,
-    fill_color,
-    fill_kwargs,
-    plot_kwargs,
-    bw,
-    legend,
-    backend_kwargs,
-    show,
-):
-    """Bokeh energy plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi")),
-        **backend_kwargs,
-    }
-    dpi = backend_kwargs.pop("dpi")
-
-    figsize, _, _, _, line_width, _ = _scale_fig_size(figsize, textsize, 1, 1)
-
-    fill_kwargs = {} if fill_kwargs is None else fill_kwargs
-    plot_kwargs = {} if plot_kwargs is None else plot_kwargs
-    plot_kwargs.setdefault("line_width", line_width)
-    if kind == "hist":
-        legend = False
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    _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)),
-    )
-
-    labels = []
-
-    if kind == "kde":
-        for alpha, color, label, value in series:
-            fill_kwargs["fill_alpha"] = alpha
-            fill_kwargs["fill_color"] = vectorized_to_hex(color)
-            plot_kwargs["line_alpha"] = alpha
-            plot_kwargs["line_color"] = vectorized_to_hex(color)
-            _, glyph = plot_kde(
-                value,
-                bw=bw,
-                label=label,
-                fill_kwargs=fill_kwargs,
-                plot_kwargs=plot_kwargs,
-                ax=ax,
-                legend=legend,
-                backend="bokeh",
-                backend_kwargs={},
-                show=False,
-                return_glyph=True,
-            )
-            labels.append(
-                (
-                    label,
-                    glyph,
-                )
-            )
-
-    elif kind == "hist":
-        hist_kwargs = plot_kwargs.copy()
-        hist_kwargs.update(**fill_kwargs)
-
-        for alpha, color, label, value in series:
-            hist_kwargs["fill_alpha"] = alpha
-            hist_kwargs["fill_color"] = vectorized_to_hex(color)
-            hist_kwargs["line_color"] = None
-            hist_kwargs["line_alpha"] = alpha
-            _histplot_bokeh_op(
-                value.flatten(),
-                values2=None,
-                rotated=False,
-                ax=ax,
-                hist_kwargs=hist_kwargs,
-                is_circular=False,
-            )
-
-    else:
-        raise ValueError(f"Plot type {kind} not recognized.")
-
-    if bfmi:
-        for idx, val in enumerate(e_bfmi(energy)):
-            bfmi_info = Label(
-                x=int(figsize[0] * dpi * 0.58),
-                y=int(figsize[1] * dpi * 0.73) - 20 * idx,
-                x_units="screen",
-                y_units="screen",
-                text=f"chain {idx:>2} BFMI = {val:.2f}",
-                border_line_color=None,
-                border_line_alpha=0.0,
-                background_fill_color="white",
-                background_fill_alpha=1.0,
-            )
-
-            ax.add_layout(bfmi_info)
-
-    if legend and label is not None:
-        legend = Legend(
-            items=labels,
-            location="center_right",
-            orientation="horizontal",
-        )
-        ax.add_layout(legend, "above")
-        ax.legend.click_policy = "hide"
-
-    show_layout(ax, show)
-
-    return ax