arviz 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

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,18 +51,30 @@ 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)
 
     if y_hat_fill_kwargs is None:
         y_hat_fill_kwargs = {}
-    y_hat_fill_kwargs.setdefault("color", "orange")
+    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 = {}
@@ -72,8 +84,13 @@ def plot_lm(
 
     if y_model_fill_kwargs is None:
         y_model_fill_kwargs = {}
-    y_model_fill_kwargs.setdefault("color", "black")
-    y_model_fill_kwargs.setdefault("alpha", 0.5)
+    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 = {}
@@ -84,7 +101,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 +115,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)
@@ -143,6 +160,11 @@ def plot_lm(
                 )
 
                 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)

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

@@ -37,6 +37,8 @@ def plot_pair(
     diverging_mask,
     divergences_kwargs,
     flat_var_names,
+    flat_ref_slices,
+    flat_var_labels,
     backend_kwargs,
     marginal_kwargs,
     show,
@@ -72,61 +74,25 @@ def plot_pair(
         kde_kwargs["contour_kwargs"].setdefault("line_alpha", 1)
 
     if reference_values:
-        reference_values_copy = {}
-        label = []
-        for variable in list(reference_values.keys()):
-            if " " in variable:
-                variable_copy = variable.replace(" ", "\n", 1)
-            else:
-                variable_copy = variable
-
-            label.append(variable_copy)
-            reference_values_copy[variable_copy] = reference_values[variable]
-
-        difference = set(flat_var_names).difference(set(label))
-
-        if difference:
-            warn = [diff.replace("\n", " ", 1) for diff in difference]
-            warnings.warn(
-                "Argument reference_values does not include reference value for: {}".format(
-                    ", ".join(warn)
-                ),
-                UserWarning,
-            )
-
-    if reference_values:
-        reference_values_copy = {}
-        label = []
-        for variable in list(reference_values.keys()):
-            if " " in variable:
-                variable_copy = variable.replace(" ", "\n", 1)
-            else:
-                variable_copy = variable
-
-            label.append(variable_copy)
-            reference_values_copy[variable_copy] = reference_values[variable]
-
-        difference = set(flat_var_names).difference(set(label))
-
-        for dif in difference:
-            reference_values_copy[dif] = None
+        difference = set(flat_var_names).difference(set(reference_values.keys()))
 
         if difference:
-            warn = [dif.replace("\n", " ", 1) for dif in difference]
             warnings.warn(
                 "Argument reference_values does not include reference value for: {}".format(
-                    ", ".join(warn)
+                    ", ".join(difference)
                 ),
                 UserWarning,
             )
 
     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 +121,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")
@@ -259,15 +226,17 @@ def plot_pair(
                     **marginal_kwargs,
                 )
 
-                ax[j, i].xaxis.axis_label = flat_var_names[i]
-                ax[j, i].yaxis.axis_label = flat_var_names[j + marginals_offset]
+                ax[j, i].xaxis.axis_label = flat_var_labels[i]
+                ax[j, i].yaxis.axis_label = flat_var_labels[j + marginals_offset]
 
             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 +262,7 @@ def plot_pair(
                     )
 
                 if divergences:
-                    ax[j, i].circle(
+                    ax[j, i].scatter(
                         var1,
                         var2,
                         source=source,
@@ -306,7 +275,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,
@@ -341,12 +310,18 @@ def plot_pair(
                             ax[-1, -1].add_layout(ax_pe_hline)
 
                 if reference_values:
-                    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].xaxis.axis_label = flat_var_names[i]
-                ax[j, i].yaxis.axis_label = flat_var_names[j + marginals_offset]
+                    x_name = flat_var_names[j + marginals_offset]
+                    y_name = flat_var_names[i]
+                    if (x_name not in difference) and (y_name not in difference):
+                        ax[j, i].scatter(
+                            np.array(reference_values[y_name])[flat_ref_slices[i]],
+                            np.array(reference_values[x_name])[
+                                flat_ref_slices[j + marginals_offset]
+                            ],
+                            **reference_values_kwargs,
+                        )
+                ax[j, i].xaxis.axis_label = flat_var_labels[i]
+                ax[j, i].yaxis.axis_label = flat_var_labels[j + marginals_offset]
 
     show_layout(ax, show)
 

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/backends/matplotlib/khatplot.py

@@ -7,6 +7,7 @@ from matplotlib import cm
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.colors import to_rgba_array
+from packaging import version
 
 from ....stats.density_utils import histogram
 from ...plot_utils import _scale_fig_size, color_from_dim, set_xticklabels, vectorized_to_hex
@@ -39,7 +40,13 @@ def plot_khat(
     show,
 ):
     """Matplotlib khat plot."""
-    if hover_label and mpl.get_backend() not in mpl.rcsetup.interactive_bk:
+    if version.parse(mpl.__version__) >= version.parse("3.9.0.dev0"):
+        interactive_backends = mpl.backends.backend_registry.list_builtin(
+            mpl.backends.BackendFilter.INTERACTIVE
+        )
+    else:
+        interactive_backends = mpl.rcsetup.interactive_bk
+    if hover_label and mpl.get_backend() not in interactive_backends:
         hover_label = False
         warnings.warn(
             "hover labels are only available with interactive backends. To switch to an "

arviz/plots/backends/matplotlib/lmplot.py

@@ -115,12 +115,18 @@ def plot_lm(
 
         if y_model is not None:
             _, _, _, y_model_plotters = y_model[i]
+
             if kind_model == "lines":
-                for j in range(num_samples):
-                    ax_i.plot(x_plotters, y_model_plotters[..., j], **y_model_plot_kwargs)
-                ax_i.plot([], **y_model_plot_kwargs, label="Uncertainty in mean")
+                # y_model_plotters should be (points, samples)
+                y_points = y_model_plotters.shape[0]
+                if x_plotters.shape[0] == y_points:
+                    for j in range(num_samples):
+                        ax_i.plot(x_plotters, y_model_plotters[:, j], **y_model_plot_kwargs)
+
+                    ax_i.plot([], **y_model_plot_kwargs, label="Uncertainty in mean")
+                    y_model_mean = np.mean(y_model_plotters, axis=1)
+                    ax_i.plot(x_plotters, y_model_mean, **y_model_mean_kwargs, label="Mean")
 
-                y_model_mean = np.mean(y_model_plotters, axis=1)
             else:
                 plot_hdi(
                     x_plotters,
@@ -128,10 +134,10 @@ def plot_lm(
                     fill_kwargs=y_model_fill_kwargs,
                     ax=ax_i,
                 )
-                ax_i.plot([], color=y_model_fill_kwargs["color"], label="Uncertainty in mean")
 
-                y_model_mean = np.mean(y_model_plotters, axis=(0, 1))
-            ax_i.plot(x_plotters, y_model_mean, **y_model_mean_kwargs, label="Mean")
+                ax_i.plot([], color=y_model_fill_kwargs["color"], label="Uncertainty in mean")
+                y_model_mean = np.mean(y_model_plotters, axis=0)
+                ax_i.plot(x_plotters, y_model_mean, **y_model_mean_kwargs, label="Mean")
 
         if legend:
             ax_i.legend(fontsize=xt_labelsize, loc="upper left")

arviz/plots/backends/matplotlib/pairplot.py

@@ -30,6 +30,8 @@ def plot_pair(
     diverging_mask,
     divergences_kwargs,
     flat_var_names,
+    flat_ref_slices,
+    flat_var_labels,
     backend_kwargs,
     marginal_kwargs,
     show,
@@ -77,24 +79,12 @@ def plot_pair(
         kde_kwargs["contour_kwargs"].setdefault("colors", "k")
 
     if reference_values:
-        reference_values_copy = {}
-        label = []
-        for variable in list(reference_values.keys()):
-            if " " in variable:
-                variable_copy = variable.replace(" ", "\n", 1)
-            else:
-                variable_copy = variable
-
-            label.append(variable_copy)
-            reference_values_copy[variable_copy] = reference_values[variable]
-
-        difference = set(flat_var_names).difference(set(label))
+        difference = set(flat_var_names).difference(set(reference_values.keys()))
 
         if difference:
-            warn = [diff.replace("\n", " ", 1) for diff in difference]
             warnings.warn(
                 "Argument reference_values does not include reference value for: {}".format(
-                    ", ".join(warn)
+                    ", ".join(difference)
                 ),
                 UserWarning,
             )
@@ -211,12 +201,12 @@ def plot_pair(
 
         if reference_values:
             ax.plot(
-                reference_values_copy[flat_var_names[0]],
-                reference_values_copy[flat_var_names[1]],
+                np.array(reference_values[flat_var_names[0]])[flat_ref_slices[0]],
+                np.array(reference_values[flat_var_names[1]])[flat_ref_slices[1]],
                 **reference_values_kwargs,
             )
-        ax.set_xlabel(f"{flat_var_names[0]}", fontsize=ax_labelsize, wrap=True)
-        ax.set_ylabel(f"{flat_var_names[1]}", fontsize=ax_labelsize, wrap=True)
+        ax.set_xlabel(f"{flat_var_labels[0]}", fontsize=ax_labelsize, wrap=True)
+        ax.set_ylabel(f"{flat_var_labels[1]}", fontsize=ax_labelsize, wrap=True)
         ax.tick_params(labelsize=xt_labelsize)
 
     else:
@@ -336,20 +326,22 @@ def plot_pair(
                         y_name = flat_var_names[j + not_marginals]
                         if (x_name not in difference) and (y_name not in difference):
                             ax[j, i].plot(
-                                reference_values_copy[x_name],
-                                reference_values_copy[y_name],
+                                np.array(reference_values[x_name])[flat_ref_slices[i]],
+                                np.array(reference_values[y_name])[
+                                    flat_ref_slices[j + not_marginals]
+                                ],
                                 **reference_values_kwargs,
                             )
 
                 if j != vars_to_plot - 1:
                     plt.setp(ax[j, i].get_xticklabels(), visible=False)
                 else:
-                    ax[j, i].set_xlabel(f"{flat_var_names[i]}", fontsize=ax_labelsize, wrap=True)
+                    ax[j, i].set_xlabel(f"{flat_var_labels[i]}", fontsize=ax_labelsize, wrap=True)
                 if i != 0:
                     plt.setp(ax[j, i].get_yticklabels(), visible=False)
                 else:
                     ax[j, i].set_ylabel(
-                        f"{flat_var_names[j + not_marginals]}",
+                        f"{flat_var_labels[j + not_marginals]}",
                         fontsize=ax_labelsize,
                         wrap=True,
                     )

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,

arviz/plots/bpvplot.py

@@ -16,6 +16,7 @@ def plot_bpv(
     bpv=True,
     plot_mean=True,
     reference="analytical",
+    smoothing=None,
     mse=False,
     n_ref=100,
     hdi_prob=0.94,
@@ -72,6 +73,9 @@ def plot_bpv(
     reference : {"analytical", "samples", None}, default "analytical"
         How to compute the distributions used as reference for ``kind=u_values``
         or ``kind=p_values``. Use `None` to not plot any reference.
+    smoothing : bool, optional
+        If True and the data has integer dtype, smooth the data before computing the p-values,
+        u-values or tstat. By default, True when `kind` is "u_value" and False otherwise.
     mse : bool, default False
         Show scaled mean square error between uniform distribution and marginal p_value
         distribution.
@@ -166,7 +170,8 @@ def plot_bpv(
     Notes
     -----
     Discrete data is smoothed before computing either p-values or u-values using the
-    function :func:`~arviz.smooth_data`
+    function :func:`~arviz.smooth_data` if the data is integer type
+    and the smoothing parameter is True.
 
     Examples
     --------
@@ -206,6 +211,9 @@ def plot_bpv(
     elif not 1 >= hdi_prob > 0:
         raise ValueError("The value of hdi_prob should be in the interval (0, 1]")
 
+    if smoothing is None:
+        smoothing = kind.lower() == "u_value"
+
     if data_pairs is None:
         data_pairs = {}
 
@@ -291,6 +299,7 @@ def plot_bpv(
         plot_ref_kwargs=plot_ref_kwargs,
         backend_kwargs=backend_kwargs,
         show=show,
+        smoothing=smoothing,
     )
 
     # TODO: Add backend kwargs

arviz/plots/hdiplot.py

@@ -136,6 +136,11 @@ def plot_hdi(
     x = np.asarray(x)
     x_shape = x.shape
 
+    if isinstance(x[0], str):
+        raise NotImplementedError(
+            "The `arviz.plot_hdi()` function does not support categorical data. "
+            "Consider using `arviz.plot_forest()`."
+        )
     if y is None and hdi_data is None:
         raise ValueError("One of {y, hdi_data} is required")
     if hdi_data is not None and y is not None:

arviz/plots/kdeplot.py

@@ -255,6 +255,10 @@ def plot_kde(
             "or plot_pair instead of plot_kde"
         )
 
+    if backend is None:
+        backend = rcParams["plot.backend"]
+    backend = backend.lower()
+
     if values2 is None:
         if bw == "default":
             bw = "taylor" if is_circular else "experimental"
@@ -346,10 +350,6 @@ def plot_kde(
         **kwargs,
     )
 
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
     # TODO: Add backend kwargs
     plot = get_plotting_function("plot_kde", "kdeplot", backend)
     ax = plot(**kde_plot_args)