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

arviz/stats/ecdf_utils.py

@@ -0,0 +1,165 @@
+"""Functions for evaluating ECDFs and their confidence bands."""
+from typing import Any, Callable, Optional, Tuple
+import warnings
+
+import numpy as np
+from scipy.stats import uniform, binom
+
+
+def compute_ecdf(sample: np.ndarray, eval_points: np.ndarray) -> np.ndarray:
+    """Compute ECDF of the sorted `sample` at the evaluation points."""
+    return np.searchsorted(sample, eval_points, side="right") / len(sample)
+
+
+def _get_ecdf_points(
+    sample: np.ndarray, eval_points: np.ndarray, difference: bool
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Compute the coordinates for the ecdf points using compute_ecdf."""
+    x = eval_points
+    y = compute_ecdf(sample, eval_points)
+
+    if not difference and y[0] > 0:
+        x = np.insert(x, 0, x[0])
+        y = np.insert(y, 0, 0)
+    return x, y
+
+
+def _simulate_ecdf(
+    ndraws: int,
+    eval_points: np.ndarray,
+    rvs: Callable[[int, Optional[Any]], np.ndarray],
+    random_state: Optional[Any] = None,
+) -> np.ndarray:
+    """Simulate ECDF at the `eval_points` using the given random variable sampler"""
+    sample = rvs(ndraws, random_state=random_state)
+    sample.sort()
+    return compute_ecdf(sample, eval_points)
+
+
+def _fit_pointwise_band_probability(
+    ndraws: int,
+    ecdf_at_eval_points: np.ndarray,
+    cdf_at_eval_points: np.ndarray,
+) -> float:
+    """Compute the smallest marginal probability of a pointwise confidence band that
+    contains the ECDF."""
+    ecdf_scaled = (ndraws * ecdf_at_eval_points).astype(int)
+    prob_lower_tail = np.amin(binom.cdf(ecdf_scaled, ndraws, cdf_at_eval_points))
+    prob_upper_tail = np.amin(binom.sf(ecdf_scaled - 1, ndraws, cdf_at_eval_points))
+    prob_pointwise = 1 - 2 * min(prob_lower_tail, prob_upper_tail)
+    return prob_pointwise
+
+
+def _get_pointwise_confidence_band(
+    prob: float, ndraws: int, cdf_at_eval_points: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Compute the `prob`-level pointwise confidence band."""
+    count_lower, count_upper = binom.interval(prob, ndraws, cdf_at_eval_points)
+    prob_lower = count_lower / ndraws
+    prob_upper = count_upper / ndraws
+    return prob_lower, prob_upper
+
+
+def ecdf_confidence_band(
+    ndraws: int,
+    eval_points: np.ndarray,
+    cdf_at_eval_points: np.ndarray,
+    prob: float = 0.95,
+    method="simulated",
+    **kwargs,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Compute the `prob`-level confidence band for the ECDF.
+
+    Arguments
+    ---------
+    ndraws : int
+        Number of samples in the original dataset.
+    eval_points : np.ndarray
+        Points at which the ECDF is evaluated. If these are dependent on the sample
+        values, simultaneous confidence bands may not be correctly calibrated.
+    cdf_at_eval_points : np.ndarray
+        CDF values at the evaluation points.
+    prob : float, default 0.95
+        The target probability that a true ECDF lies within the 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.
+        - "simulated": Use Monte Carlo simulation to estimate a simultaneous confidence band.
+          `rvs` must be provided.
+    rvs: callable, optional
+        A function that takes an integer `ndraws` and optionally the object passed to
+        `random_state` and returns an array of `ndraws` samples from the same distribution
+        as the original dataset. Required if `method` is "simulated" and variable is discrete.
+    num_trials : int, default 1000
+        The number of random ECDFs to generate for constructing simultaneous confidence bands
+        (if `method` is "simulated").
+    random_state : {None, int, `numpy.random.Generator`,
+                    `numpy.random.RandomState`}, optional
+        If `None`, the `numpy.random.RandomState` singleton is used. If an `int`, a new
+        ``numpy.random.RandomState`` instance is used, seeded with seed. If a `RandomState` or
+        `Generator` instance, the instance is used.
+
+    Returns
+    -------
+    prob_lower : np.ndarray
+        Lower confidence band for the ECDF at the evaluation points.
+    prob_upper : np.ndarray
+        Upper confidence band for the ECDF at the evaluation points.
+    """
+    if not 0 < prob < 1:
+        raise ValueError(f"Invalid value for `prob`. Expected 0 < prob < 1, but got {prob}.")
+
+    if method == "pointwise":
+        prob_pointwise = prob
+    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'.")
+
+    prob_lower, prob_upper = _get_pointwise_confidence_band(
+        prob_pointwise, ndraws, cdf_at_eval_points
+    )
+
+    return prob_lower, prob_upper
+
+
+def _simulate_simultaneous_ecdf_band_probability(
+    ndraws: int,
+    eval_points: np.ndarray,
+    cdf_at_eval_points: np.ndarray,
+    prob: float = 0.95,
+    rvs: Optional[Callable[[int, Optional[Any]], np.ndarray]] = None,
+    num_trials: int = 1000,
+    random_state: Optional[Any] = None,
+) -> float:
+    """Estimate probability for simultaneous confidence band using simulation.
+
+    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.
+    """
+    if rvs is None:
+        warnings.warn(
+            "Assuming variable is continuous for calibration of pointwise bands. "
+            "If the variable is discrete, specify random variable sampler `rvs`.",
+            UserWarning,
+        )
+        # if variable continuous, we can calibrate the confidence band using a uniform
+        # distribution
+        rvs = uniform(0, 1).rvs
+        eval_points_sim = cdf_at_eval_points
+    else:
+        eval_points_sim = eval_points
+
+    probs_pointwise = np.empty(num_trials)
+    for i in range(num_trials):
+        ecdf_at_eval_points = _simulate_ecdf(
+            ndraws, eval_points_sim, rvs, random_state=random_state
+        )
+        prob_pointwise = _fit_pointwise_band_probability(
+            ndraws, ecdf_at_eval_points, cdf_at_eval_points
+        )
+        probs_pointwise[i] = prob_pointwise
+    return np.quantile(probs_pointwise, prob)

arviz/stats/stats.py

@@ -146,6 +146,7 @@ def compare(
     Compare the centered and non centered models of the eight school problem:
 
     .. ipython::
+       :okwarning:
 
         In [1]: import arviz as az
            ...: data1 = az.load_arviz_data("non_centered_eight")
@@ -157,6 +158,7 @@ def compare(
     weights using the stacking method.
 
     .. ipython::
+       :okwarning:
 
         In [1]: az.compare(compare_dict, ic="loo", method="stacking", scale="log")
 
@@ -180,37 +182,19 @@ def compare(
     except Exception as e:
         raise e.__class__("Encountered error in ELPD computation of compare.") from e
     names = list(ics_dict.keys())
-    if ic == "loo":
+    if ic in {"loo", "waic"}:
         df_comp = pd.DataFrame(
-            index=names,
-            columns=[
-                "rank",
-                "elpd_loo",
-                "p_loo",
-                "elpd_diff",
-                "weight",
-                "se",
-                "dse",
-                "warning",
-                "scale",
-            ],
-            dtype=np.float_,
-        )
-    elif ic == "waic":
-        df_comp = pd.DataFrame(
-            index=names,
-            columns=[
-                "rank",
-                "elpd_waic",
-                "p_waic",
-                "elpd_diff",
-                "weight",
-                "se",
-                "dse",
-                "warning",
-                "scale",
-            ],
-            dtype=np.float_,
+            {
+                "rank": pd.Series(index=names, dtype="int"),
+                f"elpd_{ic}": pd.Series(index=names, dtype="float"),
+                f"p_{ic}": pd.Series(index=names, dtype="float"),
+                "elpd_diff": pd.Series(index=names, dtype="float"),
+                "weight": pd.Series(index=names, dtype="float"),
+                "se": pd.Series(index=names, dtype="float"),
+                "dse": pd.Series(index=names, dtype="float"),
+                "warning": pd.Series(index=names, dtype="boolean"),
+                "scale": pd.Series(index=names, dtype="str"),
+            }
         )
     else:
         raise NotImplementedError(f"The information criterion {ic} is not supported.")
@@ -632,7 +616,7 @@ def _hdi(ary, hdi_prob, circular, skipna):
     ary = np.sort(ary)
     interval_idx_inc = int(np.floor(hdi_prob * n))
     n_intervals = n - interval_idx_inc
-    interval_width = np.subtract(ary[interval_idx_inc:], ary[:n_intervals], dtype=np.float_)
+    interval_width = np.subtract(ary[interval_idx_inc:], ary[:n_intervals], dtype=np.float64)
 
     if len(interval_width) == 0:
         raise ValueError("Too few elements for interval calculation. ")
@@ -2096,7 +2080,7 @@ def weight_predictions(idatas, weights=None):
     weights /= weights.sum()
 
     len_idatas = [
-        idata.posterior_predictive.dims["chain"] * idata.posterior_predictive.dims["draw"]
+        idata.posterior_predictive.sizes["chain"] * idata.posterior_predictive.sizes["draw"]
         for idata in idatas
     ]
 

arviz/stats/stats_utils.py

@@ -484,7 +484,7 @@ class ELPDData(pd.Series):  # pylint: disable=too-many-ancestors
             base += "\n\nThere has been a warning during the calculation. Please check the results."
 
         if kind == "loo" and "pareto_k" in self:
-            bins = np.asarray([-np.Inf, 0.5, 0.7, 1, np.Inf])
+            bins = np.asarray([-np.inf, 0.5, 0.7, 1, np.inf])
             counts, *_ = _histogram(self.pareto_k.values, bins)
             extended = POINTWISE_LOO_FMT.format(max(4, len(str(np.max(counts)))))
             extended = extended.format(

arviz/tests/base_tests/test_data.py

@@ -1241,7 +1241,7 @@ class TestDataDict:
         self.check_var_names_coords_dims(inference_data.prior_predictive)
         self.check_var_names_coords_dims(inference_data.sample_stats_prior)
 
-        pred_dims = inference_data.predictions.dims["school_pred"]
+        pred_dims = inference_data.predictions.sizes["school_pred"]
         assert pred_dims == 8
 
     def test_inference_data_warmup(self, data, eight_schools_params):
@@ -1586,8 +1586,8 @@ class TestExtractDataset:
         idata = load_arviz_data("centered_eight")
         post = extract(idata, combined=False)
         assert "sample" not in post.dims
-        assert post.dims["chain"] == 4
-        assert post.dims["draw"] == 500
+        assert post.sizes["chain"] == 4
+        assert post.sizes["draw"] == 500
 
     def test_var_name_group(self):
         idata = load_arviz_data("centered_eight")
@@ -1607,5 +1607,5 @@ class TestExtractDataset:
     def test_subset_samples(self):
         idata = load_arviz_data("centered_eight")
         post = extract(idata, num_samples=10)
-        assert post.dims["sample"] == 10
+        assert post.sizes["sample"] == 10
         assert post.attrs == idata.posterior.attrs

arviz/tests/base_tests/test_stats_ecdf_utils.py

@@ -0,0 +1,153 @@
+import pytest
+
+import numpy as np
+import scipy.stats
+from ...stats.ecdf_utils import (
+    compute_ecdf,
+    ecdf_confidence_band,
+    _get_ecdf_points,
+    _simulate_ecdf,
+    _get_pointwise_confidence_band,
+)
+
+
+def test_compute_ecdf():
+    """Test compute_ecdf function."""
+    sample = np.array([1, 2, 3, 3, 4, 5])
+    eval_points = np.arange(0, 7, 0.1)
+    ecdf_expected = (sample[:, None] <= eval_points).mean(axis=0)
+    assert np.allclose(compute_ecdf(sample, eval_points), ecdf_expected)
+    assert np.allclose(compute_ecdf(sample / 2 + 10, eval_points / 2 + 10), ecdf_expected)
+
+
+@pytest.mark.parametrize("difference", [True, False])
+def test_get_ecdf_points(difference):
+    """Test _get_ecdf_points."""
+    # if first point already outside support, no need to insert it
+    sample = np.array([1, 2, 3, 3, 4, 5, 5])
+    eval_points = np.arange(-1, 7, 0.1)
+    x, y = _get_ecdf_points(sample, eval_points, difference)
+    assert np.array_equal(x, eval_points)
+    assert np.array_equal(y, compute_ecdf(sample, eval_points))
+
+    # if first point is inside support, insert it if not in difference mode
+    eval_points = np.arange(1, 6, 0.1)
+    x, y = _get_ecdf_points(sample, eval_points, difference)
+    assert len(x) == len(eval_points) + 1 - difference
+    assert len(y) == len(eval_points) + 1 - difference
+
+    # if not in difference mode, first point should be (eval_points[0], 0)
+    if not difference:
+        assert x[0] == eval_points[0]
+        assert y[0] == 0
+        assert np.allclose(x[1:], eval_points)
+        assert np.allclose(y[1:], compute_ecdf(sample, eval_points))
+        assert x[-1] == eval_points[-1]
+        assert y[-1] == 1
+
+
+@pytest.mark.parametrize(
+    "dist", [scipy.stats.norm(3, 10), scipy.stats.binom(10, 0.5)], ids=["continuous", "discrete"]
+)
+@pytest.mark.parametrize("seed", [32, 87])
+def test_simulate_ecdf(dist, seed):
+    """Test _simulate_ecdf."""
+    ndraws = 1000
+    eval_points = np.arange(0, 1, 0.1)
+
+    rvs = dist.rvs
+
+    random_state = np.random.default_rng(seed)
+    ecdf = _simulate_ecdf(ndraws, eval_points, rvs, random_state=random_state)
+    random_state = np.random.default_rng(seed)
+    ecdf_expected = compute_ecdf(np.sort(rvs(ndraws, random_state=random_state)), eval_points)
+
+    assert np.allclose(ecdf, ecdf_expected)
+
+
+@pytest.mark.parametrize("prob", [0.8, 0.9])
+@pytest.mark.parametrize(
+    "dist", [scipy.stats.norm(3, 10), scipy.stats.poisson(100)], ids=["continuous", "discrete"]
+)
+@pytest.mark.parametrize("ndraws", [10_000])
+def test_get_pointwise_confidence_band(dist, prob, ndraws, num_trials=1_000, seed=57):
+    """Test _get_pointwise_confidence_band."""
+    eval_points = np.linspace(*dist.interval(0.99), 10)
+    cdf_at_eval_points = dist.cdf(eval_points)
+
+    ecdf_lower, ecdf_upper = _get_pointwise_confidence_band(prob, ndraws, cdf_at_eval_points)
+
+    # check basic properties
+    assert np.all(ecdf_lower >= 0)
+    assert np.all(ecdf_upper <= 1)
+    assert np.all(ecdf_lower <= ecdf_upper)
+
+    # use simulation to estimate lower and upper bounds on pointwise probability
+    in_interval = []
+    random_state = np.random.default_rng(seed)
+    for _ in range(num_trials):
+        ecdf = _simulate_ecdf(ndraws, eval_points, dist.rvs, random_state=random_state)
+        in_interval.append((ecdf_lower <= ecdf) & (ecdf < ecdf_upper))
+    asymptotic_dist = scipy.stats.norm(
+        np.mean(in_interval, axis=0), scipy.stats.sem(in_interval, axis=0)
+    )
+    prob_lower, prob_upper = asymptotic_dist.interval(0.999)
+
+    # check target probability within all bounds
+    assert np.all(prob_lower <= prob)
+    assert np.all(prob <= prob_upper)
+
+
+@pytest.mark.parametrize("prob", [0.8, 0.9])
+@pytest.mark.parametrize(
+    "dist, rvs",
+    [
+        (scipy.stats.norm(3, 10), scipy.stats.norm(3, 10).rvs),
+        (scipy.stats.norm(3, 10), None),
+        (scipy.stats.poisson(100), scipy.stats.poisson(100).rvs),
+    ],
+    ids=["continuous", "continuous default rvs", "discrete"],
+)
+@pytest.mark.parametrize("ndraws", [10_000])
+@pytest.mark.parametrize("method", ["pointwise", "simulated"])
+def test_ecdf_confidence_band(dist, rvs, prob, ndraws, method, num_trials=1_000, seed=57):
+    """Test test_ecdf_confidence_band."""
+    eval_points = np.linspace(*dist.interval(0.99), 10)
+    cdf_at_eval_points = dist.cdf(eval_points)
+    random_state = np.random.default_rng(seed)
+
+    ecdf_lower, ecdf_upper = ecdf_confidence_band(
+        ndraws,
+        eval_points,
+        cdf_at_eval_points,
+        prob=prob,
+        rvs=rvs,
+        random_state=random_state,
+        method=method,
+    )
+
+    if method == "pointwise":
+        # these values tested elsewhere, we just make sure they're the same
+        ecdf_lower_pointwise, ecdf_upper_pointwise = _get_pointwise_confidence_band(
+            prob, ndraws, cdf_at_eval_points
+        )
+        assert np.array_equal(ecdf_lower, ecdf_lower_pointwise)
+        assert np.array_equal(ecdf_upper, ecdf_upper_pointwise)
+        return
+
+    # check basic properties
+    assert np.all(ecdf_lower >= 0)
+    assert np.all(ecdf_upper <= 1)
+    assert np.all(ecdf_lower <= ecdf_upper)
+
+    # use simulation to estimate lower and upper bounds on simultaneous probability
+    in_envelope = []
+    random_state = np.random.default_rng(seed)
+    for _ in range(num_trials):
+        ecdf = _simulate_ecdf(ndraws, eval_points, dist.rvs, random_state=random_state)
+        in_envelope.append(np.all(ecdf_lower <= ecdf) & np.all(ecdf < ecdf_upper))
+    asymptotic_dist = scipy.stats.norm(np.mean(in_envelope), scipy.stats.sem(in_envelope))
+    prob_lower, prob_upper = asymptotic_dist.interval(0.999)
+
+    # check target probability within bounds
+    assert prob_lower <= prob <= prob_upper

arviz/tests/base_tests/test_stats_utils.py

@@ -344,9 +344,9 @@ def test_variance_bad_data():
 
 def test_histogram():
     school = load_arviz_data("non_centered_eight").posterior["mu"].values
-    k_count_az, k_dens_az, _ = histogram(school, bins=np.asarray([-np.Inf, 0.5, 0.7, 1, np.Inf]))
-    k_dens_np, *_ = np.histogram(school, bins=[-np.Inf, 0.5, 0.7, 1, np.Inf], density=True)
-    k_count_np, *_ = np.histogram(school, bins=[-np.Inf, 0.5, 0.7, 1, np.Inf], density=False)
+    k_count_az, k_dens_az, _ = histogram(school, bins=np.asarray([-np.inf, 0.5, 0.7, 1, np.inf]))
+    k_dens_np, *_ = np.histogram(school, bins=[-np.inf, 0.5, 0.7, 1, np.inf], density=True)
+    k_count_np, *_ = np.histogram(school, bins=[-np.inf, 0.5, 0.7, 1, np.inf], density=False)
     assert np.allclose(k_count_az, k_count_np)
     assert np.allclose(k_dens_az, k_dens_np)
 

arviz/tests/external_tests/test_data_numpyro.py

@@ -101,8 +101,8 @@ class TestDataNumPyro:
         assert not fails
 
         # test dims
-        dims = inference_data.posterior_predictive.dims["school"]
-        pred_dims = inference_data.predictions.dims["school_pred"]
+        dims = inference_data.posterior_predictive.sizes["school"]
+        pred_dims = inference_data.predictions.sizes["school_pred"]
         assert dims == 8
         assert pred_dims == 8
 
@@ -240,7 +240,7 @@ class TestDataNumPyro:
     def test_inference_data_num_chains(self, predictions_data, chains):
         predictions = predictions_data
         inference_data = from_numpyro(predictions=predictions, num_chains=chains)
-        nchains = inference_data.predictions.dims["chain"]
+        nchains = inference_data.predictions.sizes["chain"]
         assert nchains == chains
 
     @pytest.mark.parametrize("nchains", [1, 2])

arviz/tests/external_tests/test_data_pyro.py

@@ -83,8 +83,8 @@ class TestDataPyro:
         assert not fails
 
         # test dims
-        dims = inference_data.posterior_predictive.dims["school"]
-        pred_dims = inference_data.predictions.dims["school_pred"]
+        dims = inference_data.posterior_predictive.sizes["school"]
+        pred_dims = inference_data.predictions.sizes["school_pred"]
         assert dims == 8
         assert pred_dims == 8
 
@@ -225,7 +225,7 @@ class TestDataPyro:
     def test_inference_data_num_chains(self, predictions_data, chains):
         predictions = predictions_data
         inference_data = from_pyro(predictions=predictions, num_chains=chains)
-        nchains = inference_data.predictions.dims["chain"]
+        nchains = inference_data.predictions.sizes["chain"]
         assert nchains == chains
 
     @pytest.mark.parametrize("log_likelihood", [True, False])

{arviz-0.17.0.dist-info → arviz-0.17.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arviz
-Version: 0.17.0
+Version: 0.17.1
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Scientific/Engineering :: Mathematics
@@ -52,8 +53,7 @@ Requires-Dist: xarray-datatree ; extra == 'all'
 [![DOI](http://joss.theoj.org/papers/10.21105/joss.01143/status.svg)](https://doi.org/10.21105/joss.01143) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2540945.svg)](https://doi.org/10.5281/zenodo.2540945)
 [![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
 
-ArviZ (pronounced "AR-_vees_") is a Python package for exploratory analysis of Bayesian models.
-Includes functions for posterior analysis, data storage, model checking, comparison and diagnostics.
+ArviZ (pronounced "AR-_vees_") is a Python package for exploratory analysis of Bayesian models. It includes functions for posterior analysis, data storage, model checking, comparison and diagnostics.
 
 ### ArviZ in other languages
 ArviZ also has a Julia wrapper available [ArviZ.jl](https://julia.arviz.org/).
@@ -202,6 +202,7 @@ python setup.py install
 
   <a href="https://python.arviz.org/en/latest/examples/index.html">And more...</a>
 </div>
+
 ## Dependencies
 
 ArviZ is tested on Python 3.10, 3.11 and 3.12, and depends on NumPy, SciPy, xarray, and Matplotlib.