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

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

@@ -1,4 +1,5 @@
 """Stats functions that require refitting the model."""
+
 import logging
 import warnings
 

arviz/stats/stats_utils.py

@@ -1,4 +1,5 @@
 """Stats-utility functions for ArviZ."""
+
 import warnings
 from collections.abc import Sequence
 from copy import copy as _copy
@@ -134,7 +135,10 @@ def make_ufunc(
                 raise TypeError(msg)
         for idx in np.ndindex(out.shape[:n_dims_out]):
             arys_idx = [ary[idx].ravel() if ravel else ary[idx] for ary in arys]
-            out[idx] = np.asarray(func(*arys_idx, *args[n_input:], **kwargs))[index]
+            out_idx = np.asarray(func(*arys_idx, *args[n_input:], **kwargs))[index]
+            if n_dims_out is None:
+                out_idx = out_idx.item()
+            out[idx] = out_idx
         return out
 
     def _multi_ufunc(*args, out=None, out_shape=None, **kwargs):
@@ -484,7 +488,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

@@ -1077,6 +1077,20 @@ def test_dict_to_dataset():
     assert set(dataset.b.coords) == {"chain", "draw", "c"}
 
 
+def test_nested_dict_to_dataset():
+    datadict = {
+        "top": {"a": np.random.randn(100), "b": np.random.randn(1, 100, 10)},
+        "d": np.random.randn(100),
+    }
+    dataset = convert_to_dataset(datadict, coords={"c": np.arange(10)}, dims={("top", "b"): ["c"]})
+    assert set(dataset.data_vars) == {("top", "a"), ("top", "b"), "d"}
+    assert set(dataset.coords) == {"chain", "draw", "c"}
+
+    assert set(dataset[("top", "a")].coords) == {"chain", "draw"}
+    assert set(dataset[("top", "b")].coords) == {"chain", "draw", "c"}
+    assert set(dataset.d.coords) == {"chain", "draw"}
+
+
 def test_dict_to_dataset_event_dims_error():
     datadict = {"a": np.random.randn(1, 100, 10)}
     coords = {"b": np.arange(10), "c": ["x", "y", "z"]}
@@ -1241,7 +1255,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 +1600,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 +1621,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_diagnostics.py

@@ -1,4 +1,5 @@
 """Test Diagnostic methods"""
+
 # pylint: disable=redefined-outer-name, no-member, too-many-public-methods
 import os
 

arviz/tests/base_tests/test_diagnostics_numba.py

@@ -1,4 +1,5 @@
 """Test Diagnostic methods"""
+
 import importlib
 
 # pylint: disable=redefined-outer-name, no-member, too-many-public-methods

arviz/tests/base_tests/test_labels.py

@@ -1,4 +1,5 @@
 """Tests for labeller classes."""
+
 import pytest
 
 from ...labels import (

arviz/tests/base_tests/test_plots_matplotlib.py

@@ -1,4 +1,5 @@
 """Tests use the default backend."""
+
 # pylint: disable=redefined-outer-name,too-many-lines
 import os
 from copy import deepcopy
@@ -54,7 +55,7 @@ from ..helpers import (  # pylint: disable=unused-import
     eight_schools_params,
     models,
     multidim_models,
-    TestRandomVariable,
+    RandomVariableTestClass,
 )
 
 rcParams["data.load"] = "eager"
@@ -168,9 +169,9 @@ def test_plot_density_no_subset():
 
 def test_plot_density_nonstring_varnames():
     """Test plot_density works when variables are not strings."""
-    rv1 = TestRandomVariable("a")
-    rv2 = TestRandomVariable("b")
-    rv3 = TestRandomVariable("c")
+    rv1 = RandomVariableTestClass("a")
+    rv2 = RandomVariableTestClass("b")
+    rv3 = RandomVariableTestClass("c")
     model_ab = from_dict(
         {
             rv1: np.random.normal(size=200),
@@ -752,7 +753,7 @@ def test_plot_ppc_transposed():
     )
     x, y = ax.get_lines()[2].get_data()
     assert not np.isclose(y[0], 0)
-    assert np.all(np.array([40, 43, 10, 9]) == x)
+    assert np.all(np.array([47, 44, 15, 11]) == x)
 
 
 @pytest.mark.parametrize("kind", ["kde", "cumulative", "scatter"])

arviz/tests/base_tests/test_stats.py

@@ -89,25 +89,25 @@ def test_hdi_idata(centered_eight):
     data = centered_eight.posterior
     result = hdi(data)
     assert isinstance(result, Dataset)
-    assert dict(result.dims) == {"school": 8, "hdi": 2}
+    assert dict(result.sizes) == {"school": 8, "hdi": 2}
 
     result = hdi(data, input_core_dims=[["chain"]])
     assert isinstance(result, Dataset)
-    assert result.dims == {"draw": 500, "hdi": 2, "school": 8}
+    assert result.sizes == {"draw": 500, "hdi": 2, "school": 8}
 
 
 def test_hdi_idata_varnames(centered_eight):
     data = centered_eight.posterior
     result = hdi(data, var_names=["mu", "theta"])
     assert isinstance(result, Dataset)
-    assert result.dims == {"hdi": 2, "school": 8}
+    assert result.sizes == {"hdi": 2, "school": 8}
     assert list(result.data_vars.keys()) == ["mu", "theta"]
 
 
 def test_hdi_idata_group(centered_eight):
     result_posterior = hdi(centered_eight, group="posterior", var_names="mu")
     result_prior = hdi(centered_eight, group="prior", var_names="mu")
-    assert result_prior.dims == {"hdi": 2}
+    assert result_prior.sizes == {"hdi": 2}
     range_posterior = result_posterior.mu.values[1] - result_posterior.mu.values[0]
     range_prior = result_prior.mu.values[1] - result_prior.mu.values[0]
     assert range_posterior < range_prior

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

@@ -1,4 +1,5 @@
 """Tests for stats_utils."""
+
 #  pylint: disable=no-member
 import numpy as np
 import pytest
@@ -344,9 +345,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/base_tests/test_utils.py

@@ -1,4 +1,5 @@
 """Tests for arviz.utils."""
+
 # pylint: disable=redefined-outer-name, no-member
 from unittest.mock import Mock
 
@@ -17,7 +18,7 @@ from ...utils import (
     one_de,
     two_de,
 )
-from ..helpers import TestRandomVariable
+from ..helpers import RandomVariableTestClass
 
 
 @pytest.fixture(scope="session")
@@ -123,7 +124,7 @@ def test_var_names_filter(var_args):
 
 def test_nonstring_var_names():
     """Check that non-string variables are preserved"""
-    mu = TestRandomVariable("mu")
+    mu = RandomVariableTestClass("mu")
     samples = np.random.randn(10)
     data = dict_to_dataset({mu: samples})
     assert _var_names([mu], data) == [mu]

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

@@ -18,7 +18,7 @@ from ..data import InferenceData, from_dict
 _log = logging.getLogger(__name__)
 
 
-class TestRandomVariable:
+class RandomVariableTestClass:
     """Example class for random variables."""
 
     def __init__(self, name):

arviz/wrappers/__init__.py

@@ -1,4 +1,5 @@
 """Sampling wrappers."""
+
 from .base import SamplingWrapper
 from .wrap_stan import PyStan2SamplingWrapper, PyStanSamplingWrapper, CmdStanPySamplingWrapper
 from .wrap_pymc import PyMCSamplingWrapper

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arviz
-Version: 0.17.0
+Version: 0.18.0
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers
@@ -12,22 +12,23 @@ Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 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
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 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: numpy <2.0,>=1.23.0
+Requires-Dist: scipy >=1.9.0
 Requires-Dist: packaging
-Requires-Dist: pandas >=1.4.0
-Requires-Dist: xarray >=0.21.0
+Requires-Dist: pandas >=1.5.0
+Requires-Dist: dm-tree >=0.1.8
+Requires-Dist: xarray >=2022.6.0
 Requires-Dist: h5netcdf >=1.0.2
 Requires-Dist: typing-extensions >=4.1.0
 Requires-Dist: xarray-einstats >=0.3
@@ -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.