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

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/compareplot.py

@@ -11,9 +11,9 @@ def plot_compare(
     comp_df,
     insample_dev=False,
     plot_standard_error=True,
-    plot_ic_diff=True,
+    plot_ic_diff=False,
     order_by_rank=True,
-    legend=True,
+    legend=False,
     title=True,
     figsize=None,
     textsize=None,
@@ -45,12 +45,12 @@ def plot_compare(
         penalization given by the effective number of parameters (p_loo or p_waic).
     plot_standard_error : bool, default True
         Plot the standard error of the ELPD.
-    plot_ic_diff : bool, default True
+    plot_ic_diff : bool, default False
         Plot standard error of the difference in ELPD between each model
         and the top-ranked model.
     order_by_rank : bool, default True
         If True ensure the best model is used as reference.
-    legend : bool, default True
+    legend : bool, default False
         Add legend to figure.
     figsize : (float, float), optional
         If `None`, size is (6, num of models) inches.

arviz/plots/ecdfplot.py

@@ -73,6 +73,7 @@ def plot_ecdf(
         - False: No confidence bands are plotted (default).
         - True: Plot bands computed with the default algorithm (subject to change)
         - "pointwise": Compute the pointwise (i.e. marginal) confidence band.
+        - "optimized": Use optimization to estimate a simultaneous confidence band.
         - "simulated": Use Monte Carlo simulation to estimate a simultaneous confidence
           band.
 
@@ -216,8 +217,7 @@ def plot_ecdf(
         >>> pit_vals = distribution.cdf(sample)
         >>> uniform_dist = uniform(0, 1)
         >>> az.plot_ecdf(
-        >>>     pit_vals, cdf=uniform_dist.cdf,
-        >>>     rvs=uniform_dist.rvs, confidence_bands=True
+        >>>     pit_vals, cdf=uniform_dist.cdf, confidence_bands=True,
         >>> )
 
     Plot an ECDF-difference plot of PIT values.
@@ -226,8 +226,8 @@ def plot_ecdf(
         :context: close-figs
 
         >>> az.plot_ecdf(
-        >>>     pit_vals, cdf = uniform_dist.cdf, rvs = uniform_dist.rvs,
-        >>>     confidence_bands = True, difference = True
+        >>>     pit_vals, cdf = uniform_dist.cdf, confidence_bands = True,
+        >>>     difference = True
         >>> )
     """
     if confidence_bands is True:
@@ -238,9 +238,12 @@ def plot_ecdf(
             )
             confidence_bands = "pointwise"
         else:
-            confidence_bands = "simulated"
-    elif confidence_bands == "simulated" and pointwise:
-        raise ValueError("Cannot specify both `confidence_bands='simulated'` and `pointwise=True`")
+            confidence_bands = "auto"
+        # if pointwise specified, confidence_bands must be a bool or 'pointwise'
+    elif confidence_bands not in [False, "pointwise"] and pointwise:
+        raise ValueError(
+            f"Cannot specify both `confidence_bands='{confidence_bands}'` and `pointwise=True`"
+        )
 
     if fpr is not None:
         warnings.warn(
@@ -298,7 +301,7 @@ def plot_ecdf(
             "`eval_points` explicitly.",
             BehaviourChangeWarning,
         )
-        if confidence_bands == "simulated":
+        if confidence_bands in ["optimized", "simulated"]:
             warnings.warn(
                 "For simultaneous bands to be correctly calibrated, specify `eval_points` "
                 "independent of the `values`"
@@ -319,6 +322,11 @@ def plot_ecdf(
 
     if confidence_bands:
         ndraws = len(values)
+        if confidence_bands == "auto":
+            if ndraws < 200 or num_trials >= 250 * np.sqrt(ndraws):
+                confidence_bands = "optimized"
+            else:
+                confidence_bands = "simulated"
         x_bands = eval_points
         lower, higher = ecdf_confidence_band(
             ndraws,

arviz/plots/forestplot.py

@@ -55,8 +55,8 @@ def plot_forest(
         Specify the kind of plot:
 
         * The ``kind="forestplot"`` generates credible intervals, where the central points are the
-          estimated posterior means, the thick lines are the central quartiles, and the thin lines
-          represent the :math:`100\times`(`hdi_prob`)% highest density intervals.
+          estimated posterior median, the thick lines are the central quartiles, and the thin lines
+          represent the :math:`100\times(hdi\_prob)\%` highest density intervals.
         * The ``kind="ridgeplot"`` option generates density plots (kernel density estimate or
           histograms) in the same graph. Ridge plots can be configured to have different overlap,
           truncation bounds and quantile markers.

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

@@ -72,7 +72,7 @@ def plot_kde(
         If True plot the 2D KDE using contours, otherwise plot a smooth 2D KDE.
     hdi_probs : list, optional
         Plots highest density credibility regions for the provided probabilities for a 2D KDE.
-        Defaults to matplotlib chosen levels with no fixed probability associated.
+        Defaults to [0.5, 0.8, 0.94].
     fill_last : bool, default False
         If True fill the last contour of the 2D KDE plot.
     figsize : (float, float), optional
@@ -270,6 +270,9 @@ def plot_kde(
         gridsize = (128, 128) if contour else (256, 256)
         density, xmin, xmax, ymin, ymax = _fast_kde_2d(values, values2, gridsize=gridsize)
 
+        if hdi_probs is None:
+            hdi_probs = [0.5, 0.8, 0.94]
+
         if hdi_probs is not None:
             # Check hdi probs are within bounds (0, 1)
             if min(hdi_probs) <= 0 or max(hdi_probs) >= 1:
@@ -289,7 +292,11 @@ def plot_kde(
                     "Using 'hdi_probs' in favor of 'levels'.",
                     UserWarning,
                 )
-            contour_kwargs["levels"] = contour_level_list
+
+            if backend == "bokeh":
+                contour_kwargs["levels"] = contour_level_list
+            elif backend == "matplotlib":
+                contour_kwargs["levels"] = contour_level_list[1:]
 
             contourf_kwargs = _init_kwargs_dict(contourf_kwargs)
             if "levels" in contourf_kwargs:

arviz/plots/plot_utils.py

@@ -482,16 +482,18 @@ def plot_point_interval(
         if point_estimate:
             point_value = calculate_point_estimate(point_estimate, values)
             if rotated:
-                ax.circle(
+                ax.scatter(
                     x=0,
                     y=point_value,
+                    marker="circle",
                     size=markersize,
                     fill_color=markercolor,
                 )
             else:
-                ax.circle(
+                ax.scatter(
                     x=point_value,
                     y=0,
+                    marker="circle",
                     size=markersize,
                     fill_color=markercolor,
                 )
@@ -534,7 +536,7 @@ def set_bokeh_circular_ticks_labels(ax, hist, labels):
     )
 
     radii_circles = np.linspace(0, np.max(hist) * 1.1, 4)
-    ax.circle(0, 0, radius=radii_circles, fill_color=None, line_color="grey")
+    ax.scatter(0, 0, marker="circle", radius=radii_circles, fill_color=None, line_color="grey")
 
     offset = np.max(hist * 1.05) * 0.15
     ticks_labels_pos_1 = np.max(hist * 1.05)

arviz/preview.py

@@ -1,17 +1,48 @@
-# pylint: disable=unused-import,unused-wildcard-import,wildcard-import
+# pylint: disable=unused-import,unused-wildcard-import,wildcard-import,invalid-name
 """Expose features from arviz-xyz refactored packages inside ``arviz.preview`` namespace."""
+import logging
+
+_log = logging.getLogger(__name__)
+
+info = ""
 
 try:
     from arviz_base import *
+
+    status = "arviz_base available, exposing its functions as part of arviz.preview"
+    _log.info(status)
 except ModuleNotFoundError:
-    pass
+    status = "arviz_base not installed"
+    _log.info(status)
+except ImportError:
+    status = "Unable to import arviz_base"
+    _log.info(status, exc_info=True)
+
+info += status + "\n"
 
 try:
-    import arviz_stats
+    from arviz_stats import *
+
+    status = "arviz_stats available, exposing its functions as part of arviz.preview"
+    _log.info(status)
 except ModuleNotFoundError:
-    pass
+    status = "arviz_stats not installed"
+    _log.info(status)
+except ImportError:
+    status = "Unable to import arviz_stats"
+    _log.info(status, exc_info=True)
+info += status + "\n"
 
 try:
     from arviz_plots import *
+
+    status = "arviz_plots available, exposing its functions as part of arviz.preview"
+    _log.info(status)
 except ModuleNotFoundError:
-    pass
+    status = "arviz_plots not installed"
+    _log.info(status)
+except ImportError:
+    status = "Unable to import arviz_plots"
+    _log.info(status, exc_info=True)
+
+info += status + "\n"

arviz/stats/__init__.py

@@ -9,6 +9,7 @@ from .stats_utils import *
 
 __all__ = [
     "apply_test_function",
+    "bayes_factor",
     "bfmi",
     "compare",
     "hdi",

arviz/stats/diagnostics.py

@@ -744,8 +744,8 @@ def _ess_sd(ary, relative=False):
     ary = np.asarray(ary)
     if _not_valid(ary, shape_kwargs=dict(min_draws=4, min_chains=1)):
         return np.nan
-    ary = _split_chains(ary)
-    return min(_ess(ary, relative=relative), _ess(ary**2, relative=relative))
+    ary = (ary - ary.mean()) ** 2
+    return _ess(_split_chains(ary), relative=relative)
 
 
 def _ess_quantile(ary, prob, relative=False):
@@ -838,13 +838,15 @@ def _mcse_sd(ary):
     ary = np.asarray(ary)
     if _not_valid(ary, shape_kwargs=dict(min_draws=4, min_chains=1)):
         return np.nan
-    ess = _ess_sd(ary)
+    sims_c2 = (ary - ary.mean()) ** 2
+    ess = _ess_mean(sims_c2)
+    evar = (sims_c2).mean()
+    varvar = ((sims_c2**2).mean() - evar**2) / ess
+    varsd = varvar / evar / 4
     if _numba_flag:
-        sd = float(_sqrt(svar(np.ravel(ary), ddof=1), np.zeros(1)).item())
+        mcse_sd_value = float(_sqrt(np.ravel(varsd), np.zeros(1)))
     else:
-        sd = np.std(ary, ddof=1)
-    fac_mcse_sd = np.sqrt(np.exp(1) * (1 - 1 / ess) ** (ess - 1) - 1)
-    mcse_sd_value = sd * fac_mcse_sd
+        mcse_sd_value = np.sqrt(varsd)
     return mcse_sd_value
 
 
@@ -973,19 +975,21 @@ def _multichain_statistics(ary, focus="mean"):
         # ess mean
         ess_mean_value = _ess_mean(ary)
 
-        # ess sd
-        ess_sd_value = _ess_sd(ary)
-
         # mcse_mean
-        sd = np.std(ary, ddof=1)
-        mcse_mean_value = sd / np.sqrt(ess_mean_value)
+        sims_c2 = (ary - ary.mean()) ** 2
+        sims_c2_sum = sims_c2.sum()
+        var = sims_c2_sum / (sims_c2.size - 1)
+        mcse_mean_value = np.sqrt(var / ess_mean_value)
 
         # ess bulk
         ess_bulk_value = _ess(z_split)
 
         # mcse_sd
-        fac_mcse_sd = np.sqrt(np.exp(1) * (1 - 1 / ess_sd_value) ** (ess_sd_value - 1) - 1)
-        mcse_sd_value = sd * fac_mcse_sd
+        evar = sims_c2_sum / sims_c2.size
+        ess_mean_sims = _ess_mean(sims_c2)
+        varvar = ((sims_c2**2).mean() - evar**2) / ess_mean_sims
+        varsd = varvar / evar / 4
+        mcse_sd_value = np.sqrt(varsd)
 
         return (
             mcse_mean_value,

arviz/stats/ecdf_utils.py

@@ -1,10 +1,25 @@
 """Functions for evaluating ECDFs and their confidence bands."""
 
+import math
 from typing import Any, Callable, Optional, Tuple
 import warnings
 
 import numpy as np
 from scipy.stats import uniform, binom
+from scipy.optimize import minimize_scalar
+
+try:
+    from numba import jit, vectorize
+except ImportError:
+
+    def jit(*args, **kwargs):  # pylint: disable=unused-argument
+        return lambda f: f
+
+    def vectorize(*args, **kwargs):  # pylint: disable=unused-argument
+        return lambda f: f
+
+
+from ..utils import Numba
 
 
 def compute_ecdf(sample: np.ndarray, eval_points: np.ndarray) -> np.ndarray:
@@ -73,7 +88,7 @@ def ecdf_confidence_band(
     eval_points: np.ndarray,
     cdf_at_eval_points: np.ndarray,
     prob: float = 0.95,
-    method="simulated",
+    method="optimized",
     **kwargs,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Compute the `prob`-level confidence band for the ECDF.
@@ -92,6 +107,7 @@ def ecdf_confidence_band(
     method : string, default "simulated"
         The method used to compute the confidence band. Valid options are:
         - "pointwise": Compute the pointwise (i.e. marginal) confidence band.
+        - "optimized": Use optimization to estimate a simultaneous confidence band.
         - "simulated": Use Monte Carlo simulation to estimate a simultaneous confidence band.
           `rvs` must be provided.
     rvs: callable, optional
@@ -115,12 +131,18 @@ def ecdf_confidence_band(
 
     if method == "pointwise":
         prob_pointwise = prob
+    elif method == "optimized":
+        prob_pointwise = _optimize_simultaneous_ecdf_band_probability(
+            ndraws, eval_points, cdf_at_eval_points, prob=prob, **kwargs
+        )
     elif method == "simulated":
         prob_pointwise = _simulate_simultaneous_ecdf_band_probability(
             ndraws, eval_points, cdf_at_eval_points, prob=prob, **kwargs
         )
     else:
-        raise ValueError(f"Unknown method {method}. Valid options are 'pointwise' or 'simulated'.")
+        raise ValueError(
+            f"Unknown method {method}. Valid options are 'pointwise', 'optimized', or 'simulated'."
+        )
 
     prob_lower, prob_upper = _get_pointwise_confidence_band(
         prob_pointwise, ndraws, cdf_at_eval_points
@@ -129,6 +151,139 @@ def ecdf_confidence_band(
     return prob_lower, prob_upper
 
 
+def _update_ecdf_band_interior_probabilities(
+    prob_left: np.ndarray,
+    interval_left: np.ndarray,
+    interval_right: np.ndarray,
+    p: float,
+    ndraws: int,
+) -> np.ndarray:
+    """Update the probability that an ECDF has been within the envelope including at the current
+    point.
+
+    Arguments
+    ---------
+    prob_left : np.ndarray
+        For each point in the interior at the previous point, the joint probability that it and all
+        points before are in the interior.
+    interval_left : np.ndarray
+        The set of points in the interior at the previous point.
+    interval_right : np.ndarray
+        The set of points in the interior at the current point.
+    p : float
+        The probability of any given point found between the previous point and the current one.
+    ndraws : int
+        Number of draws in the original dataset.
+
+    Returns
+    -------
+    prob_right : np.ndarray
+        For each point in the interior at the current point, the joint probability that it and all
+        previous points are in the interior.
+    """
+    interval_left = interval_left[:, np.newaxis]
+    prob_conditional = binom.pmf(interval_right, ndraws - interval_left, p, loc=interval_left)
+    prob_right = prob_left.dot(prob_conditional)
+    return prob_right
+
+
+@vectorize(["float64(int64, int64, float64, int64)"])
+def _binom_pmf(k, n, p, loc):
+    k -= loc
+    if k < 0 or k > n:
+        return 0.0
+    if p == 0:
+        return 1.0 if k == 0 else 0.0
+    if p == 1:
+        return 1.0 if k == n else 0.0
+    if k == 0:
+        return (1 - p) ** n
+    if k == n:
+        return p**n
+    lbinom = math.lgamma(n + 1) - math.lgamma(k + 1) - math.lgamma(n - k + 1)
+    return np.exp(lbinom + k * np.log(p) + (n - k) * np.log1p(-p))
+
+
+@jit(nopython=True)
+def _update_ecdf_band_interior_probabilities_numba(
+    prob_left: np.ndarray,
+    interval_left: np.ndarray,
+    interval_right: np.ndarray,
+    p: float,
+    ndraws: int,
+) -> np.ndarray:
+    interval_left = interval_left[:, np.newaxis]
+    prob_conditional = _binom_pmf(interval_right, ndraws - interval_left, p, interval_left)
+    prob_right = prob_left.dot(prob_conditional)
+    return prob_right
+
+
+def _ecdf_band_interior_probability(prob_between_points, ndraws, lower_count, upper_count):
+    interval_left = np.arange(1)
+    prob_interior = np.ones(1)
+    for i in range(prob_between_points.shape[0]):
+        interval_right = np.arange(lower_count[i], upper_count[i])
+        prob_interior = _update_ecdf_band_interior_probabilities(
+            prob_interior, interval_left, interval_right, prob_between_points[i], ndraws
+        )
+        interval_left = interval_right
+    return prob_interior.sum()
+
+
+@jit(nopython=True)
+def _ecdf_band_interior_probability_numba(prob_between_points, ndraws, lower_count, upper_count):
+    interval_left = np.arange(1)
+    prob_interior = np.ones(1)
+    for i in range(prob_between_points.shape[0]):
+        interval_right = np.arange(lower_count[i], upper_count[i])
+        prob_interior = _update_ecdf_band_interior_probabilities_numba(
+            prob_interior, interval_left, interval_right, prob_between_points[i], ndraws
+        )
+        interval_left = interval_right
+    return prob_interior.sum()
+
+
+def _ecdf_band_optimization_objective(
+    prob_pointwise: float,
+    cdf_at_eval_points: np.ndarray,
+    ndraws: int,
+    prob_target: float,
+) -> float:
+    """Objective function for optimizing the simultaneous confidence band probability."""
+    lower, upper = _get_pointwise_confidence_band(prob_pointwise, ndraws, cdf_at_eval_points)
+    lower_count = (lower * ndraws).astype(int)
+    upper_count = (upper * ndraws).astype(int) + 1
+    cdf_with_zero = np.insert(cdf_at_eval_points[:-1], 0, 0)
+    prob_between_points = (cdf_at_eval_points - cdf_with_zero) / (1 - cdf_with_zero)
+    if Numba.numba_flag:
+        prob_interior = _ecdf_band_interior_probability_numba(
+            prob_between_points, ndraws, lower_count, upper_count
+        )
+    else:
+        prob_interior = _ecdf_band_interior_probability(
+            prob_between_points, ndraws, lower_count, upper_count
+        )
+    return abs(prob_interior - prob_target)
+
+
+def _optimize_simultaneous_ecdf_band_probability(
+    ndraws: int,
+    eval_points: np.ndarray,  # pylint: disable=unused-argument
+    cdf_at_eval_points: np.ndarray,
+    prob: float = 0.95,
+    **kwargs,  # pylint: disable=unused-argument
+):
+    """Estimate probability for simultaneous confidence band using optimization.
+
+    This function simulates the pointwise probability needed to construct pointwise confidence bands
+    that form a `prob`-level confidence envelope for the ECDF of a sample.
+    """
+    cdf_at_eval_points = np.unique(cdf_at_eval_points)
+    objective = lambda p: _ecdf_band_optimization_objective(p, cdf_at_eval_points, ndraws, prob)
+    prob_pointwise = minimize_scalar(objective, bounds=(prob, 1), method="bounded").x
+    return prob_pointwise
+
+
 def _simulate_simultaneous_ecdf_band_probability(
     ndraws: int,
     eval_points: np.ndarray,