arviz 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

arviz/__init__.py

@@ -1,6 +1,6 @@
 # pylint: disable=wildcard-import,invalid-name,wrong-import-position
 """ArviZ is a library for exploratory analysis of Bayesian models."""
-__version__ = "0.19.0"
+__version__ = "0.21.0"
 
 import logging
 import os

arviz/data/base.py

@@ -9,9 +9,13 @@ from copy import deepcopy
 from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
 
 import numpy as np
-import tree
 import xarray as xr
 
+try:
+    import tree
+except ImportError:
+    tree = None
+
 try:
     import ujson as json
 except ImportError:
@@ -89,6 +93,9 @@ def _yield_flat_up_to(shallow_tree, input_tree, path=()):
         input_tree.
     """
     # pylint: disable=protected-access
+    if tree is None:
+        raise ImportError("Missing optional dependency 'dm-tree'. Use pip or conda to install it")
+
     if isinstance(shallow_tree, tree._TEXT_OR_BYTES) or not (
         isinstance(shallow_tree, tree.collections_abc.Mapping)
         or tree._is_namedtuple(shallow_tree)
@@ -194,10 +201,10 @@ def generate_dims_coords(
     for i, dim_len in enumerate(shape):
         idx = i + len([dim for dim in default_dims if dim in dims])
         if len(dims) < idx + 1:
-            dim_name = f"{var_name}_dim_{idx}"
+            dim_name = f"{var_name}_dim_{i}"
             dims.append(dim_name)
         elif dims[idx] is None:
-            dim_name = f"{var_name}_dim_{idx}"
+            dim_name = f"{var_name}_dim_{i}"
             dims[idx] = dim_name
         dim_name = dims[idx]
         if dim_name not in coords:
@@ -299,7 +306,7 @@ def numpy_to_data_array(
     return xr.DataArray(ary, coords=coords, dims=dims)
 
 
-def pytree_to_dataset(
+def dict_to_dataset(
     data,
     *,
     attrs=None,
@@ -312,6 +319,8 @@ def pytree_to_dataset(
 ):
     """Convert a dictionary or pytree of numpy arrays to an xarray.Dataset.
 
+    ArviZ itself supports conversion of flat dictionaries.
+    Suport for pytrees requires ``dm-tree`` which is an optional dependency.
     See https://jax.readthedocs.io/en/latest/pytrees.html for what a pytree is, but
     this inclues at least dictionaries and tuple types.
 
@@ -386,10 +395,12 @@ def pytree_to_dataset(
     """
     if dims is None:
         dims = {}
-    try:
-        data = {k[0] if len(k) == 1 else k: v for k, v in _flatten_with_path(data)}
-    except TypeError:  # probably unsortable keys -- the function will still work if
-        pass  # it is an honest dictionary.
+
+    if tree is not None:
+        try:
+            data = {k[0] if len(k) == 1 else k: v for k, v in _flatten_with_path(data)}
+        except TypeError:  # probably unsortable keys -- the function will still work if
+            pass  # it is an honest dictionary.
 
     data_vars = {
         key: numpy_to_data_array(
@@ -406,7 +417,7 @@ def pytree_to_dataset(
     return xr.Dataset(data_vars=data_vars, attrs=make_attrs(attrs=attrs, library=library))
 
 
-dict_to_dataset = pytree_to_dataset
+pytree_to_dataset = dict_to_dataset
 
 
 def make_attrs(attrs=None, library=None):

arviz/data/converters.py

@@ -1,9 +1,13 @@
 """High level conversion functions."""
 
 import numpy as np
-import tree
 import xarray as xr
 
+try:
+    from tree import is_nested
+except ImportError:
+    is_nested = lambda obj: False
+
 from .base import dict_to_dataset
 from .inference_data import InferenceData
 from .io_beanmachine import from_beanmachine
@@ -107,7 +111,7 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
         dataset = obj.to_dataset()
     elif isinstance(obj, dict):
         dataset = dict_to_dataset(obj, coords=coords, dims=dims)
-    elif tree.is_nested(obj) and not isinstance(obj, (list, tuple)):
+    elif is_nested(obj) and not isinstance(obj, (list, tuple)):
         dataset = dict_to_dataset(obj, coords=coords, dims=dims)
     elif isinstance(obj, np.ndarray):
         dataset = dict_to_dataset({"x": obj}, coords=coords, dims=dims)
@@ -122,7 +126,7 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
             "xarray dataarray",
             "xarray dataset",
             "dict",
-            "pytree",
+            "pytree (if 'dm-tree' is installed)",
             "netcdf filename",
             "numpy array",
             "pystan fit",

arviz/data/inference_data.py

@@ -102,6 +102,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
     def __init__(
         self,
         attrs: Union[None, Mapping[Any, Any]] = None,
+        warn_on_custom_groups: bool = False,
         **kwargs: Union[xr.Dataset, List[xr.Dataset], Tuple[xr.Dataset, xr.Dataset]],
     ) -> None:
         """Initialize InferenceData object from keyword xarray datasets.
@@ -110,6 +111,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         ----------
         attrs : dict
             sets global attribute for InferenceData object.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
         kwargs :
             Keyword arguments of xarray datasets
 
@@ -154,9 +158,10 @@ class InferenceData(Mapping[str, xr.Dataset]):
         for key in kwargs:
             if key not in SUPPORTED_GROUPS_ALL:
                 key_list.append(key)
-                warnings.warn(
-                    f"{key} group is not defined in the InferenceData scheme", UserWarning
-                )
+                if warn_on_custom_groups:
+                    warnings.warn(
+                        f"{key} group is not defined in the InferenceData scheme", UserWarning
+                    )
         for key in key_list:
             dataset = kwargs[key]
             dataset_warmup = None
@@ -266,6 +271,14 @@ class InferenceData(Mapping[str, xr.Dataset]):
             raise KeyError(key)
         return getattr(self, key)
 
+    def __setitem__(self, key: str, value: xr.Dataset):
+        """Set item by key and update group list accordingly."""
+        if key.startswith(WARMUP_TAG):
+            self._groups_warmup.append(key)
+        else:
+            self._groups.append(key)
+        setattr(self, key, value)
+
     def groups(self) -> List[str]:
         """Return all groups present in InferenceData object."""
         return self._groups_all
@@ -1459,7 +1472,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         else:
             return out
 
-    def add_groups(self, group_dict=None, coords=None, dims=None, **kwargs):
+    def add_groups(
+        self, group_dict=None, coords=None, dims=None, warn_on_custom_groups=False, **kwargs
+    ):
         """Add new groups to InferenceData object.
 
         Parameters
@@ -1471,6 +1486,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         dims : dict of {str : list of str}, optional
             Dimensions of each variable. The keys are variable names, values are lists of
             coordinates.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
         kwargs : dict, optional
             The keyword arguments form of group_dict. One of group_dict or kwargs must be provided.
 
@@ -1534,7 +1552,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
         if repeated_groups:
             raise ValueError(f"{repeated_groups} group(s) already exists.")
         for group, dataset in group_dict.items():
-            if group not in SUPPORTED_GROUPS_ALL:
+            if warn_on_custom_groups and group not in SUPPORTED_GROUPS_ALL:
                 warnings.warn(
                     f"The group {group} is not defined in the InferenceData scheme",
                     UserWarning,
@@ -1589,7 +1607,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
                     else:
                         self._groups.append(group)
 
-    def extend(self, other, join="left"):
+    def extend(self, other, join="left", warn_on_custom_groups=False):
         """Extend InferenceData with groups from another InferenceData.
 
         Parameters
@@ -1600,6 +1618,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
             Defines how the two decide which group to keep when the same group is
             present in both objects. 'left' will discard the group in ``other`` whereas 'right'
             will keep the group in ``other`` and discard the one in ``self``.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
 
         Examples
         --------
@@ -1643,7 +1664,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
         for group in other._groups_all:  # pylint: disable=protected-access
             if hasattr(self, group) and join == "left":
                 continue
-            if group not in SUPPORTED_GROUPS_ALL:
+            if warn_on_custom_groups and group not in SUPPORTED_GROUPS_ALL:
                 warnings.warn(
                     f"{group} group is not defined in the InferenceData scheme", UserWarning
                 )

arviz/plots/backends/__init__.py

@@ -213,10 +213,11 @@ def _copy_docstring(lib, function):
 
 
 # TODO: try copying substitutions too, or autoreplace them ourselves
-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")
+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/bpvplot.py

@@ -41,6 +41,7 @@ def plot_bpv(
     plot_ref_kwargs,
     backend_kwargs,
     show,
+    smoothing,
 ):
     """Bokeh bpv plot."""
     if backend_kwargs is None:
@@ -90,6 +91,9 @@ def plot_bpv(
         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)
@@ -115,9 +119,6 @@ def plot_bpv(
                     )
 
         elif kind == "u_value":
-            if obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i":
-                obs_vals, pp_vals = smooth_data(obs_vals, pp_vals)
-
             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)

arviz/plots/backends/bokeh/densityplot.py

@@ -225,7 +225,11 @@ def _d_helper(
 
     if point_estimate is not None:
         est = calculate_point_estimate(point_estimate, vec, bw, circular)
-        plotted.append(ax.circle(est, 0, fill_color=color, line_color="black", size=markersize))
+        plotted.append(
+            ax.scatter(
+                est, 0, marker="circle", fill_color=color, line_color="black", size=markersize
+            )
+        )
 
     _title = Title()
     _title.text = vname

arviz/plots/backends/bokeh/dotplot.py

@@ -47,7 +47,10 @@ def plot_dot(
 
     if plot_kwargs is None:
         plot_kwargs = {}
-        plot_kwargs.setdefault("color", dotcolor)
+    else:
+        plot_kwargs = plot_kwargs.copy()
+    plot_kwargs.setdefault("color", dotcolor)
+    plot_kwargs.setdefault("marker", "circle")
 
     if linewidth is None:
         linewidth = auto_linewidth
@@ -95,7 +98,7 @@ def plot_dot(
     stack_locs, stack_count = wilkinson_algorithm(values, binwidth)
     x, y = layout_stacks(stack_locs, stack_count, binwidth, stackratio, rotated)
 
-    ax.circle(x, y, radius=dotsize * (binwidth / 2), **plot_kwargs, radius_dimension="y")
+    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

arviz/plots/backends/bokeh/essplot.py

@@ -73,12 +73,14 @@ def plot_ess(
     for (var_name, selection, isel, x), ax_ in zip(
         plotters, (item for item in ax.flatten() if item is not None)
     ):
-        bulk_points = ax_.circle(np.asarray(xdata), np.asarray(x), size=6)
+        bulk_points = ax_.scatter(np.asarray(xdata), np.asarray(x), marker="circle", size=6)
         if kind == "evolution":
             bulk_line = ax_.line(np.asarray(xdata), np.asarray(x))
             ess_tail = ess_tail_dataset[var_name].sel(**selection)
             tail_points = ax_.line(np.asarray(xdata), np.asarray(ess_tail), color="orange")
-            tail_line = ax_.circle(np.asarray(xdata), np.asarray(ess_tail), size=6, color="orange")
+            tail_line = ax_.scatter(
+                np.asarray(xdata), np.asarray(ess_tail), marker="circle", size=6, color="orange"
+            )
         elif rug:
             if rug_kwargs is None:
                 rug_kwargs = {}

arviz/plots/backends/bokeh/forestplot.py

@@ -535,9 +535,10 @@ class PlotHandler:
                         )
                     )
                 plotted[model_name].append(
-                    ax.circle(
+                    ax.scatter(
                         x=values[mid],
                         y=y,
+                        marker="circle",
                         size=markersize * 0.75,
                         fill_color=color,
                     )
@@ -555,9 +556,10 @@ class PlotHandler:
             for y, ess, color, model_name in plotter.ess():
                 if ess is not None:
                     plotted[model_name].append(
-                        ax.circle(
+                        ax.scatter(
                             x=ess,
                             y=y,
+                            marker="circle",
                             fill_color=color,
                             size=markersize,
                             line_color="black",
@@ -582,8 +584,13 @@ class PlotHandler:
             for y, r_hat, color, model_name in plotter.r_hat():
                 if r_hat is not None:
                     plotted[model_name].append(
-                        ax.circle(
-                            x=r_hat, y=y, fill_color=color, size=markersize, line_color="black"
+                        ax.scatter(
+                            x=r_hat,
+                            y=y,
+                            marker="circle",
+                            fill_color=color,
+                            size=markersize,
+                            line_color="black",
                         )
                     )
         ax.x_range._property_values["start"] = 0.9  # pylint: disable=protected-access

arviz/plots/backends/bokeh/khatplot.py

@@ -94,9 +94,10 @@ def plot_khat(
 
     if not isinstance(rgba_c, str) and isinstance(rgba_c, Iterable):
         for idx, (alpha, rgba_c_) in enumerate(zip(alphas, rgba_c)):
-            ax.cross(
+            ax.scatter(
                 xdata[idx],
                 khats[idx],
+                marker="cross",
                 line_color=rgba_c_,
                 fill_color=rgba_c_,
                 line_alpha=alpha,
@@ -104,9 +105,10 @@ def plot_khat(
                 size=10,
             )
     else:
-        ax.cross(
+        ax.scatter(
             xdata,
             khats,
+            marker="cross",
             line_color=rgba_c,
             fill_color=rgba_c,
             size=10,

arviz/plots/backends/bokeh/lmplot.py

@@ -51,12 +51,18 @@ def plot_lm(
 
     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)
 
@@ -84,7 +90,7 @@ def plot_lm(
         _, _, _, y_plotters = y[i]
         _, _, _, x_plotters = x[i]
         legend_it = []
-        observed_legend = ax_i.circle(x_plotters, y_plotters, **y_kwargs)
+        observed_legend = ax_i.scatter(x_plotters, y_plotters, **y_kwargs)
         legend_it.append(("Observed", [observed_legend]))
 
         if y_hat is not None:
@@ -98,14 +104,14 @@ def plot_lm(
                         x_plotters_jitter = x_plotters + np.random.uniform(
                             low=-scale_high, high=scale_high, size=len(x_plotters)
                         )
-                        posterior_circle = ax_i.circle(
+                        posterior_circle = ax_i.scatter(
                             x_plotters_jitter,
                             y_hat_plotters[..., j],
                             alpha=0.2,
                             **y_hat_plot_kwargs,
                         )
                     else:
-                        posterior_circle = ax_i.circle(
+                        posterior_circle = ax_i.scatter(
                             x_plotters, y_hat_plotters[..., j], alpha=0.2, **y_hat_plot_kwargs
                         )
                     posterior_legend.append(posterior_circle)

arviz/plots/backends/bokeh/mcseplot.py

@@ -71,13 +71,13 @@ def plot_mcse(
             values = data[var_name].sel(**selection).values.flatten()
         if errorbar:
             quantile_values = _quantile(values, probs)
-            ax_.dash(probs, quantile_values)
+            ax_.scatter(probs, quantile_values, marker="dash")
             ax_.multi_line(
                 list(zip(probs, probs)),
                 [(quant - err, quant + err) for quant, err in zip(quantile_values, x)],
             )
         else:
-            ax_.circle(probs, x)
+            ax_.scatter(probs, x, marker="circle")
             if extra_methods:
                 mean_mcse_i = mean_mcse[var_name].sel(**selection).values.item()
                 sd_mcse_i = sd_mcse[var_name].sel(**selection).values.item()

arviz/plots/backends/bokeh/pairplot.py

@@ -121,12 +121,14 @@ def plot_pair(
             )
 
     reference_values_kwargs = _init_kwargs_dict(reference_values_kwargs)
+    reference_values_kwargs.setdefault("marker", "circle")
     reference_values_kwargs.setdefault("line_color", "black")
     reference_values_kwargs.setdefault("fill_color", vectorized_to_hex("C2"))
     reference_values_kwargs.setdefault("line_width", 1)
     reference_values_kwargs.setdefault("size", 10)
 
     divergences_kwargs = _init_kwargs_dict(divergences_kwargs)
+    divergences_kwargs.setdefault("marker", "circle")
     divergences_kwargs.setdefault("line_color", "black")
     divergences_kwargs.setdefault("fill_color", vectorized_to_hex("C1"))
     divergences_kwargs.setdefault("line_width", 1)
@@ -155,6 +157,7 @@ def plot_pair(
     )
 
     point_estimate_marker_kwargs = _init_kwargs_dict(point_estimate_marker_kwargs)
+    point_estimate_marker_kwargs.setdefault("marker", "square")
     point_estimate_marker_kwargs.setdefault("size", markersize)
     point_estimate_marker_kwargs.setdefault("color", "black")
     point_estimate_kwargs.setdefault("line_color", "black")
@@ -265,9 +268,11 @@ def plot_pair(
             elif j + marginals_offset > i:
                 if "scatter" in kind:
                     if divergences:
-                        ax[j, i].circle(var1, var2, source=source, view=source_nondiv)
+                        ax[j, i].scatter(
+                            var1, var2, marker="circle", source=source, view=source_nondiv
+                        )
                     else:
-                        ax[j, i].circle(var1, var2, source=source)
+                        ax[j, i].scatter(var1, var2, marker="circle", source=source)
 
                 if "kde" in kind:
                     var1_kde = plotters[i][-1].flatten()
@@ -293,7 +298,7 @@ def plot_pair(
                     )
 
                 if divergences:
-                    ax[j, i].circle(
+                    ax[j, i].scatter(
                         var1,
                         var2,
                         source=source,
@@ -306,7 +311,7 @@ def plot_pair(
                     var2_pe = plotters[j][-1].flatten()
                     pe_x = calculate_point_estimate(point_estimate, var1_pe)
                     pe_y = calculate_point_estimate(point_estimate, var2_pe)
-                    ax[j, i].square(pe_x, pe_y, **point_estimate_marker_kwargs)
+                    ax[j, i].scatter(pe_x, pe_y, **point_estimate_marker_kwargs)
 
                     ax_hline = Span(
                         location=pe_y,
@@ -344,7 +349,7 @@ def plot_pair(
                     x = reference_values_copy[flat_var_names[j + marginals_offset]]
                     y = reference_values_copy[flat_var_names[i]]
                     if x and y:
-                        ax[j, i].circle(y, x, **reference_values_kwargs)
+                        ax[j, i].scatter(y, x, **reference_values_kwargs)
                 ax[j, i].xaxis.axis_label = flat_var_names[i]
                 ax[j, i].yaxis.axis_label = flat_var_names[j + marginals_offset]
 

arviz/plots/backends/bokeh/ppcplot.py

@@ -313,9 +313,10 @@ def plot_ppc(
                     obs_yvals += np.random.uniform(
                         low=scale_low, high=scale_high, size=len(obs_vals)
                     )
-                glyph = ax_i.circle(
+                glyph = ax_i.scatter(
                     obs_vals,
                     obs_yvals,
+                    marker="circle",
                     line_color=colors[1],
                     fill_color=colors[1],
                     size=markersize,

arviz/plots/backends/bokeh/rankplot.py

@@ -49,6 +49,7 @@ def plot_rank(
 
     if marker_vlines_kwargs is None:
         marker_vlines_kwargs = {}
+    marker_vlines_kwargs.setdefault("marker", "circle")
 
     if backend_kwargs is None:
         backend_kwargs = {}
@@ -109,7 +110,7 @@ def plot_rank(
         elif kind == "vlines":
             ymin = np.full(len(all_counts), all_counts.mean())
             for idx, counts in enumerate(all_counts):
-                ax.circle(
+                ax.scatter(
                     bin_ary,
                     counts,
                     fill_color=colors[idx],

arviz/plots/backends/bokeh/traceplot.py

@@ -385,9 +385,10 @@ def _plot_chains_bokeh(
                 **dealiase_sel_kwargs(trace_kwargs, chain_prop, chain_idx),
             )
             if marker:
-                ax_trace.circle(
+                ax_trace.scatter(
                     x=x_name,
                     y=y_name,
+                    marker="circle",
                     source=cds,
                     radius=0.30,
                     alpha=0.5,

arviz/plots/backends/bokeh/violinplot.py

@@ -81,9 +81,10 @@ def plot_violin(
                 [0, 0], per[:2], line_width=linewidth * 3, line_color="black", line_cap="round"
             )
         ax_.line([0, 0], hdi_probs, line_width=linewidth, line_color="black", line_cap="round")
-        ax_.circle(
+        ax_.scatter(
             0,
             per[-1],
+            marker="circle",
             line_color="white",
             fill_color="white",
             size=linewidth * 1.5,

arviz/plots/backends/matplotlib/bpvplot.py

@@ -38,6 +38,7 @@ def plot_bpv(
     plot_ref_kwargs,
     backend_kwargs,
     show,
+    smoothing,
 ):
     """Matplotlib bpv plot."""
     if backend_kwargs is None:
@@ -87,7 +88,7 @@ def plot_bpv(
         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":
+        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":

arviz/plots/bfplot.py

@@ -2,11 +2,9 @@
 # pylint: disable=unbalanced-tuple-unpacking
 import logging
 
-from numpy import interp
-
 from ..data.utils import extract
 from .plot_utils import get_plotting_function
-from ..stats.density_utils import _kde_linear
+from ..stats import bayes_factor
 
 _log = logging.getLogger(__name__)
 
@@ -94,32 +92,17 @@ def plot_bf(
         >>> az.plot_bf(idata, var_name="a", ref_val=0)
 
     """
-    posterior = extract(idata, var_names=var_name).values
-
-    if ref_val > posterior.max() or ref_val < posterior.min():
-        _log.warning(
-            "The reference value is outside of the posterior. "
-            "This translate into infinite support for H1, which is most likely an overstatement."
-        )
-
-    if posterior.ndim > 1:
-        _log.warning("Posterior distribution has {posterior.ndim} dimensions")
 
     if prior is None:
         prior = extract(idata, var_names=var_name, group="prior").values
 
-    if posterior.dtype.kind == "f":
-        posterior_grid, posterior_pdf = _kde_linear(posterior)
-        prior_grid, prior_pdf = _kde_linear(prior)
-        posterior_at_ref_val = interp(ref_val, posterior_grid, posterior_pdf)
-        prior_at_ref_val = interp(ref_val, prior_grid, prior_pdf)
-
-    elif posterior.dtype.kind == "i":
-        posterior_at_ref_val = (posterior == ref_val).mean()
-        prior_at_ref_val = (prior == ref_val).mean()
+    bf, p_at_ref_val = bayes_factor(
+        idata, var_name, prior=prior, ref_val=ref_val, return_ref_vals=True
+    )
+    bf_10 = bf["BF10"]
+    bf_01 = bf["BF01"]
 
-    bf_10 = prior_at_ref_val / posterior_at_ref_val
-    bf_01 = 1 / bf_10
+    posterior = extract(idata, var_names=var_name)
 
     bfplot_kwargs = dict(
         ax=ax,
@@ -128,8 +111,8 @@ def plot_bf(
         prior=prior,
         posterior=posterior,
         ref_val=ref_val,
-        prior_at_ref_val=prior_at_ref_val,
-        posterior_at_ref_val=posterior_at_ref_val,
+        prior_at_ref_val=p_at_ref_val["prior"],
+        posterior_at_ref_val=p_at_ref_val["posterior"],
         var_name=var_name,
         colors=colors,
         figsize=figsize,