arviz 0.16.1__py3-none-any.whl → 0.17.1__py3-none-any.whl

arviz/data/io_cmdstanpy.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
 """CmdStanPy-specific conversion code."""
 import logging
 import re
@@ -72,15 +73,26 @@ class CmdStanPyConverter:
 
         self.dtypes = dtypes
 
-        if hasattr(self.posterior, "metadata"):
+        if hasattr(self.posterior, "metadata") and hasattr(
+            self.posterior.metadata, "stan_vars_cols"
+        ):
+            if self.log_likelihood is True and "log_lik" in self.posterior.metadata.stan_vars_cols:
+                self.log_likelihood = ["log_lik"]
+        elif hasattr(self.posterior, "metadata") and hasattr(
+            self.posterior.metadata, "stan_vars_cols"
+        ):
             if self.log_likelihood is True and "log_lik" in self.posterior.metadata.stan_vars_cols:
                 self.log_likelihood = ["log_lik"]
         elif hasattr(self.posterior, "stan_vars_cols"):
             if self.log_likelihood is True and "log_lik" in self.posterior.stan_vars_cols:
                 self.log_likelihood = ["log_lik"]
+        elif hasattr(self.posterior, "metadata") and hasattr(self.posterior.metadata, "stan_vars"):
+            if self.log_likelihood is True and "log_lik" in self.posterior.metadata.stan_vars:
+                self.log_likelihood = ["log_lik"]
         elif (
             self.log_likelihood is True
             and self.posterior is not None
+            and hasattr(self.posterior, "column_names")
             and any(name.split("[")[0] == "log_lik" for name in self.posterior.column_names)
         ):
             self.log_likelihood = ["log_lik"]
@@ -95,11 +107,17 @@ class CmdStanPyConverter:
         """Extract posterior samples from output csv."""
         if not (hasattr(self.posterior, "metadata") or hasattr(self.posterior, "stan_vars_cols")):
             return self.posterior_to_xarray_pre_v_0_9_68()
+        if (
+            hasattr(self.posterior, "metadata")
+            and hasattr(self.posterior.metadata, "stan_vars_cols")
+        ) or hasattr(self.posterior, "stan_vars_cols"):
+            return self.posterior_to_xarray_pre_v_1_0_0()
+        if hasattr(self.posterior, "metadata") and hasattr(
+            self.posterior.metadata, "stan_vars_cols"
+        ):
+            return self.posterior_to_xarray_pre_v_1_2_0()
 
-        if hasattr(self.posterior, "metadata"):
-            items = list(self.posterior.metadata.stan_vars_cols.keys())
-        else:
-            items = list(self.posterior.stan_vars_cols.keys())
+        items = list(self.posterior.metadata.stan_vars)
         if self.posterior_predictive is not None:
             try:
                 items = _filter(items, self.posterior_predictive)
@@ -119,9 +137,8 @@ class CmdStanPyConverter:
         valid_cols = []
         for item in items:
             if hasattr(self.posterior, "metadata"):
-                valid_cols.extend(self.posterior.metadata.stan_vars_cols[item])
-            else:
-                valid_cols.extend(self.posterior.stan_vars_cols[item])
+                if item in self.posterior.metadata.stan_vars:
+                    valid_cols.append(item)
 
         data, data_warmup = _unpack_fit(
             self.posterior,
@@ -130,7 +147,6 @@ class CmdStanPyConverter:
             self.dtypes,
         )
 
-        # copy dims and coords  - Mitzi question:  why???
         dims = deepcopy(self.dims) if self.dims is not None else {}
         coords = deepcopy(self.coords) if self.coords is not None else {}
 
@@ -165,6 +181,12 @@ class CmdStanPyConverter:
         """Extract sample_stats from fit."""
         if not (hasattr(fit, "metadata") or hasattr(fit, "sampler_vars_cols")):
             return self.sample_stats_to_xarray_pre_v_0_9_68(fit)
+        if (hasattr(fit, "metadata") and hasattr(fit.metadata, "stan_vars_cols")) or hasattr(
+            fit, "stan_vars_cols"
+        ):
+            return self.sample_stats_to_xarray_pre_v_1_0_0(fit)
+        if hasattr(fit, "metadata") and hasattr(fit.metadata, "stan_vars_cols"):
+            return self.sample_stats_to_xarray_pre_v_1_2_0(fit)
 
         dtypes = {
             "divergent__": bool,
@@ -172,10 +194,9 @@ class CmdStanPyConverter:
             "treedepth__": np.int64,
             **self.dtypes,
         }
-        if hasattr(fit, "metadata"):
-            items = list(fit.metadata._method_vars_cols.keys())  # pylint: disable=protected-access
-        else:
-            items = list(fit.sampler_vars_cols.keys())
+
+        items = list(fit.method_variables())  # pylint: disable=protected-access
+
         rename_dict = {
             "divergent": "diverging",
             "n_leapfrog": "n_steps",
@@ -196,6 +217,7 @@ class CmdStanPyConverter:
             data[name] = data.pop(item).astype(dtypes.get(item, float))
             if data_warmup:
                 data_warmup[name] = data_warmup.pop(item).astype(dtypes.get(item, float))
+
         return (
             dict_to_dataset(
                 data,
@@ -229,19 +251,35 @@ class CmdStanPyConverter:
         """Convert predictive samples to xarray."""
         predictive = _as_set(names)
 
-        if hasattr(fit, "metadata") or hasattr(fit, "stan_vars_cols"):
-            data, data_warmup = _unpack_fit(
+        if not (hasattr(fit, "metadata") or hasattr(fit, "stan_vars_cols")):  # pre_v_0_9_68
+            valid_cols = _filter_columns(fit.column_names, predictive)
+            data, data_warmup = _unpack_frame(
+                fit,
+                fit.column_names,
+                valid_cols,
+                self.save_warmup,
+                self.dtypes,
+            )
+        elif (hasattr(fit, "metadata") and hasattr(fit.metadata, "sample_vars_cols")) or hasattr(
+            fit, "stan_vars_cols"
+        ):  # pre_v_1_0_0
+            data, data_warmup = _unpack_fit_pre_v_1_0_0(
                 fit,
                 predictive,
                 self.save_warmup,
                 self.dtypes,
             )
-        else:  # pre_v_0_9_68
-            valid_cols = _filter_columns(fit.column_names, predictive)
-            data, data_warmup = _unpack_frame(
+        elif hasattr(fit, "metadata") and hasattr(fit.metadata, "stan_vars_cols"):  # pre_v_1_2_0
+            data, data_warmup = _unpack_fit_pre_v_1_2_0(
                 fit,
-                fit.column_names,
-                valid_cols,
+                predictive,
+                self.save_warmup,
+                self.dtypes,
+            )
+        else:
+            data, data_warmup = _unpack_fit(
+                fit,
+                predictive,
                 self.save_warmup,
                 self.dtypes,
             )
@@ -269,14 +307,9 @@ class CmdStanPyConverter:
         """Convert out of sample predictions samples to xarray."""
         predictions = _as_set(self.predictions)
 
-        if hasattr(self.posterior, "metadata") or hasattr(self.posterior, "stan_vars_cols"):
-            data, data_warmup = _unpack_fit(
-                self.posterior,
-                predictions,
-                self.save_warmup,
-                self.dtypes,
-            )
-        else:  # pre_v_0_9_68
+        if not (
+            hasattr(self.posterior, "metadata") or hasattr(self.posterior, "stan_vars_cols")
+        ):  # pre_v_0_9_68
             columns = self.posterior.column_names
             valid_cols = _filter_columns(columns, predictions)
             data, data_warmup = _unpack_frame(
@@ -286,6 +319,34 @@ class CmdStanPyConverter:
                 self.save_warmup,
                 self.dtypes,
             )
+        elif (
+            hasattr(self.posterior, "metadata")
+            and hasattr(self.posterior.metadata, "sample_vars_cols")
+        ) or hasattr(
+            self.posterior, "stan_vars_cols"
+        ):  # pre_v_1_0_0
+            data, data_warmup = _unpack_fit_pre_v_1_0_0(
+                self.posterior,
+                predictions,
+                self.save_warmup,
+                self.dtypes,
+            )
+        elif hasattr(self.posterior, "metadata") and hasattr(
+            self.posterior.metadata, "stan_vars_cols"
+        ):  # pre_v_1_2_0
+            data, data_warmup = _unpack_fit_pre_v_1_2_0(
+                self.posterior,
+                predictions,
+                self.save_warmup,
+                self.dtypes,
+            )
+        else:
+            data, data_warmup = _unpack_fit(
+                self.posterior,
+                predictions,
+                self.save_warmup,
+                self.dtypes,
+            )
 
         return (
             dict_to_dataset(
@@ -310,14 +371,9 @@ class CmdStanPyConverter:
         """Convert elementwise log likelihood samples to xarray."""
         log_likelihood = _as_set(self.log_likelihood)
 
-        if hasattr(self.posterior, "metadata") or hasattr(self.posterior, "stan_vars_cols"):
-            data, data_warmup = _unpack_fit(
-                self.posterior,
-                log_likelihood,
-                self.save_warmup,
-                self.dtypes,
-            )
-        else:  # pre_v_0_9_68
+        if not (
+            hasattr(self.posterior, "metadata") or hasattr(self.posterior, "stan_vars_cols")
+        ):  # pre_v_0_9_68
             columns = self.posterior.column_names
             valid_cols = _filter_columns(columns, log_likelihood)
             data, data_warmup = _unpack_frame(
@@ -327,6 +383,35 @@ class CmdStanPyConverter:
                 self.save_warmup,
                 self.dtypes,
             )
+        elif (
+            hasattr(self.posterior, "metadata")
+            and hasattr(self.posterior.metadata, "sample_vars_cols")
+        ) or hasattr(
+            self.posterior, "stan_vars_cols"
+        ):  # pre_v_1_0_0
+            data, data_warmup = _unpack_fit_pre_v_1_0_0(
+                self.posterior,
+                log_likelihood,
+                self.save_warmup,
+                self.dtypes,
+            )
+        elif hasattr(self.posterior, "metadata") and hasattr(
+            self.posterior.metadata, "stan_vars_cols"
+        ):  # pre_v_1_2_0
+            data, data_warmup = _unpack_fit_pre_v_1_2_0(
+                self.posterior,
+                log_likelihood,
+                self.save_warmup,
+                self.dtypes,
+            )
+        else:
+            data, data_warmup = _unpack_fit(
+                self.posterior,
+                log_likelihood,
+                self.save_warmup,
+                self.dtypes,
+            )
+
         if isinstance(self.log_likelihood, dict):
             data = {obs_name: data[lik_name] for obs_name, lik_name in self.log_likelihood.items()}
             if data_warmup:
@@ -356,8 +441,29 @@ class CmdStanPyConverter:
     @requires("prior")
     def prior_to_xarray(self):
         """Convert prior samples to xarray."""
-        if hasattr(self.posterior, "metadata") or hasattr(self.prior, "stan_vars_cols"):
-            if hasattr(self.posterior, "metadata"):
+        if not (
+            hasattr(self.prior, "metadata") or hasattr(self.prior, "stan_vars_cols")
+        ):  # pre_v_0_9_68
+            columns = self.prior.column_names
+            prior_predictive = _as_set(self.prior_predictive)
+            prior_predictive = _filter_columns(columns, prior_predictive)
+
+            invalid_cols = set(prior_predictive + [col for col in columns if col.endswith("__")])
+            valid_cols = [col for col in columns if col not in invalid_cols]
+
+            data, data_warmup = _unpack_frame(
+                self.prior,
+                columns,
+                valid_cols,
+                self.save_warmup,
+                self.dtypes,
+            )
+        elif (
+            hasattr(self.prior, "metadata") and hasattr(self.prior.metadata, "sample_vars_cols")
+        ) or hasattr(
+            self.prior, "stan_vars_cols"
+        ):  # pre_v_1_0_0
+            if hasattr(self.prior, "metadata"):
                 items = list(self.prior.metadata.stan_vars_cols.keys())
             else:
                 items = list(self.prior.stan_vars_cols.keys())
@@ -366,24 +472,37 @@ class CmdStanPyConverter:
                     items = _filter(items, self.prior_predictive)
                 except ValueError:
                     pass
-            data, data_warmup = _unpack_fit(
+            data, data_warmup = _unpack_fit_pre_v_1_0_0(
                 self.prior,
                 items,
                 self.save_warmup,
                 self.dtypes,
             )
-        else:  # pre_v_0_9_68
-            columns = self.prior.column_names
-            prior_predictive = _as_set(self.prior_predictive)
-            prior_predictive = _filter_columns(columns, prior_predictive)
-
-            invalid_cols = set(prior_predictive + [col for col in columns if col.endswith("__")])
-            valid_cols = [col for col in columns if col not in invalid_cols]
-
-            data, data_warmup = _unpack_frame(
+        elif hasattr(self.prior, "metadata") and hasattr(
+            self.prior.metadata, "stan_vars_cols"
+        ):  # pre_v_1_2_0
+            items = list(self.prior.metadata.stan_vars_cols.keys())
+            if self.prior_predictive is not None:
+                try:
+                    items = _filter(items, self.prior_predictive)
+                except ValueError:
+                    pass
+            data, data_warmup = _unpack_fit_pre_v_1_2_0(
                 self.prior,
-                columns,
-                valid_cols,
+                items,
+                self.save_warmup,
+                self.dtypes,
+            )
+        else:
+            items = list(self.prior.metadata.stan_vars.keys())
+            if self.prior_predictive is not None:
+                try:
+                    items = _filter(items, self.prior_predictive)
+                except ValueError:
+                    pass
+            data, data_warmup = _unpack_fit(
+                self.prior,
+                items,
                 self.save_warmup,
                 self.dtypes,
             )
@@ -466,6 +585,113 @@ class CmdStanPyConverter:
             },
         )
 
+    def posterior_to_xarray_pre_v_1_2_0(self):
+        items = list(self.posterior.metadata.stan_vars_cols)
+        if self.posterior_predictive is not None:
+            try:
+                items = _filter(items, self.posterior_predictive)
+            except ValueError:
+                pass
+        if self.predictions is not None:
+            try:
+                items = _filter(items, self.predictions)
+            except ValueError:
+                pass
+        if self.log_likelihood is not None:
+            try:
+                items = _filter(items, self.log_likelihood)
+            except ValueError:
+                pass
+
+        valid_cols = []
+        for item in items:
+            if hasattr(self.posterior, "metadata"):
+                if item in self.posterior.metadata.stan_vars_cols:
+                    valid_cols.append(item)
+
+        data, data_warmup = _unpack_fit_pre_v_1_2_0(
+            self.posterior,
+            items,
+            self.save_warmup,
+            self.dtypes,
+        )
+
+        dims = deepcopy(self.dims) if self.dims is not None else {}
+        coords = deepcopy(self.coords) if self.coords is not None else {}
+
+        return (
+            dict_to_dataset(
+                data,
+                library=self.cmdstanpy,
+                coords=coords,
+                dims=dims,
+                index_origin=self.index_origin,
+            ),
+            dict_to_dataset(
+                data_warmup,
+                library=self.cmdstanpy,
+                coords=coords,
+                dims=dims,
+                index_origin=self.index_origin,
+            ),
+        )
+
+    @requires("posterior")
+    def posterior_to_xarray_pre_v_1_0_0(self):
+        if hasattr(self.posterior, "metadata"):
+            items = list(self.posterior.metadata.stan_vars_cols.keys())
+        else:
+            items = list(self.posterior.stan_vars_cols.keys())
+        if self.posterior_predictive is not None:
+            try:
+                items = _filter(items, self.posterior_predictive)
+            except ValueError:
+                pass
+        if self.predictions is not None:
+            try:
+                items = _filter(items, self.predictions)
+            except ValueError:
+                pass
+        if self.log_likelihood is not None:
+            try:
+                items = _filter(items, self.log_likelihood)
+            except ValueError:
+                pass
+
+        valid_cols = []
+        for item in items:
+            if hasattr(self.posterior, "metadata"):
+                valid_cols.extend(self.posterior.metadata.stan_vars_cols[item])
+            else:
+                valid_cols.extend(self.posterior.stan_vars_cols[item])
+
+        data, data_warmup = _unpack_fit_pre_v_1_0_0(
+            self.posterior,
+            items,
+            self.save_warmup,
+            self.dtypes,
+        )
+
+        dims = deepcopy(self.dims) if self.dims is not None else {}
+        coords = deepcopy(self.coords) if self.coords is not None else {}
+
+        return (
+            dict_to_dataset(
+                data,
+                library=self.cmdstanpy,
+                coords=coords,
+                dims=dims,
+                index_origin=self.index_origin,
+            ),
+            dict_to_dataset(
+                data_warmup,
+                library=self.cmdstanpy,
+                coords=coords,
+                dims=dims,
+                index_origin=self.index_origin,
+            ),
+        )
+
     @requires("posterior")
     def posterior_to_xarray_pre_v_0_9_68(self):
         """Extract posterior samples from output csv."""
@@ -544,6 +770,103 @@ class CmdStanPyConverter:
             ),
         )
 
+    def sample_stats_to_xarray_pre_v_1_2_0(self, fit):
+        dtypes = {
+            "divergent__": bool,
+            "n_leapfrog__": np.int64,
+            "treedepth__": np.int64,
+            **self.dtypes,
+        }
+
+        items = list(fit.metadata.method_vars_cols.keys())  # pylint: disable=protected-access
+
+        rename_dict = {
+            "divergent": "diverging",
+            "n_leapfrog": "n_steps",
+            "treedepth": "tree_depth",
+            "stepsize": "step_size",
+            "accept_stat": "acceptance_rate",
+        }
+
+        data, data_warmup = _unpack_fit_pre_v_1_2_0(
+            fit,
+            items,
+            self.save_warmup,
+            self.dtypes,
+        )
+        for item in items:
+            name = re.sub("__$", "", item)
+            name = rename_dict.get(name, name)
+            data[name] = data.pop(item).astype(dtypes.get(item, float))
+            if data_warmup:
+                data_warmup[name] = data_warmup.pop(item).astype(dtypes.get(item, float))
+
+        return (
+            dict_to_dataset(
+                data,
+                library=self.cmdstanpy,
+                coords=self.coords,
+                dims=self.dims,
+                index_origin=self.index_origin,
+            ),
+            dict_to_dataset(
+                data_warmup,
+                library=self.cmdstanpy,
+                coords=self.coords,
+                dims=self.dims,
+                index_origin=self.index_origin,
+            ),
+        )
+
+    def sample_stats_to_xarray_pre_v_1_0_0(self, fit):
+        """Extract sample_stats from fit."""
+        dtypes = {
+            "divergent__": bool,
+            "n_leapfrog__": np.int64,
+            "treedepth__": np.int64,
+            **self.dtypes,
+        }
+        if hasattr(fit, "metadata"):
+            items = list(fit.metadata._method_vars_cols.keys())  # pylint: disable=protected-access
+        else:
+            items = list(fit.sampler_vars_cols.keys())
+        rename_dict = {
+            "divergent": "diverging",
+            "n_leapfrog": "n_steps",
+            "treedepth": "tree_depth",
+            "stepsize": "step_size",
+            "accept_stat": "acceptance_rate",
+        }
+
+        data, data_warmup = _unpack_fit_pre_v_1_0_0(
+            fit,
+            items,
+            self.save_warmup,
+            self.dtypes,
+        )
+        for item in items:
+            name = re.sub("__$", "", item)
+            name = rename_dict.get(name, name)
+            data[name] = data.pop(item).astype(dtypes.get(item, float))
+            if data_warmup:
+                data_warmup[name] = data_warmup.pop(item).astype(dtypes.get(item, float))
+        return (
+            dict_to_dataset(
+                data,
+                library=self.cmdstanpy,
+                coords=self.coords,
+                dims=self.dims,
+                index_origin=self.index_origin,
+            ),
+            dict_to_dataset(
+                data_warmup,
+                library=self.cmdstanpy,
+                coords=self.coords,
+                dims=self.dims,
+                index_origin=self.index_origin,
+            ),
+        )
+
     def sample_stats_to_xarray_pre_v_0_9_68(self, fit):
         """Extract sample_stats from fit."""
         dtypes = {"divergent__": bool, "n_leapfrog__": np.int64, "treedepth__": np.int64}
@@ -612,6 +935,72 @@ def _filter_columns(columns, spec):
 
 
 def _unpack_fit(fit, items, save_warmup, dtypes):
+    num_warmup = 0
+    if save_warmup:
+        if not fit._save_warmup:  # pylint: disable=protected-access
+            save_warmup = False
+        else:
+            num_warmup = fit.num_draws_warmup
+
+    nchains = fit.chains
+    sample = {}
+    sample_warmup = {}
+    stan_vars_cols = list(fit.metadata.stan_vars)
+    sampler_vars = fit.method_variables()
+    for item in items:
+        if item in stan_vars_cols:
+            raw_draws = fit.stan_variable(item, inc_warmup=save_warmup)
+            raw_draws = np.swapaxes(
+                raw_draws.reshape((-1, nchains, *raw_draws.shape[1:]), order="F"), 0, 1
+            )
+        elif item in sampler_vars:
+            raw_draws = np.swapaxes(sampler_vars[item], 0, 1)
+        else:
+            raise ValueError(f"fit data, unknown variable: {item}")
+        raw_draws = raw_draws.astype(dtypes.get(item))
+        if save_warmup:
+            sample_warmup[item] = raw_draws[:, :num_warmup, ...]
+            sample[item] = raw_draws[:, num_warmup:, ...]
+        else:
+            sample[item] = raw_draws
+
+    return sample, sample_warmup
+
+
+def _unpack_fit_pre_v_1_2_0(fit, items, save_warmup, dtypes):
+    num_warmup = 0
+    if save_warmup:
+        if not fit._save_warmup:  # pylint: disable=protected-access
+            save_warmup = False
+        else:
+            num_warmup = fit.num_draws_warmup
+
+    nchains = fit.chains
+    sample = {}
+    sample_warmup = {}
+    stan_vars_cols = list(fit.metadata.stan_vars_cols)
+    sampler_vars = fit.method_variables()
+    for item in items:
+        if item in stan_vars_cols:
+            raw_draws = fit.stan_variable(item, inc_warmup=save_warmup)
+            raw_draws = np.swapaxes(
+                raw_draws.reshape((-1, nchains, *raw_draws.shape[1:]), order="F"), 0, 1
+            )
+        elif item in sampler_vars:
+            raw_draws = np.swapaxes(sampler_vars[item], 0, 1)
+        else:
+            raise ValueError(f"fit data, unknown variable: {item}")
+        raw_draws = raw_draws.astype(dtypes.get(item))
+        if save_warmup:
+            sample_warmup[item] = raw_draws[:, :num_warmup, ...]
+            sample[item] = raw_draws[:, num_warmup:, ...]
+        else:
+            sample[item] = raw_draws
+
+    return sample, sample_warmup
+
+
+def _unpack_fit_pre_v_1_0_0(fit, items, save_warmup, dtypes):
     """Transform fit to dictionary containing ndarrays.
 
     Parameters

arviz/data/io_pyjags.py

@@ -52,7 +52,7 @@ class PyJAGSConverter:
         self.save_warmup = rcParams["data.save_warmup"] if save_warmup is None else save_warmup
         self.warmup_iterations = warmup_iterations
 
-        import pyjags
+        import pyjags  # pylint: disable=import-error
 
         self.pyjags = pyjags
 
@@ -149,7 +149,10 @@ def get_draws(
     variables = tuple(variables)
 
     if warmup_iterations > 0:
-        (warmup_samples, actual_samples,) = _split_pyjags_dict_in_warmup_and_actual_samples(
+        (
+            warmup_samples,
+            actual_samples,
+        ) = _split_pyjags_dict_in_warmup_and_actual_samples(
             pyjags_samples=pyjags_samples,
             warmup_iterations=warmup_iterations,
             variable_names=variables,

arviz/data/io_pystan.py

@@ -676,8 +676,7 @@ def get_draws(fit, variables=None, ignore=None, warmup=False, dtypes=None):
         for item in par_keys:
             _, shape = item.replace("]", "").split("[")
             shape_idx_min = min(int(shape_value) for shape_value in shape.split(","))
-            if shape_idx_min < shift:
-                shift = shape_idx_min
+            shift = min(shift, shape_idx_min)
         # If shift is higher than 1, this will probably mean that Stan
         # has implemented sparse structure (saves only non-zero parts),
         # but let's hope that dims are still corresponding to the full shape

arviz/labels.py

@@ -100,6 +100,8 @@ class BaseLabeller:
         """WIP."""
         var_name_str = self.var_name_to_str(var_name)
         pp_var_name_str = self.var_name_to_str(pp_var_name)
+        if var_name_str == pp_var_name_str:
+            return f"{var_name_str}"
         return f"{var_name_str} / {pp_var_name_str}"
 
     def model_name_to_str(self, model_name):

arviz/plots/backends/bokeh/bpvplot.py

@@ -171,8 +171,13 @@ def plot_bpv(
                 ax_i.line(0, 0, legend_label=f"bpv={p_value:.2f}", alpha=0)
 
             if plot_mean:
-                ax_i.circle(
-                    obs_vals.mean(), 0, fill_color=color, line_color="black", size=markersize
+                ax_i.scatter(
+                    obs_vals.mean(),
+                    0,
+                    fill_color=color,
+                    line_color="black",
+                    size=markersize,
+                    marker="circle",
                 )
 
         _title = Title()