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

arviz/plots/backends/bokeh/compareplot.py

@@ -1,167 +0,0 @@
-"""Bokeh Compareplot."""
-
-from bokeh.models import Span
-from bokeh.models.annotations import Title, Legend
-
-
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_compare(
-    ax,
-    comp_df,
-    legend,
-    title,
-    figsize,
-    plot_ic_diff,
-    plot_standard_error,
-    insample_dev,
-    yticks_pos,
-    yticks_labels,
-    plot_kwargs,
-    textsize,
-    information_criterion,
-    step,
-    backend_kwargs,
-    show,
-):
-    """Bokeh compareplot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, _, _, _, line_width, _ = _scale_fig_size(figsize, textsize, 1, 1)
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    yticks_pos = list(yticks_pos)
-
-    labels = []
-
-    if plot_ic_diff:
-        ax.yaxis.ticker = yticks_pos[::2]
-        ax.yaxis.major_label_overrides = {
-            dtype(key): value
-            for key, value in zip(yticks_pos, yticks_labels)
-            for dtype in (int, float)
-            if (dtype(key) - key == 0)
-        }
-
-        # create the coordinates for the errorbars
-        err_xs = []
-        err_ys = []
-
-        for x, y, xerr in zip(
-            comp_df[information_criterion].iloc[1:], yticks_pos[1::2], comp_df.dse[1:]
-        ):
-            err_xs.append((x - xerr, x + xerr))
-            err_ys.append((y, y))
-
-        # plot them
-        dif_tri = ax.scatter(
-            comp_df[information_criterion].iloc[1:],
-            yticks_pos[1::2],
-            line_color=plot_kwargs.get("color_dse", "grey"),
-            fill_color=plot_kwargs.get("color_dse", "grey"),
-            line_width=2,
-            size=6,
-            marker="triangle",
-        )
-        dif_line = ax.multi_line(err_xs, err_ys, line_color=plot_kwargs.get("color_dse", "grey"))
-
-        labels.append(("ELPD difference", [dif_tri, dif_line]))
-
-    else:
-        ax.yaxis.ticker = yticks_pos[::2]
-        ax.yaxis.major_label_overrides = dict(zip(yticks_pos[::2], yticks_labels))
-
-    elpd_circ = ax.scatter(
-        comp_df[information_criterion],
-        yticks_pos[::2],
-        line_color=plot_kwargs.get("color_ic", "black"),
-        fill_color=None,
-        line_width=2,
-        size=6,
-        marker="circle",
-    )
-    elpd_label = [elpd_circ]
-
-    if plot_standard_error:
-        # create the coordinates for the errorbars
-        err_xs = []
-        err_ys = []
-
-        for x, y, xerr in zip(comp_df[information_criterion], yticks_pos[::2], comp_df.se):
-            err_xs.append((x - xerr, x + xerr))
-            err_ys.append((y, y))
-
-        # plot them
-        elpd_line = ax.multi_line(err_xs, err_ys, line_color=plot_kwargs.get("color_ic", "black"))
-        elpd_label.append(elpd_line)
-
-    labels.append(("ELPD", elpd_label))
-
-    scale = comp_df["scale"].iloc[0]
-
-    if insample_dev:
-        p_ic = comp_df[f"p_{information_criterion.split('_')[1]}"]
-        if scale == "log":
-            correction = p_ic
-        elif scale == "negative_log":
-            correction = -p_ic
-        elif scale == "deviance":
-            correction = -(2 * p_ic)
-        insample_circ = ax.scatter(
-            comp_df[information_criterion] + correction,
-            yticks_pos[::2],
-            line_color=plot_kwargs.get("color_insample_dev", "black"),
-            fill_color=plot_kwargs.get("color_insample_dev", "black"),
-            line_width=2,
-            size=6,
-            marker="circle",
-        )
-        labels.append(("In-sample ELPD", [insample_circ]))
-
-    vline = Span(
-        location=comp_df[information_criterion].iloc[0],
-        dimension="height",
-        line_color=plot_kwargs.get("color_ls_min_ic", "grey"),
-        line_width=line_width,
-        line_dash=plot_kwargs.get("ls_min_ic", "dashed"),
-    )
-
-    ax.renderers.append(vline)
-
-    if legend:
-        legend = Legend(items=labels, orientation="vertical", location="top_right")
-        ax.add_layout(legend, "above")
-        ax.legend.click_policy = "hide"
-
-    if title:
-        _title = Title()
-        _title.text = f"Model comparison\n{'higher' if scale == 'log' else 'lower'} is better"
-        ax.title = _title
-
-    if scale == "negative_log":
-        scale = "-log"
-
-    ax.xaxis.axis_label = f"{information_criterion} ({scale})"
-    ax.yaxis.axis_label = "ranked models"
-    ax.y_range._property_values["start"] = -1 + step  # pylint: disable=protected-access
-    ax.y_range._property_values["end"] = 0 - step  # pylint: disable=protected-access
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/densityplot.py

@@ -1,239 +0,0 @@
-"""Bokeh Densityplot."""
-
-from collections import defaultdict
-from itertools import cycle
-
-import matplotlib.pyplot as plt
-import numpy as np
-from bokeh.models.annotations import Legend, Title
-
-from ....stats import hdi
-from ....stats.density_utils import get_bins, histogram, kde
-from ...plot_utils import _scale_fig_size, calculate_point_estimate, vectorized_to_hex
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_density(
-    ax,
-    all_labels,
-    to_plot,
-    colors,
-    bw,
-    circular,
-    figsize,
-    length_plotters,
-    rows,
-    cols,
-    textsize,
-    labeller,
-    hdi_prob,
-    point_estimate,
-    hdi_markers,
-    outline,
-    shade,
-    n_data,
-    data_labels,
-    backend_kwargs,
-    show,
-):
-    """Bokeh density plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    if colors == "cycle":
-        colors = [
-            prop
-            for _, prop in zip(
-                range(n_data), cycle(plt.rcParams["axes.prop_cycle"].by_key()["color"])
-            )
-        ]
-    elif isinstance(colors, str):
-        colors = [colors for _ in range(n_data)]
-    colors = vectorized_to_hex(colors)
-
-    (figsize, _, _, _, line_width, markersize) = _scale_fig_size(figsize, textsize, rows, cols)
-
-    if ax is None:
-        ax = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            figsize=figsize,
-            squeeze=False,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        ax = np.atleast_2d(ax)
-
-    axis_map = dict(zip(all_labels, (item for item in ax.flatten() if item is not None)))
-
-    if data_labels is None:
-        data_labels = {}
-
-    legend_items = defaultdict(list)
-    for m_idx, plotters in enumerate(to_plot):
-        for var_name, selection, isel, values in plotters:
-            label = labeller.make_label_vert(var_name, selection, isel)
-
-            data_label = data_labels[m_idx] if data_labels else None
-
-            plotted = _d_helper(
-                values.flatten(),
-                label,
-                colors[m_idx],
-                bw,
-                circular,
-                line_width,
-                markersize,
-                hdi_prob,
-                point_estimate,
-                hdi_markers,
-                outline,
-                shade,
-                axis_map[label],
-            )
-            if data_label is not None:
-                legend_items[axis_map[label]].append((data_label, plotted))
-
-    for ax1, legend in legend_items.items():
-        legend = Legend(
-            items=legend,
-            location="center_right",
-            orientation="horizontal",
-        )
-        ax1.add_layout(legend, "above")
-        ax1.legend.click_policy = "hide"
-
-    show_layout(ax, show)
-
-    return ax
-
-
-def _d_helper(
-    vec,
-    vname,
-    color,
-    bw,
-    circular,
-    line_width,
-    markersize,
-    hdi_prob,
-    point_estimate,
-    hdi_markers,
-    outline,
-    shade,
-    ax,
-):
-    extra = {}
-    plotted = []
-
-    if vec.dtype.kind == "f":
-        if hdi_prob != 1:
-            hdi_ = hdi(vec, hdi_prob, multimodal=False)
-            new_vec = vec[(vec >= hdi_[0]) & (vec <= hdi_[1])]
-        else:
-            new_vec = vec
-
-        x, density = kde(new_vec, circular=circular, bw=bw)
-        density *= hdi_prob
-        xmin, xmax = x[0], x[-1]
-        ymin, ymax = density[0], density[-1]
-
-        if outline:
-            plotted.append(ax.line(x, density, line_color=color, line_width=line_width, **extra))
-            plotted.append(
-                ax.line(
-                    [xmin, xmin],
-                    [-ymin / 100, ymin],
-                    line_color=color,
-                    line_dash="solid",
-                    line_width=line_width,
-                    muted_color=color,
-                    muted_alpha=0.2,
-                )
-            )
-            plotted.append(
-                ax.line(
-                    [xmax, xmax],
-                    [-ymax / 100, ymax],
-                    line_color=color,
-                    line_dash="solid",
-                    line_width=line_width,
-                    muted_color=color,
-                    muted_alpha=0.2,
-                )
-            )
-
-        if shade:
-            plotted.append(
-                ax.patch(
-                    np.r_[x[::-1], x, x[-1:]],
-                    np.r_[np.zeros_like(x), density, [0]],
-                    fill_color=color,
-                    fill_alpha=shade,
-                    muted_color=color,
-                    muted_alpha=0.2,
-                    **extra
-                )
-            )
-
-    else:
-        xmin, xmax = hdi(vec, hdi_prob, multimodal=False)
-        bins = get_bins(vec)
-
-        _, hist, edges = histogram(vec, bins=bins)
-
-        if outline:
-            plotted.append(
-                ax.quad(
-                    top=hist,
-                    bottom=0,
-                    left=edges[:-1],
-                    right=edges[1:],
-                    line_color=color,
-                    fill_color=None,
-                    muted_color=color,
-                    muted_alpha=0.2,
-                    **extra
-                )
-            )
-        else:
-            plotted.append(
-                ax.quad(
-                    top=hist,
-                    bottom=0,
-                    left=edges[:-1],
-                    right=edges[1:],
-                    line_color=color,
-                    fill_color=color,
-                    fill_alpha=shade,
-                    muted_color=color,
-                    muted_alpha=0.2,
-                    **extra
-                )
-            )
-
-    if hdi_markers:
-        plotted.append(ax.diamond(xmin, 0, line_color="black", fill_color=color, size=markersize))
-        plotted.append(ax.diamond(xmax, 0, line_color="black", fill_color=color, size=markersize))
-
-    if point_estimate is not None:
-        est = calculate_point_estimate(point_estimate, vec, bw, circular)
-        plotted.append(
-            ax.scatter(
-                est, 0, marker="circle", fill_color=color, line_color="black", size=markersize
-            )
-        )
-
-    _title = Title()
-    _title.text = vname
-    ax.title = _title
-    ax.title.text_font_size = "13pt"
-
-    return plotted

arviz/plots/backends/bokeh/distcomparisonplot.py

@@ -1,23 +0,0 @@
-"""Bokeh Density Comparison plot."""
-
-
-def plot_dist_comparison(
-    ax,
-    nvars,
-    ngroups,
-    figsize,
-    dc_plotters,
-    legend,
-    groups,
-    textsize,
-    labeller,
-    prior_kwargs,
-    posterior_kwargs,
-    observed_kwargs,
-    backend_kwargs,
-    show,
-):
-    """Bokeh Density Comparison plot."""
-    raise NotImplementedError(
-        "The bokeh backend is still under development. Use matplotlib backend."
-    )

arviz/plots/backends/bokeh/distplot.py

@@ -1,183 +0,0 @@
-"""Bokeh Distplot."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ....stats.density_utils import get_bins, histogram
-from ...kdeplot import plot_kde
-from ...plot_utils import (
-    _scale_fig_size,
-    set_bokeh_circular_ticks_labels,
-    vectorized_to_hex,
-    _init_kwargs_dict,
-)
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_dist(
-    values,
-    values2,
-    color,
-    kind,
-    cumulative,
-    label,
-    rotated,
-    rug,
-    bw,
-    quantiles,
-    contour,
-    fill_last,
-    figsize,
-    textsize,
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    contour_kwargs,
-    contourf_kwargs,
-    pcolormesh_kwargs,
-    hist_kwargs,
-    is_circular,
-    ax,
-    backend_kwargs,
-    show,
-):
-    """Bokeh distplot."""
-    backend_kwargs = _init_kwargs_dict(backend_kwargs)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, *_ = _scale_fig_size(figsize, textsize)
-
-    color = vectorized_to_hex(color)
-
-    hist_kwargs = _init_kwargs_dict(hist_kwargs)
-    if kind == "hist":
-        hist_kwargs.setdefault("cumulative", cumulative)
-        hist_kwargs.setdefault("fill_color", color)
-        hist_kwargs.setdefault("line_color", color)
-        hist_kwargs.setdefault("line_alpha", 0)
-        if label is not None:
-            hist_kwargs.setdefault("legend_label", str(label))
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            polar=is_circular,
-            backend_kwargs=backend_kwargs,
-        )
-
-    if kind == "auto":
-        kind = "hist" if values.dtype.kind == "i" else "kde"
-
-    if kind == "hist":
-        _histplot_bokeh_op(
-            values=values,
-            values2=values2,
-            rotated=rotated,
-            ax=ax,
-            hist_kwargs=hist_kwargs,
-            is_circular=is_circular,
-        )
-    elif kind == "kde":
-        plot_kwargs = _init_kwargs_dict(plot_kwargs)
-        if color is None:
-            color = plt.rcParams["axes.prop_cycle"].by_key()["color"][0]
-        plot_kwargs.setdefault("line_color", color)
-        legend = label is not None
-
-        plot_kde(
-            values,
-            values2,
-            cumulative=cumulative,
-            rug=rug,
-            label=label,
-            bw=bw,
-            is_circular=is_circular,
-            quantiles=quantiles,
-            rotated=rotated,
-            contour=contour,
-            legend=legend,
-            fill_last=fill_last,
-            plot_kwargs=plot_kwargs,
-            fill_kwargs=fill_kwargs,
-            rug_kwargs=rug_kwargs,
-            contour_kwargs=contour_kwargs,
-            contourf_kwargs=contourf_kwargs,
-            pcolormesh_kwargs=pcolormesh_kwargs,
-            ax=ax,
-            backend="bokeh",
-            backend_kwargs={},
-            show=False,
-        )
-    else:
-        raise TypeError(f'Invalid "kind":{kind}. Select from {{"auto","kde","hist"}}')
-
-    show_layout(ax, show)
-
-    return ax
-
-
-def _histplot_bokeh_op(values, values2, rotated, ax, hist_kwargs, is_circular):
-    """Add a histogram for the data to the axes."""
-    if values2 is not None:
-        raise NotImplementedError("Insert hexbin plot here")
-
-    color = hist_kwargs.pop("color", False)
-    if color:
-        hist_kwargs["fill_color"] = color
-        hist_kwargs["line_color"] = color
-
-    bins = hist_kwargs.pop("bins", None)
-    if bins is None:
-        bins = get_bins(values)
-    hist, hist_dens, edges = histogram(np.asarray(values).flatten(), bins=bins)
-    if hist_kwargs.pop("density", True):
-        hist = hist_dens
-    if hist_kwargs.pop("cumulative", False):
-        hist = np.cumsum(hist)
-        hist /= hist[-1]
-    if values.dtype.kind == "i":
-        edges = edges.astype(float) - 0.5
-
-    if is_circular:
-        if is_circular == "degrees":
-            edges = np.deg2rad(edges)
-            labels = ["0°", "45°", "90°", "135°", "180°", "225°", "270°", "315°"]
-        else:
-            labels = [
-                r"0",
-                r"π/4",
-                r"π/2",
-                r"3π/4",
-                r"π",
-                r"5π/4",
-                r"3π/2",
-                r"7π/4",
-            ]
-
-        delta = np.mean(np.diff(edges) / 2)
-
-        ax.annular_wedge(
-            x=0,
-            y=0,
-            inner_radius=0,
-            outer_radius=hist,
-            start_angle=edges[1:] - delta,
-            end_angle=edges[:-1] - delta,
-            direction="clock",
-            **hist_kwargs,
-        )
-
-        ax = set_bokeh_circular_ticks_labels(ax, hist, labels)
-    elif rotated:
-        ax.quad(top=edges[:-1], bottom=edges[1:], left=0, right=hist, **hist_kwargs)
-    else:
-        ax.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], **hist_kwargs)
-
-    return ax