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

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_beanmachine.py

@@ -11,6 +11,8 @@ from ..helpers import (  # pylint: disable=unused-import, wrong-import-position
     load_cached_models,
 )
 
+pytest.skip("Ignore beanmachine tests until it supports pytorch 2", allow_module_level=True)
+
 # Skip all tests if beanmachine or pytorch not installed
 torch = importorskip("torch")
 bm = importorskip("beanmachine.ppl")

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_pyjags.py

@@ -1,4 +1,5 @@
 # pylint: disable=no-member, invalid-name, redefined-outer-name, unused-import
+import sys
 import typing as tp
 
 import numpy as np
@@ -12,6 +13,8 @@ from ...data.io_pyjags import (
 )
 from ..helpers import check_multiple_attrs, eight_schools_params
 
+pytest.skip("Uses deprecated numpy C-api", allow_module_level=True)
+
 PYJAGS_POSTERIOR_DICT = {
     "b": np.random.randn(3, 10, 3),
     "int": np.random.randn(1, 10, 3),
@@ -40,7 +43,6 @@ def verify_equality_of_numpy_values_dictionaries(
     return True
 
 
-@pytest.mark.skip("Crashes Python")
 class TestDataPyJAGSWithoutEstimation:
     def test_convert_pyjags_samples_dictionary_to_arviz_samples_dictionary(self):
         arviz_samples_dict_from_pyjags_samples_dict = _convert_pyjags_dict_to_arviz_dict(

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/tests/helpers.py

@@ -432,18 +432,18 @@ def pystan_noncentered_schools(data, draws, chains):
     schools_code = """
         data {
             int<lower=0> J;
-            real y[J];
-            real<lower=0> sigma[J];
+            array[J] real y;
+            array[J] real<lower=0> sigma;
         }
 
         parameters {
             real mu;
             real<lower=0> tau;
-            real eta[J];
+            array[J] real eta;
         }
 
         transformed parameters {
-            real theta[J];
+            array[J] real theta;
             for (j in 1:J)
                 theta[j] = mu + tau * eta[j];
         }
@@ -456,8 +456,8 @@ def pystan_noncentered_schools(data, draws, chains):
         }
 
         generated quantities {
-            vector[J] log_lik;
-            vector[J] y_hat;
+            array[J] real log_lik;
+            array[J] real y_hat;
             for (j in 1:J) {
                 log_lik[j] = normal_lpdf(y[j] | theta[j], sigma[j]);
                 y_hat[j] = normal_rng(theta[j], sigma[j]);
@@ -487,7 +487,7 @@ def pystan_noncentered_schools(data, draws, chains):
 
 
 def bm_schools_model(data, draws, chains):
-    import beanmachine.ppl as bm
+    import beanmachine.ppl as bm  # pylint: disable=import-error
     import torch
     import torch.distributions as dist
 
@@ -552,7 +552,7 @@ def load_cached_models(eight_schools_data, draws, chains, libs=None):
         ("emcee", emcee_schools_model),
         ("pyro", pyro_noncentered_schools),
         ("numpyro", numpyro_schools_model),
-        ("beanmachine", bm_schools_model),
+        # ("beanmachine", bm_schools_model),  # ignore beanmachine until it supports torch>=2
     )
     data_directory = os.path.join(here, "saved_models")
     models = {}

arviz/utils.py

@@ -21,7 +21,7 @@ def _check_tilde_start(x):
     return bool(isinstance(x, str) and x.startswith("~"))
 
 
-def _var_names(var_names, data, filter_vars=None):
+def _var_names(var_names, data, filter_vars=None, errors="raise"):
     """Handle var_names input across arviz.
 
     Parameters
@@ -34,6 +34,8 @@ def _var_names(var_names, data, filter_vars=None):
          interpret var_names as substrings of the real variables names. If "regex",
          interpret var_names as regular expressions on the real variables names. A la
         `pandas.filter`.
+    errors: {"raise", "ignore"}, optional, default="raise"
+        Select either to raise or ignore the invalid names.
 
     Returns
     -------
@@ -44,6 +46,9 @@ def _var_names(var_names, data, filter_vars=None):
             f"'filter_vars' can only be None, 'like', or 'regex', got: '{filter_vars}'"
         )
 
+    if errors not in {"raise", "ignore"}:
+        raise ValueError(f"'errors' can only be 'raise', or 'ignore', got: '{errors}'")
+
     if var_names is not None:
         if isinstance(data, (list, tuple)):
             all_vars = []
@@ -66,14 +71,16 @@ def _var_names(var_names, data, filter_vars=None):
             )
 
         try:
-            var_names = _subset_list(var_names, all_vars, filter_items=filter_vars, warn=False)
+            var_names = _subset_list(
+                var_names, all_vars, filter_items=filter_vars, warn=False, errors=errors
+            )
         except KeyError as err:
             msg = " ".join(("var names:", f"{err}", "in dataset"))
             raise KeyError(msg) from err
     return var_names
 
 
-def _subset_list(subset, whole_list, filter_items=None, warn=True):
+def _subset_list(subset, whole_list, filter_items=None, warn=True, errors="raise"):
     """Handle list subsetting (var_names, groups...) across arviz.
 
     Parameters
@@ -87,6 +94,8 @@ def _subset_list(subset, whole_list, filter_items=None, warn=True):
         names. If "like", interpret `subset` as substrings of the elements in
         `whole_list`. If "regex", interpret `subset` as regular expressions to match
         elements in `whole_list`. A la `pandas.filter`.
+    errors: {"raise", "ignore"}, optional, default="raise"
+        Select either to raise or ignore the invalid names.
 
     Returns
     -------
@@ -95,7 +104,6 @@ def _subset_list(subset, whole_list, filter_items=None, warn=True):
         and ``filter_items``.
     """
     if subset is not None:
-
         if isinstance(subset, str):
             subset = [subset]
 
@@ -142,7 +150,7 @@ def _subset_list(subset, whole_list, filter_items=None, warn=True):
             subset = [item for item in whole_list for name in subset if re.search(name, item)]
 
         existing_items = np.isin(subset, whole_list)
-        if not np.all(existing_items):
+        if not np.all(existing_items) and (errors == "raise"):
             raise KeyError(f"{np.array(subset)[~existing_items]} are not present")
 
     return subset
@@ -660,7 +668,8 @@ def _load_static_files():
     Clone from xarray.core.formatted_html_template.
     """
     return [
-        importlib.resources.files("arviz").joinpath(fname).read_text() for fname in STATIC_FILES
+        importlib.resources.files("arviz").joinpath(fname).read_text(encoding="utf-8")
+        for fname in STATIC_FILES
     ]
 
 
@@ -745,7 +754,6 @@ def conditional_dask(func):
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-
         if not Dask.dask_flag:
             return func(*args, **kwargs)
         user_kwargs = kwargs.pop("dask_kwargs", None)

arviz/wrappers/wrap_pymc.py

@@ -2,6 +2,7 @@
 """Base class for PyMC interface wrappers."""
 from .base import SamplingWrapper
 
+
 # pylint: disable=abstract-method
 class PyMCSamplingWrapper(SamplingWrapper):
     """PyMC (4.0+) sampling wrapper base class.
@@ -21,7 +22,6 @@ class PyMCSamplingWrapper(SamplingWrapper):
         import pymc  # pylint: disable=import-error
 
         with self.model:
-
             pymc.set_data(modified_observed_data)
             idata = pymc.sample(
                 **self.sample_kwargs,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arviz
-Version: 0.16.1
+Version: 0.17.1
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers
@@ -15,30 +15,31 @@ 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
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: setuptools (>=60.0.0)
-Requires-Dist: matplotlib (>=3.2)
-Requires-Dist: numpy (<2.0,>=1.21.0)
-Requires-Dist: scipy (>=1.8.0)
+Requires-Dist: setuptools >=60.0.0
+Requires-Dist: matplotlib >=3.5
+Requires-Dist: numpy <2.0,>=1.22.0
+Requires-Dist: scipy >=1.8.0
 Requires-Dist: packaging
-Requires-Dist: pandas (>=1.3.0)
-Requires-Dist: xarray (>=0.21.0)
-Requires-Dist: h5netcdf (>=1.0.2)
-Requires-Dist: typing-extensions (>=4.1.0)
-Requires-Dist: xarray-einstats (>=0.3)
+Requires-Dist: pandas >=1.4.0
+Requires-Dist: xarray >=0.21.0
+Requires-Dist: h5netcdf >=1.0.2
+Requires-Dist: typing-extensions >=4.1.0
+Requires-Dist: xarray-einstats >=0.3
 Provides-Extra: all
 Requires-Dist: numba ; extra == 'all'
 Requires-Dist: netcdf4 ; extra == 'all'
-Requires-Dist: bokeh (<3.0,>=1.4.0) ; extra == 'all'
+Requires-Dist: bokeh <3.0,>=1.4.0 ; extra == 'all'
 Requires-Dist: contourpy ; extra == 'all'
 Requires-Dist: ujson ; extra == 'all'
 Requires-Dist: dask[distributed] ; extra == 'all'
-Requires-Dist: zarr (>=2.5.0) ; extra == 'all'
+Requires-Dist: zarr >=2.5.0 ; extra == 'all'
 Requires-Dist: xarray-datatree ; extra == 'all'
 
 <img src="https://raw.githubusercontent.com/arviz-devs/arviz-project/main/arviz_logos/ArviZ.png#gh-light-mode-only" width=200></img>
@@ -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,9 +202,10 @@ 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.9, 3.10 and 3.11, and depends on NumPy, SciPy, xarray, and Matplotlib.
+ArviZ is tested on Python 3.10, 3.11 and 3.12, and depends on NumPy, SciPy, xarray, and Matplotlib.
 
 
 ## Citation