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

arviz/plots/backends/bokeh/hdiplot.py

@@ -1,54 +0,0 @@
-"""Bokeh hdiplot."""
-
-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_hdi(ax, x_data, y_data, color, figsize, plot_kwargs, fill_kwargs, backend_kwargs, show):
-    """Bokeh HDI plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    plot_kwargs = {} if plot_kwargs is None else plot_kwargs
-    plot_kwargs["color"] = vectorized_to_hex(plot_kwargs.get("color", color))
-    plot_kwargs.setdefault("alpha", 0)
-
-    fill_kwargs = {} if fill_kwargs is None else fill_kwargs.copy()
-    # Convert matplotlib color to bokeh fill_color if needed
-    if "color" in fill_kwargs and "fill_color" not in fill_kwargs:
-        fill_kwargs["fill_color"] = vectorized_to_hex(fill_kwargs.pop("color"))
-    else:
-        fill_kwargs["fill_color"] = vectorized_to_hex(fill_kwargs.get("fill_color", color))
-    fill_kwargs.setdefault("fill_alpha", fill_kwargs.pop("alpha", 0.5))
-
-    figsize, *_ = _scale_fig_size(figsize, None)
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    plot_kwargs.setdefault("line_color", plot_kwargs.pop("color"))
-    plot_kwargs.setdefault("line_alpha", plot_kwargs.pop("alpha", 0))
-
-    ax.patch(
-        np.concatenate((x_data, x_data[::-1])),
-        np.concatenate((y_data[:, 0], y_data[:, 1][::-1])),
-        **fill_kwargs,
-        **plot_kwargs
-    )
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/kdeplot.py

@@ -1,268 +0,0 @@
-# pylint: disable=c-extension-no-member
-"""Bokeh KDE Plot."""
-from collections.abc import Callable
-from numbers import Integral
-
-import numpy as np
-from bokeh.models import ColumnDataSource
-from bokeh.models.glyphs import Scatter
-from matplotlib import colormaps
-from matplotlib.colors import rgb2hex
-from matplotlib.pyplot import rcParams as mpl_rcParams
-
-from ...plot_utils import _scale_fig_size, _init_kwargs_dict
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_kde(
-    density,
-    lower,
-    upper,
-    density_q,
-    xmin,
-    xmax,
-    ymin,
-    ymax,
-    gridsize,
-    values,
-    values2,
-    rug,
-    label,  # pylint: disable=unused-argument
-    quantiles,
-    rotated,
-    contour,
-    fill_last,
-    figsize,
-    textsize,  # pylint: disable=unused-argument
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    contour_kwargs,
-    contourf_kwargs,
-    pcolormesh_kwargs,
-    is_circular,  # pylint: disable=unused-argument
-    ax,
-    legend,  # pylint: disable=unused-argument
-    backend_kwargs,
-    show,
-    return_glyph,
-):
-    """Bokeh kde plot."""
-    backend_kwargs = _init_kwargs_dict(backend_kwargs)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, *_ = _scale_fig_size(figsize, textsize)
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    glyphs = []
-    if values2 is None:
-        plot_kwargs = _init_kwargs_dict(plot_kwargs)
-        plot_kwargs.setdefault("line_color", mpl_rcParams["axes.prop_cycle"].by_key()["color"][0])
-
-        fill_kwargs = _init_kwargs_dict(fill_kwargs)
-        fill_kwargs.setdefault("fill_color", mpl_rcParams["axes.prop_cycle"].by_key()["color"][0])
-
-        if rug:
-            rug_kwargs = _init_kwargs_dict(rug_kwargs)
-
-            if "cds" in rug_kwargs:
-                cds_rug = rug_kwargs.pop("cds")
-                rug_varname = rug_kwargs.pop("y", "y")
-            else:
-                rug_varname = "y"
-                cds_rug = ColumnDataSource({rug_varname: np.asarray(values)})
-
-            rug_kwargs.setdefault("size", 8)
-            rug_kwargs.setdefault("line_color", plot_kwargs["line_color"])
-            rug_kwargs.setdefault("line_width", 1)
-            rug_kwargs.setdefault("line_alpha", 0.35)
-            if not rotated:
-                rug_kwargs.setdefault("angle", np.pi / 2)
-            if isinstance(cds_rug, dict):
-                for _cds_rug in cds_rug.values():
-                    if not rotated:
-                        glyph = Scatter(x=rug_varname, y=0.0, marker="dash", **rug_kwargs)
-                    else:
-                        glyph = Scatter(x=0.0, y=rug_varname, marker="dash", **rug_kwargs)
-                    ax.add_glyph(_cds_rug, glyph)
-            else:
-                if not rotated:
-                    glyph = Scatter(x=rug_varname, y=0.0, marker="dash", **rug_kwargs)
-                else:
-                    glyph = Scatter(x=0.0, y=rug_varname, marker="dash", **rug_kwargs)
-                ax.add_glyph(cds_rug, glyph)
-            glyphs.append(glyph)
-
-        x = np.linspace(lower, upper, len(density))
-
-        if quantiles is not None:
-            fill_kwargs.setdefault("fill_alpha", 0.75)
-            fill_kwargs.setdefault("line_color", None)
-
-            quantiles = sorted(np.clip(quantiles, 0, 1))
-            if quantiles[0] != 0:
-                quantiles = [0] + quantiles
-            if quantiles[-1] != 1:
-                quantiles = quantiles + [1]
-
-            for quant_0, quant_1 in zip(quantiles[:-1], quantiles[1:]):
-                idx = (density_q > quant_0) & (density_q < quant_1)
-                if idx.sum():
-                    patch_x = np.concatenate((x[idx], [x[idx][-1]], x[idx][::-1], [x[idx][0]]))
-                    patch_y = np.concatenate(
-                        (np.zeros_like(density[idx]), [density[idx][-1]], density[idx][::-1], [0])
-                    )
-                    if not rotated:
-                        patch = ax.patch(patch_x, patch_y, **fill_kwargs)
-                    else:
-                        patch = ax.patch(patch_y, patch_x, **fill_kwargs)
-                    glyphs.append(patch)
-        else:
-            if fill_kwargs.get("fill_alpha", False):
-                patch_x = np.concatenate((x, [x[-1]], x[::-1], [x[0]]))
-                patch_y = np.concatenate(
-                    (np.zeros_like(density), [density[-1]], density[::-1], [0])
-                )
-                if not rotated:
-                    patch = ax.patch(patch_x, patch_y, **fill_kwargs)
-                else:
-                    patch = ax.patch(patch_y, patch_x, **fill_kwargs)
-                glyphs.append(patch)
-
-            if label is not None:
-                plot_kwargs.setdefault("legend_label", label)
-            if not rotated:
-                line = ax.line(x, density, **plot_kwargs)
-            else:
-                line = ax.line(density, x, **plot_kwargs)
-            glyphs.append(line)
-
-    else:
-        try:
-            import contourpy
-        except ImportError as err:
-            raise ImportError(
-                "'bokeh' kde contour plots needs ContourPy installed (pip install countourpy)."
-            ) from err
-
-        contour_kwargs = _init_kwargs_dict(contour_kwargs)
-        contourf_kwargs = _init_kwargs_dict(contourf_kwargs)
-        pcolormesh_kwargs = _init_kwargs_dict(pcolormesh_kwargs)
-
-        g_s = complex(gridsize[0])
-        x_x, y_y = np.mgrid[xmin:xmax:g_s, ymin:ymax:g_s]
-
-        if contour:
-            scaled_density, *scaled_density_args = _scale_axis(density)
-
-            contourpy_kwargs = _init_kwargs_dict(contour_kwargs.pop("contourpy_kwargs", {}))
-            contourpy_kwargs.setdefault("name", "serial")
-            contour_generator = contourpy.contour_generator(
-                x=x_x, y=y_y, z=scaled_density, **contourpy_kwargs
-            )
-
-            levels = 9
-            if "levels" in contourf_kwargs:
-                levels = contourf_kwargs.pop("levels")
-            if "levels" in contour_kwargs:
-                levels = contour_kwargs.pop("levels")
-
-            if isinstance(levels, Integral):
-                levels_scaled = np.linspace(0, 1, levels + 2)
-                levels = _rescale_axis(levels_scaled, scaled_density_args)
-            else:
-                levels_scaled_nonclip, *_ = _scale_axis(np.asarray(levels), scaled_density_args)
-                levels_scaled = np.clip(levels_scaled_nonclip, 0, 1)
-
-            cmap = contourf_kwargs.pop("cmap", "viridis")
-            if isinstance(cmap, str):
-                cmap = colormaps[cmap]
-            if isinstance(cmap, Callable):
-                colors = [rgb2hex(item) for item in cmap(np.linspace(0, 1, len(levels_scaled) + 1))]
-            else:
-                colors = cmap
-
-            contour_kwargs.update(contourf_kwargs)
-            contour_kwargs.setdefault("line_alpha", 0.25)
-            contour_kwargs.setdefault("fill_alpha", 1)
-
-            for i, (level, level_upper, color) in enumerate(
-                zip(levels_scaled[:-1], levels_scaled[1:], colors[1:])
-            ):
-                if not fill_last and (i == 0):
-                    continue
-                contour_kwargs_ = contour_kwargs.copy()
-                contour_kwargs_.setdefault("line_color", color)
-                contour_kwargs_.setdefault("fill_color", color)
-                vertices, _ = contour_generator.filled(level, level_upper)
-                for seg in vertices:
-                    # ax.multi_polygon would be better, but input is
-                    # currently not suitable
-                    # seg is 1 line that defines an area
-                    # multi_polygon would need inner and outer edges
-                    # as a line
-                    patch = ax.patch(*seg.T, **contour_kwargs_)
-                    glyphs.append(patch)
-
-            if fill_last:
-                ax.background_fill_color = colors[0]
-
-            ax.xgrid.grid_line_color = None
-            ax.ygrid.grid_line_color = None
-
-        else:
-            cmap = pcolormesh_kwargs.pop("cmap", "viridis")
-            if isinstance(cmap, str):
-                cmap = colormaps[cmap]
-            if isinstance(cmap, Callable):
-                colors = [rgb2hex(item) for item in cmap(np.linspace(0, 1, 256))]
-            else:
-                colors = cmap
-
-            image = ax.image(
-                image=[density.T],
-                x=xmin,
-                y=ymin,
-                dw=(xmax - xmin) / density.shape[0],
-                dh=(ymax - ymin) / density.shape[1],
-                palette=colors,
-                **pcolormesh_kwargs
-            )
-            glyphs.append(image)
-            ax.x_range.range_padding = ax.y_range.range_padding = 0
-
-    show_layout(ax, show)
-
-    if return_glyph:
-        return ax, glyphs
-
-    return ax
-
-
-def _scale_axis(arr, args=None):
-    if args:
-        amin, amax = args
-    else:
-        amin, amax = arr.min(), arr.max()
-    scaled_arr = arr - amin
-    scaled_arr /= amax - amin
-    return scaled_arr, amin, amax
-
-
-def _rescale_axis(arr, args):
-    amin, amax = args
-    rescaled_arr = arr * (amax - amin)
-    rescaled_arr += amin
-    return rescaled_arr

arviz/plots/backends/bokeh/khatplot.py

@@ -1,163 +0,0 @@
-"""Bokeh pareto shape plot."""
-
-from collections.abc import Iterable
-
-from matplotlib import cm
-import matplotlib.pyplot as plt
-import numpy as np
-from bokeh.models import Span
-from matplotlib.colors import to_rgba_array
-
-from ....stats.density_utils import histogram
-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_khat(
-    hover_label,  # pylint: disable=unused-argument
-    hover_format,  # pylint: disable=unused-argument
-    ax,
-    figsize,
-    xdata,
-    khats,
-    good_k,
-    kwargs,
-    threshold,
-    coord_labels,
-    show_hlines,
-    show_bins,
-    hlines_kwargs,
-    xlabels,  # pylint: disable=unused-argument
-    legend,  # pylint: disable=unused-argument
-    color,
-    dims,
-    textsize,
-    markersize,  # pylint: disable=unused-argument
-    n_data_points,
-    bin_format,
-    backend_kwargs,
-    show,
-):
-    """Bokeh khat plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(
-            ("dpi", "plot.bokeh.figure.dpi"),
-        ),
-        **backend_kwargs,
-    }
-
-    (figsize, *_, line_width, _) = _scale_fig_size(figsize, textsize)
-
-    if hlines_kwargs is None:
-        hlines_kwargs = {}
-
-    if good_k is None:
-        good_k = 0.7
-
-    hlines_kwargs.setdefault("hlines", [0, good_k, 1])
-
-    cmap = None
-    if isinstance(color, str):
-        if color in dims:
-            colors, _ = color_from_dim(khats, color)
-            cmap_name = kwargs.get("cmap", plt.rcParams["image.cmap"])
-            cmap = getattr(cm, cmap_name)
-            rgba_c = cmap(colors)
-        else:
-            legend = False
-            rgba_c = to_rgba_array(np.full(n_data_points, color))
-    else:
-        legend = False
-        try:
-            rgba_c = to_rgba_array(color)
-        except ValueError:
-            cmap_name = kwargs.get("cmap", plt.rcParams["image.cmap"])
-            cmap = getattr(cm, cmap_name)
-            rgba_c = cmap(color)
-
-    khats = khats if isinstance(khats, np.ndarray) else khats.values.flatten()
-    alphas = 0.5 + 0.2 * (khats > good_k) + 0.3 * (khats > 1)
-
-    rgba_c = vectorized_to_hex(rgba_c)
-
-    if ax is None:
-        ax = create_axes_grid(
-            1,
-            figsize=figsize,
-            squeeze=True,
-            backend_kwargs=backend_kwargs,
-        )
-
-    if not isinstance(rgba_c, str) and isinstance(rgba_c, Iterable):
-        for idx, (alpha, rgba_c_) in enumerate(zip(alphas, rgba_c)):
-            ax.scatter(
-                xdata[idx],
-                khats[idx],
-                marker="cross",
-                line_color=rgba_c_,
-                fill_color=rgba_c_,
-                line_alpha=alpha,
-                fill_alpha=alpha,
-                size=10,
-            )
-    else:
-        ax.scatter(
-            xdata,
-            khats,
-            marker="cross",
-            line_color=rgba_c,
-            fill_color=rgba_c,
-            size=10,
-            line_alpha=alphas,
-            fill_alpha=alphas,
-        )
-
-    if threshold is not None:
-        idxs = xdata[khats > threshold]
-        for idx in idxs:
-            ax.text(x=[idx], y=[khats[idx]], text=[coord_labels[idx]])
-
-    if show_hlines:
-        for hline in hlines_kwargs.pop("hlines"):
-            _hline = Span(
-                location=hline,
-                dimension="width",
-                line_color="grey",
-                line_width=line_width,
-                line_dash="dashed",
-            )
-            ax.renderers.append(_hline)
-
-    ymin = min(khats)
-    ymax = max(khats)
-    xmax = len(khats)
-
-    if show_bins:
-        bin_edges = np.array([ymin, good_k, 1, ymax])
-        bin_edges = bin_edges[(bin_edges >= ymin) & (bin_edges <= ymax)]
-        hist, _, _ = histogram(khats, bin_edges)
-        for idx, count in enumerate(hist):
-            ax.text(
-                x=[(n_data_points - 1 + xmax) / 2],
-                y=[np.mean(bin_edges[idx : idx + 2])],
-                text=[bin_format.format(count, count / n_data_points * 100)],
-            )
-        ax.x_range._property_values["end"] = xmax + 1  # pylint: disable=protected-access
-
-    ax.xaxis.axis_label = "Data Point"
-    ax.yaxis.axis_label = "Shape parameter k"
-
-    if ymin > 0:
-        ax.y_range._property_values["start"] = -0.02  # pylint: disable=protected-access
-    if ymax < 1:
-        ax.y_range._property_values["end"] = 1.02  # pylint: disable=protected-access
-    elif ymax > 1 & threshold:
-        ax.y_range._property_values["end"] = 1.1 * ymax  # pylint: disable=protected-access
-
-    show_layout(ax, show)
-
-    return ax

arviz/plots/backends/bokeh/lmplot.py

@@ -1,185 +0,0 @@
-"""Bokeh linear regression plot."""
-
-import numpy as np
-from bokeh.models.annotations import Legend
-
-from ...hdiplot import plot_hdi
-
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_lm(
-    x,
-    y,
-    y_model,
-    y_hat,
-    num_samples,
-    kind_pp,
-    kind_model,
-    length_plotters,
-    xjitter,
-    rows,
-    cols,
-    y_kwargs,
-    y_hat_plot_kwargs,
-    y_hat_fill_kwargs,
-    y_model_plot_kwargs,
-    y_model_fill_kwargs,
-    y_model_mean_kwargs,
-    backend_kwargs,
-    show,
-    figsize,
-    textsize,
-    axes,
-    legend,
-    grid,  # pylint: disable=unused-argument
-):
-    """Bokeh linreg plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, *_ = _scale_fig_size(figsize, textsize, rows, cols)
-    if axes is None:
-        axes = create_axes_grid(length_plotters, rows, cols, backend_kwargs=backend_kwargs)
-
-    if y_kwargs is None:
-        y_kwargs = {}
-    else:
-        y_kwargs = y_kwargs.copy()
-    y_kwargs.setdefault("marker", "circle")
-    y_kwargs.setdefault("fill_color", "red")
-    y_kwargs.setdefault("line_width", 0)
-    y_kwargs.setdefault("size", 3)
-
-    if y_hat_plot_kwargs is None:
-        y_hat_plot_kwargs = {}
-    else:
-        y_hat_plot_kwargs = y_hat_plot_kwargs.copy()
-    y_hat_plot_kwargs.setdefault("marker", "circle")
-    y_hat_plot_kwargs.setdefault("fill_color", "orange")
-    y_hat_plot_kwargs.setdefault("line_width", 0)
-
-    if y_hat_fill_kwargs is None:
-        y_hat_fill_kwargs = {}
-    else:
-        y_hat_fill_kwargs = y_hat_fill_kwargs.copy()
-    # Convert matplotlib color to bokeh fill_color if needed
-    if "color" in y_hat_fill_kwargs and "fill_color" not in y_hat_fill_kwargs:
-        y_hat_fill_kwargs["fill_color"] = y_hat_fill_kwargs.pop("color")
-    y_hat_fill_kwargs.setdefault("fill_color", "orange")
-    y_hat_fill_kwargs.setdefault("fill_alpha", 0.5)
-
-    if y_model_plot_kwargs is None:
-        y_model_plot_kwargs = {}
-    y_model_plot_kwargs.setdefault("line_color", "black")
-    y_model_plot_kwargs.setdefault("line_alpha", 0.5)
-    y_model_plot_kwargs.setdefault("line_width", 0.5)
-
-    if y_model_fill_kwargs is None:
-        y_model_fill_kwargs = {}
-    else:
-        y_model_fill_kwargs = y_model_fill_kwargs.copy()
-    # Convert matplotlib color to bokeh fill_color if needed
-    if "color" in y_model_fill_kwargs and "fill_color" not in y_model_fill_kwargs:
-        y_model_fill_kwargs["fill_color"] = y_model_fill_kwargs.pop("color")
-    y_model_fill_kwargs.setdefault("fill_color", "black")
-    y_model_fill_kwargs.setdefault("fill_alpha", 0.5)
-
-    if y_model_mean_kwargs is None:
-        y_model_mean_kwargs = {}
-    y_model_mean_kwargs.setdefault("line_color", "yellow")
-    y_model_mean_kwargs.setdefault("line_width", 2)
-
-    for i, ax_i in enumerate((item for item in axes.flatten() if item is not None)):
-        _, _, _, y_plotters = y[i]
-        _, _, _, x_plotters = x[i]
-        legend_it = []
-        observed_legend = ax_i.scatter(x_plotters, y_plotters, **y_kwargs)
-        legend_it.append(("Observed", [observed_legend]))
-
-        if y_hat is not None:
-            _, _, _, y_hat_plotters = y_hat[i]
-            if kind_pp == "samples":
-                posterior_legend = []
-                for j in range(num_samples):
-                    if xjitter is True:
-                        jitter_scale = x_plotters[1] - x_plotters[0]
-                        scale_high = jitter_scale * 0.2
-                        x_plotters_jitter = x_plotters + np.random.uniform(
-                            low=-scale_high, high=scale_high, size=len(x_plotters)
-                        )
-                        posterior_circle = ax_i.scatter(
-                            x_plotters_jitter,
-                            y_hat_plotters[..., j],
-                            alpha=0.2,
-                            **y_hat_plot_kwargs,
-                        )
-                    else:
-                        posterior_circle = ax_i.scatter(
-                            x_plotters, y_hat_plotters[..., j], alpha=0.2, **y_hat_plot_kwargs
-                        )
-                    posterior_legend.append(posterior_circle)
-                legend_it.append(("Posterior predictive samples", posterior_legend))
-
-            else:
-                plot_hdi(
-                    x_plotters,
-                    y_hat_plotters,
-                    ax=ax_i,
-                    backend="bokeh",
-                    fill_kwargs=y_hat_fill_kwargs,
-                    show=False,
-                )
-
-        if y_model is not None:
-            _, _, _, y_model_plotters = y_model[i]
-            if kind_model == "lines":
-                model_legend = ax_i.multi_line(
-                    [np.tile(np.array(x_plotters, dtype=object), (num_samples, 1))],
-                    [np.transpose(y_model_plotters)],
-                    **y_model_plot_kwargs,
-                )
-                legend_it.append(("Uncertainty in mean", [model_legend]))
-
-                y_model_mean = np.mean(y_model_plotters, axis=1)
-            else:
-                plot_hdi(
-                    x_plotters,
-                    y_model_plotters,
-                    fill_kwargs=y_model_fill_kwargs,
-                    ax=ax_i,
-                    backend="bokeh",
-                    show=False,
-                )
-
-                y_model_mean = np.mean(y_model_plotters, axis=(0, 1))
-                # Plot mean line across all x values instead of just edges
-                mean_legend = ax_i.line(x_plotters, y_model_mean, **y_model_mean_kwargs)
-                legend_it.append(("Mean", [mean_legend]))
-                continue  # Skip the edge plotting since we plotted full line
-
-            x_plotters_edge = [min(x_plotters), max(x_plotters)]
-            y_model_mean_edge = [min(y_model_mean), max(y_model_mean)]
-            mean_legend = ax_i.line(x_plotters_edge, y_model_mean_edge, **y_model_mean_kwargs)
-            legend_it.append(("Mean", [mean_legend]))
-
-        if legend:
-            legend = Legend(
-                items=legend_it,
-                location="top_left",
-                orientation="vertical",
-            )
-            ax_i.add_layout(legend)
-            if textsize is not None:
-                ax_i.legend.label_text_font_size = f"{textsize}pt"
-            ax_i.legend.click_policy = "hide"
-
-    show_layout(axes, show)
-    return axes