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

arviz/plots/backends/__init__.py

@@ -1,223 +0,0 @@
-# pylint: disable=no-member,invalid-name,redefined-outer-name
-"""ArviZ plotting backends."""
-import re
-
-import numpy as np
-from pandas import DataFrame
-
-from ...rcparams import rcParams
-
-__all__ = [
-    "to_cds",
-    "output_notebook",
-    "output_file",
-    "ColumnDataSource",
-    "create_layout",
-    "show_layout",
-]
-
-
-def to_cds(
-    data,
-    var_names=None,
-    groups=None,
-    dimensions=None,
-    group_info=True,
-    var_name_format=None,
-    index_origin=None,
-):
-    """Transform data to ColumnDataSource (CDS) compatible with Bokeh.
-
-    Uses `_ARVIZ_GROUP_` and `_ARVIZ_CDS_SELECTION_` to separate var_name
-    from group and dimensions in CDS columns.
-
-    Parameters
-    ----------
-    data : obj
-        Any object that can be converted to an az.InferenceData object
-        Refer to documentation of az.convert_to_inference_data for details
-    var_names : str or list of str, optional
-        Variables to be processed, if None all variables are processed.
-    groups : str or list of str, optional
-        Select groups for CDS. Default groups are {"posterior_groups", "prior_groups",
-        "posterior_groups_warmup"}
-
-        - posterior_groups: posterior, posterior_predictive, sample_stats
-        - prior_groups: prior, prior_predictive, sample_stats_prior
-        - posterior_groups_warmup: warmup_posterior, warmup_posterior_predictive,
-          warmup_sample_stats
-
-    ignore_groups : str or list of str, optional
-        Ignore specific groups from CDS.
-    dimension : str, or list of str, optional
-        Select dimensions along to slice the data. By default uses ("chain", "draw").
-    group_info : bool
-        Add group info for `var_name_format`
-    var_name_format : str or tuple of tuple of string, optional
-        Select column name format for non-scalar input.
-        Predefined options are {"brackets", "underscore", "cds"}
-
-            "brackets":
-                - add_group_info == False: ``theta[0,0]``
-                - add_group_info == True: ``theta_posterior[0,0]``
-            "underscore":
-                - add_group_info == False: ``theta_0_0``
-                - add_group_info == True: ``theta_posterior_0_0_``
-            "cds":
-                - add_group_info == False: ``theta_ARVIZ_CDS_SELECTION_0_0``
-                - add_group_info == True: ``theta_ARVIZ_GROUP_posterior__ARVIZ_CDS_SELECTION_0_0``
-            tuple:
-                Structure:
-
-                    - tuple: (dim_info, group_info)
-
-                        - dim_info: (str: `.join` separator,
-                          str: dim_separator_start,
-                          str: dim_separator_end)
-                        - group_info: (str: group separator start, str: group separator end)
-
-                Example: ((",", "[", "]"), ("_", ""))
-
-                    - add_group_info == False: ``theta[0,0]``
-                    - add_group_info == True: ``theta_posterior[0,0]``
-
-    index_origin : int, optional
-        Start parameter indices from `index_origin`. Either 0 or 1.
-
-    Returns
-    -------
-    bokeh.models.ColumnDataSource object
-    """
-    from ...utils import flatten_inference_data_to_dict
-
-    if var_name_format is None:
-        var_name_format = "cds"
-
-    cds_dict = flatten_inference_data_to_dict(
-        data=data,
-        var_names=var_names,
-        groups=groups,
-        dimensions=dimensions,
-        group_info=group_info,
-        index_origin=index_origin,
-        var_name_format=var_name_format,
-    )
-    cds_data = ColumnDataSource(DataFrame.from_dict(cds_dict, orient="columns"))
-    return cds_data
-
-
-def output_notebook(*args, **kwargs):
-    """Wrap func:`bokeh.plotting.output_notebook`."""
-    import bokeh.plotting as bkp
-
-    return bkp.output_notebook(*args, **kwargs)
-
-
-def output_file(*args, **kwargs):
-    """Wrap :func:`bokeh.plotting.output_file`."""
-    import bokeh.plotting as bkp
-
-    return bkp.output_file(*args, **kwargs)
-
-
-def ColumnDataSource(*args, **kwargs):
-    """Wrap bokeh.models.ColumnDataSource."""
-    from bokeh.models import ColumnDataSource
-
-    return ColumnDataSource(*args, **kwargs)
-
-
-def create_layout(ax, force_layout=False):
-    """Transform bokeh array of figures to layout."""
-    ax = np.atleast_2d(ax)
-    subplot_order = rcParams["plot.bokeh.layout.order"]
-    if force_layout:
-        from bokeh.layouts import gridplot as layout
-
-        ax = ax.tolist()
-        layout_args = {
-            "sizing_mode": rcParams["plot.bokeh.layout.sizing_mode"],
-            "toolbar_location": rcParams["plot.bokeh.layout.toolbar_location"],
-        }
-    elif any(item in subplot_order for item in ("row", "column")):
-        # check number of rows
-        match = re.match(r"(\d*)(row|column)", subplot_order)
-        n = int(match.group(1)) if match.group(1) is not None else 1
-        subplot_order = match.group(2)
-        # set up 1D list of axes
-        ax = [item for item in ax.ravel().tolist() if item is not None]
-        layout_args = {"sizing_mode": rcParams["plot.bokeh.layout.sizing_mode"]}
-        if subplot_order == "row" and n == 1:
-            from bokeh.layouts import row as layout
-        elif subplot_order == "column" and n == 1:
-            from bokeh.layouts import column as layout
-        else:
-            from bokeh.layouts import layout
-
-        if n != 1:
-            ax = np.array(ax + [None for _ in range(int(np.ceil(len(ax) / n)) - len(ax))])
-            ax = ax.reshape(n, -1) if subplot_order == "row" else ax.reshape(-1, n)
-            ax = ax.tolist()
-    else:
-        if subplot_order in ("square", "square_trimmed"):
-            ax = [item for item in ax.ravel().tolist() if item is not None]
-            n = int(np.ceil(len(ax) ** 0.5))
-            ax = ax + [None for _ in range(n**2 - len(ax))]
-            ax = np.array(ax).reshape(n, n)
-        ax = ax.tolist()
-        if (subplot_order == "square_trimmed") and any(
-            all(item is None for item in row) for row in ax
-        ):
-            from bokeh.layouts import layout
-
-            ax = [row for row in ax if any(item is not None for item in row)]
-            layout_args = {"sizing_mode": rcParams["plot.bokeh.layout.sizing_mode"]}
-        else:
-            from bokeh.layouts import gridplot as layout
-
-            layout_args = {
-                "sizing_mode": rcParams["plot.bokeh.layout.sizing_mode"],
-                "toolbar_location": rcParams["plot.bokeh.layout.toolbar_location"],
-            }
-    # ignore "fixed" sizing_mode without explicit width and height
-    if layout_args.get("sizing_mode", "") == "fixed":
-        layout_args.pop("sizing_mode")
-    return layout(ax, **layout_args)
-
-
-def show_layout(ax, show=True, force_layout=False):
-    """Create a layout and call bokeh show."""
-    if show is None:
-        show = rcParams["plot.bokeh.show"]
-    if show:
-        import bokeh.plotting as bkp
-
-        layout = create_layout(ax, force_layout=force_layout)
-        bkp.show(layout)
-
-
-def _copy_docstring(lib, function):
-    """Extract docstring from function."""
-    import importlib
-
-    try:
-        module = importlib.import_module(lib)
-        func = getattr(module, function)
-        doc = func.__doc__
-    except ImportError:
-        doc = f"Failed to import function {function} from {lib}"
-
-    if not isinstance(doc, str):
-        doc = ""
-    return doc
-
-
-# TODO: try copying substitutions too, or autoreplace them ourselves
-if output_notebook.__doc__ is not None:  # if run with python -OO, __doc__ is stripped
-    output_notebook.__doc__ += "\n\n" + _copy_docstring(
-        "bokeh.plotting", "output_notebook"
-    ).replace("|save|", "save").replace("|show|", "show")
-    output_file.__doc__ += "\n\n" + _copy_docstring("bokeh.plotting", "output_file").replace(
-        "|save|", "save"
-    ).replace("|show|", "show")
-    ColumnDataSource.__doc__ += "\n\n" + _copy_docstring("bokeh.models", "ColumnDataSource")

arviz/plots/backends/bokeh/__init__.py

@@ -1,166 +0,0 @@
-# pylint: disable=wrong-import-position
-"""Bokeh Plotting Backend."""
-from bokeh.plotting import figure
-from numpy import array
-from packaging import version
-
-from ....rcparams import rcParams
-
-
-def backend_kwarg_defaults(*args, **kwargs):
-    """Get default kwargs for backend.
-
-    For args add a tuple with key and rcParam key pair.
-    """
-    defaults = {**kwargs}
-    # add needed default args from arviz.rcParams
-    for key, arg in args:
-        defaults.setdefault(key, rcParams[arg])
-
-    for key, arg in {
-        "toolbar_location": "plot.bokeh.layout.toolbar_location",
-        "tools": "plot.bokeh.tools",
-        "output_backend": "plot.bokeh.output_backend",
-        "height": "plot.bokeh.figure.height",
-        "width": "plot.bokeh.figure.width",
-    }.items():
-        # by default, ignore height and width if dpi is used
-        if key in ("height", "width") and "dpi" in defaults:
-            continue
-        defaults.setdefault(key, rcParams[arg])
-    return defaults
-
-
-def create_axes_grid(
-    length_plotters,
-    rows=1,
-    cols=1,
-    figsize=None,
-    squeeze=False,
-    sharex=False,
-    sharey=False,
-    polar=False,
-    backend_kwargs=None,
-):
-    """Create figure and axes for grids with multiple plots.
-
-    Parameters
-    ----------
-    length_plotters : int
-        Number of figures required
-    rows : int
-        Number of rows
-    cols : int
-        Number of columns
-    figsize : tuple
-        Figure size in inches
-    squeeze : bool
-        Return bokeh.figure object if True else ndarray of bokeh.figure objects
-    sharex : bool
-        Share x axis between the figures
-    sharey : bool
-        Share y axis between the figures
-    polar : bool
-        Set up polar coordinates plot
-    backend_kwargs: dict, optional
-        kwargs for backend figure.
-
-    Returns
-    -------
-    figures : bokeh figure or np.array of bokeh.figure
-    """
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    if figsize is not None:
-        backend_kwargs = {
-            **backend_kwarg_defaults(
-                ("dpi", "plot.bokeh.figure.dpi"),
-            ),
-            **backend_kwargs,
-        }
-        dpi = backend_kwargs.pop("dpi")
-        backend_kwargs.setdefault("width", int(figsize[0] * dpi / cols))
-        backend_kwargs.setdefault("height", int(figsize[1] * dpi / rows))
-    else:
-        backend_kwargs = {
-            **backend_kwarg_defaults(),
-            **backend_kwargs,
-        }
-
-    figures = []
-
-    if polar:
-        backend_kwargs.setdefault("x_axis_type", None)
-        backend_kwargs.setdefault("y_axis_type", None)
-
-    for row in range(rows):
-        row_figures = []
-        for col in range(cols):
-            if (row == 0) and (col == 0) and (sharex or sharey):
-                p = figure(**backend_kwargs)  # pylint: disable=invalid-name
-                row_figures.append(p)
-                if sharex:
-                    backend_kwargs["x_range"] = p.x_range
-                if sharey:
-                    backend_kwargs["y_range"] = p.y_range
-            elif row * cols + (col + 1) > length_plotters:
-                row_figures.append(None)
-            else:
-                row_figures.append(figure(**backend_kwargs))
-        figures.append(row_figures)
-    figures = array(figures)
-    if figures.size == 1 and squeeze:
-        figures = figures[0, 0]
-    return figures
-
-
-def dealiase_sel_kwargs(kwargs, prop_dict, idx):
-    """Generate kwargs dict from kwargs and prop_dict.
-
-    Gets property at position ``idx`` for each property in prop_dict and adds it to
-    ``kwargs``. Values in prop_dict are dealiased and overwrite values in
-    kwargs with the same key .
-
-    Parameters
-    ----------
-    kwargs : dict
-    prop_dict : dict of {str : array_like}
-    idx : int
-    """
-    return {
-        **kwargs,
-        **{prop: props[idx] for prop, props in prop_dict.items()},
-    }
-
-
-from .autocorrplot import plot_autocorr
-from .compareplot import plot_compare
-from .densityplot import plot_density
-from .distplot import plot_dist
-from .elpdplot import plot_elpd
-from .energyplot import plot_energy
-from .essplot import plot_ess
-from .forestplot import plot_forest
-from .hdiplot import plot_hdi
-from .kdeplot import plot_kde
-from .khatplot import plot_khat
-from .loopitplot import plot_loo_pit
-from .mcseplot import plot_mcse
-from .pairplot import plot_pair
-from .parallelplot import plot_parallel
-from .ppcplot import plot_ppc
-from .posteriorplot import plot_posterior
-from .rankplot import plot_rank
-from .traceplot import plot_trace
-from .violinplot import plot_violin
-
-
-def check_bokeh_version():
-    """Check minimum bokeh version."""
-    try:
-        import bokeh
-
-        assert version.parse(bokeh.__version__) >= version.parse("1.4.0")
-    except (ImportError, AssertionError) as err:
-        raise ImportError("'bokeh' backend needs Bokeh (1.4.0+) installed.") from err

arviz/plots/backends/bokeh/autocorrplot.py

@@ -1,101 +0,0 @@
-"""Bokeh Autocorrplot."""
-
-import numpy as np
-from bokeh.models import DataRange1d, BoxAnnotation
-from bokeh.models.annotations import Title
-
-
-from ....stats import autocorr
-from ...plot_utils import _scale_fig_size
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_autocorr(
-    axes,
-    plotters,
-    max_lag,
-    figsize,
-    rows,
-    cols,
-    combined,
-    textsize,
-    labeller,
-    backend_config,
-    backend_kwargs,
-    show,
-):
-    """Bokeh autocorrelation plot."""
-    if backend_config is None:
-        backend_config = {}
-
-    len_y = plotters[0][-1].size
-    backend_config.setdefault("bounds_x_range", (0, len_y))
-
-    backend_config = {
-        **backend_kwarg_defaults(
-            ("bounds_y_range", "plot.bokeh.bounds_y_range"),
-        ),
-        **backend_config,
-    }
-
-    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, rows, cols)
-
-    if axes is None:
-        axes = create_axes_grid(
-            len(plotters),
-            rows,
-            cols,
-            figsize=figsize,
-            sharex=True,
-            sharey=True,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        axes = np.atleast_2d(axes)
-
-    data_range_x = DataRange1d(
-        start=0, end=max_lag, bounds=backend_config["bounds_x_range"], min_interval=5
-    )
-    data_range_y = DataRange1d(
-        start=-1, end=1, bounds=backend_config["bounds_y_range"], min_interval=0.1
-    )
-
-    for (var_name, selection, isel, x), ax in zip(
-        plotters, (item for item in axes.flatten() if item is not None)
-    ):
-        x_prime = x
-        if combined:
-            x_prime = x.flatten()
-        c_i = 1.96 / x_prime.size**0.5
-        y = autocorr(x_prime)
-
-        ax.add_layout(BoxAnnotation(bottom=-c_i, top=c_i, fill_color="gray"))
-        ax.segment(
-            x0=np.arange(len(y)),
-            y0=0,
-            x1=np.arange(len(y)),
-            y1=y,
-            line_width=line_width,
-            line_color="black",
-        )
-
-        title = Title()
-        title.text = labeller.make_label_vert(var_name, selection, isel)
-        ax.title = title
-        ax.x_range = data_range_x
-        ax.y_range = data_range_y
-
-    show_layout(axes, show)
-
-    return axes

arviz/plots/backends/bokeh/bfplot.py

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

arviz/plots/backends/bokeh/bpvplot.py

@@ -1,193 +0,0 @@
-"""Bokeh Bayesian p-value Posterior predictive plot."""
-
-import numpy as np
-from bokeh.models import BoxAnnotation
-from bokeh.models.annotations import Title
-from scipy import stats
-
-from ....stats.density_utils import kde
-from ....stats.stats_utils import smooth_data
-from ...kdeplot import plot_kde
-from ...plot_utils import (
-    _scale_fig_size,
-    is_valid_quantile,
-    sample_reference_distribution,
-    vectorized_to_hex,
-)
-from .. import show_layout
-from . import backend_kwarg_defaults, create_axes_grid
-
-
-def plot_bpv(
-    ax,
-    length_plotters,
-    rows,
-    cols,
-    obs_plotters,
-    pp_plotters,
-    total_pp_samples,
-    kind,
-    t_stat,
-    bpv,
-    plot_mean,
-    reference,
-    mse,
-    n_ref,
-    hdi_prob,
-    color,
-    figsize,
-    textsize,
-    labeller,
-    plot_ref_kwargs,
-    backend_kwargs,
-    show,
-    smoothing,
-):
-    """Bokeh bpv plot."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    color = vectorized_to_hex(color)
-
-    if plot_ref_kwargs is None:
-        plot_ref_kwargs = {}
-    if kind == "p_value" and reference == "analytical":
-        plot_ref_kwargs.setdefault("line_color", "black")
-        plot_ref_kwargs.setdefault("line_dash", "dashed")
-    else:
-        plot_ref_kwargs.setdefault("alpha", 0.1)
-        plot_ref_kwargs.setdefault("line_color", color)
-
-    (figsize, ax_labelsize, _, _, linewidth, markersize) = _scale_fig_size(
-        figsize, textsize, rows, cols
-    )
-
-    if ax is None:
-        axes = create_axes_grid(
-            length_plotters,
-            rows,
-            cols,
-            figsize=figsize,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        axes = np.atleast_2d(ax)
-
-        if len([item for item in axes.ravel() if not None]) != length_plotters:
-            raise ValueError(
-                f"Found {length_plotters} variables to plot but {len(axes)} axes instances. "
-                "They must be equal."
-            )
-
-    for i, ax_i in enumerate((item for item in axes.flatten() if item is not None)):
-        var_name, sel, isel, obs_vals = obs_plotters[i]
-        pp_var_name, _, _, pp_vals = pp_plotters[i]
-
-        obs_vals = obs_vals.flatten()
-        pp_vals = pp_vals.reshape(total_pp_samples, -1)
-
-        if (obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i") and smoothing is True:
-            obs_vals, pp_vals = smooth_data(obs_vals, pp_vals)
-
-        if kind == "p_value":
-            tstat_pit = np.mean(pp_vals <= obs_vals, axis=-1)
-            x_s, tstat_pit_dens = kde(tstat_pit)
-            ax_i.line(x_s, tstat_pit_dens, line_width=linewidth, line_color=color)
-            if reference is not None:
-                dist = stats.beta(obs_vals.size / 2, obs_vals.size / 2)
-                if reference == "analytical":
-                    lwb = dist.ppf((1 - 0.9999) / 2)
-                    upb = 1 - lwb
-                    x = np.linspace(lwb, upb, 500)
-                    dens_ref = dist.pdf(x)
-                    ax_i.line(x, dens_ref, **plot_ref_kwargs)
-                elif reference == "samples":
-                    x_ss, u_dens = sample_reference_distribution(
-                        dist,
-                        (
-                            tstat_pit_dens.size,
-                            n_ref,
-                        ),
-                    )
-                    ax_i.multi_line(
-                        list(x_ss.T), list(u_dens.T), line_width=linewidth, **plot_ref_kwargs
-                    )
-
-        elif kind == "u_value":
-            tstat_pit = np.mean(pp_vals <= obs_vals, axis=0)
-            x_s, tstat_pit_dens = kde(tstat_pit)
-            ax_i.line(x_s, tstat_pit_dens, color=color)
-            if reference is not None:
-                if reference == "analytical":
-                    n_obs = obs_vals.size
-                    hdi_ = stats.beta(n_obs / 2, n_obs / 2).ppf((1 - hdi_prob) / 2)
-                    hdi_odds = (hdi_ / (1 - hdi_), (1 - hdi_) / hdi_)
-                    ax_i.add_layout(
-                        BoxAnnotation(
-                            bottom=hdi_odds[1],
-                            top=hdi_odds[0],
-                            fill_alpha=plot_ref_kwargs.pop("alpha"),
-                            fill_color=plot_ref_kwargs.pop("line_color"),
-                            **plot_ref_kwargs,
-                        )
-                    )
-                    ax_i.line([0, 1], [1, 1], line_color="white")
-                elif reference == "samples":
-                    dist = stats.uniform(0, 1)
-                    x_ss, u_dens = sample_reference_distribution(dist, (tstat_pit_dens.size, n_ref))
-                    for x_ss_i, u_dens_i in zip(x_ss.T, u_dens.T):
-                        ax_i.line(x_ss_i, u_dens_i, line_width=linewidth, **plot_ref_kwargs)
-            if mse:
-                ax_i.line(0, 0, legend_label=f"mse={np.mean((1 - tstat_pit_dens)**2) * 100:.2f}")
-
-            ax_i.line(0, 0)
-        else:
-            if t_stat in ["mean", "median", "std"]:
-                if t_stat == "mean":
-                    tfunc = np.mean
-                elif t_stat == "median":
-                    tfunc = np.median
-                elif t_stat == "std":
-                    tfunc = np.std
-                obs_vals = tfunc(obs_vals)
-                pp_vals = tfunc(pp_vals, axis=1)
-            elif hasattr(t_stat, "__call__"):
-                obs_vals = t_stat(obs_vals.flatten())
-                pp_vals = t_stat(pp_vals)
-            elif is_valid_quantile(t_stat):
-                t_stat = float(t_stat)
-                obs_vals = np.quantile(obs_vals, q=t_stat)
-                pp_vals = np.quantile(pp_vals, q=t_stat, axis=1)
-            else:
-                raise ValueError(f"T statistics {t_stat} not implemented")
-
-            plot_kde(pp_vals, ax=ax_i, plot_kwargs={"color": color}, backend="bokeh", show=False)
-            # ax_i.set_yticks([])
-            if bpv:
-                p_value = np.mean(pp_vals <= obs_vals)
-                ax_i.line(0, 0, legend_label=f"bpv={p_value:.2f}", alpha=0)
-
-            if plot_mean:
-                ax_i.scatter(
-                    obs_vals.mean(),
-                    0,
-                    fill_color=color,
-                    line_color="black",
-                    size=markersize,
-                    marker="circle",
-                )
-
-        _title = Title()
-        _title.text = labeller.make_pp_label(var_name, pp_var_name, sel, isel)
-        ax_i.title = _title
-        size = str(int(ax_labelsize))
-        ax_i.title.text_font_size = f"{size}pt"
-
-    show_layout(axes, show)
-
-    return axes