arviz 0.23.1__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

arviz/tests/external_tests/test_data_pyro.py

@@ -1,260 +0,0 @@
-# pylint: disable=no-member, invalid-name, redefined-outer-name
-import numpy as np
-import packaging
-import pytest
-
-from ...data.io_pyro import from_pyro  # pylint: disable=wrong-import-position
-from ..helpers import (  # pylint: disable=unused-import, wrong-import-position
-    chains,
-    check_multiple_attrs,
-    draws,
-    eight_schools_params,
-    importorskip,
-    load_cached_models,
-)
-
-# Skip all tests if pyro or pytorch not installed
-torch = importorskip("torch")
-pyro = importorskip("pyro")
-Predictive = pyro.infer.Predictive
-dist = pyro.distributions
-
-
-class TestDataPyro:
-    @pytest.fixture(scope="class")
-    def data(self, eight_schools_params, draws, chains):
-        class Data:
-            obj = load_cached_models(eight_schools_params, draws, chains, "pyro")["pyro"]
-
-        return Data
-
-    @pytest.fixture(scope="class")
-    def predictions_params(self):
-        """Predictions data for eight schools."""
-        return {
-            "J": 8,
-            "sigma": np.array([5.0, 7.0, 12.0, 4.0, 6.0, 10.0, 3.0, 9.0]),
-        }
-
-    @pytest.fixture(scope="class")
-    def predictions_data(self, data, predictions_params):
-        """Generate predictions for predictions_params"""
-        posterior_samples = data.obj.get_samples()
-        model = data.obj.kernel.model
-        predictions = Predictive(model, posterior_samples)(
-            predictions_params["J"], torch.from_numpy(predictions_params["sigma"]).float()
-        )
-        return predictions
-
-    def get_inference_data(self, data, eight_schools_params, predictions_data):
-        posterior_samples = data.obj.get_samples()
-        model = data.obj.kernel.model
-        posterior_predictive = Predictive(model, posterior_samples)(
-            eight_schools_params["J"], torch.from_numpy(eight_schools_params["sigma"]).float()
-        )
-        prior = Predictive(model, num_samples=500)(
-            eight_schools_params["J"], torch.from_numpy(eight_schools_params["sigma"]).float()
-        )
-        predictions = predictions_data
-        return from_pyro(
-            posterior=data.obj,
-            prior=prior,
-            posterior_predictive=posterior_predictive,
-            predictions=predictions,
-            coords={
-                "school": np.arange(eight_schools_params["J"]),
-                "school_pred": np.arange(eight_schools_params["J"]),
-            },
-            dims={"theta": ["school"], "eta": ["school"], "obs": ["school"]},
-            pred_dims={"theta": ["school_pred"], "eta": ["school_pred"], "obs": ["school_pred"]},
-        )
-
-    def test_inference_data(self, data, eight_schools_params, predictions_data):
-        inference_data = self.get_inference_data(data, eight_schools_params, predictions_data)
-        test_dict = {
-            "posterior": ["mu", "tau", "eta"],
-            "sample_stats": ["diverging"],
-            "posterior_predictive": ["obs"],
-            "predictions": ["obs"],
-            "prior": ["mu", "tau", "eta"],
-            "prior_predictive": ["obs"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails
-
-        # test dims
-        dims = inference_data.posterior_predictive.sizes["school"]
-        pred_dims = inference_data.predictions.sizes["school_pred"]
-        assert dims == 8
-        assert pred_dims == 8
-
-    @pytest.mark.skipif(
-        packaging.version.parse(pyro.__version__) < packaging.version.parse("1.0.0"),
-        reason="requires pyro 1.0.0 or higher",
-    )
-    def test_inference_data_has_log_likelihood_and_observed_data(self, data):
-        idata = from_pyro(data.obj)
-        test_dict = {"log_likelihood": ["obs"], "observed_data": ["obs"]}
-        fails = check_multiple_attrs(test_dict, idata)
-        assert not fails
-
-    def test_inference_data_no_posterior(
-        self, data, eight_schools_params, predictions_data, predictions_params
-    ):
-        posterior_samples = data.obj.get_samples()
-        model = data.obj.kernel.model
-        posterior_predictive = Predictive(model, posterior_samples)(
-            eight_schools_params["J"], torch.from_numpy(eight_schools_params["sigma"]).float()
-        )
-        prior = Predictive(model, num_samples=500)(
-            eight_schools_params["J"], torch.from_numpy(eight_schools_params["sigma"]).float()
-        )
-        predictions = predictions_data
-        constant_data = {"J": 8, "sigma": eight_schools_params["sigma"]}
-        predictions_constant_data = predictions_params
-        # only prior
-        inference_data = from_pyro(prior=prior)
-        test_dict = {"prior": ["mu", "tau", "eta"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails, f"only prior: {fails}"
-        # only posterior_predictive
-        inference_data = from_pyro(posterior_predictive=posterior_predictive)
-        test_dict = {"posterior_predictive": ["obs"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails, f"only posterior_predictive: {fails}"
-        # only predictions
-        inference_data = from_pyro(predictions=predictions)
-        test_dict = {"predictions": ["obs"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails, f"only predictions: {fails}"
-        # only constant_data
-        inference_data = from_pyro(constant_data=constant_data)
-        test_dict = {"constant_data": ["J", "sigma"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails, f"only constant_data: {fails}"
-        # only predictions_constant_data
-        inference_data = from_pyro(predictions_constant_data=predictions_constant_data)
-        test_dict = {"predictions_constant_data": ["J", "sigma"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails, f"only predictions_constant_data: {fails}"
-        # prior and posterior_predictive
-        idata = from_pyro(
-            prior=prior,
-            posterior_predictive=posterior_predictive,
-            coords={"school": np.arange(eight_schools_params["J"])},
-            dims={"theta": ["school"], "eta": ["school"]},
-        )
-        test_dict = {"posterior_predictive": ["obs"], "prior": ["mu", "tau", "eta", "obs"]}
-        fails = check_multiple_attrs(test_dict, idata)
-        assert not fails, f"prior and posterior_predictive: {fails}"
-
-    def test_inference_data_only_posterior(self, data):
-        idata = from_pyro(data.obj)
-        test_dict = {"posterior": ["mu", "tau", "eta"], "sample_stats": ["diverging"]}
-        fails = check_multiple_attrs(test_dict, idata)
-        assert not fails
-
-    @pytest.mark.skipif(
-        packaging.version.parse(pyro.__version__) < packaging.version.parse("1.0.0"),
-        reason="requires pyro 1.0.0 or higher",
-    )
-    def test_inference_data_only_posterior_has_log_likelihood(self, data):
-        idata = from_pyro(data.obj)
-        test_dict = {"log_likelihood": ["obs"]}
-        fails = check_multiple_attrs(test_dict, idata)
-        assert not fails
-
-    def test_multiple_observed_rv(self):
-        y1 = torch.randn(10)
-        y2 = torch.randn(10)
-
-        def model_example_multiple_obs(y1=None, y2=None):
-            x = pyro.sample("x", dist.Normal(1, 3))
-            pyro.sample("y1", dist.Normal(x, 1), obs=y1)
-            pyro.sample("y2", dist.Normal(x, 1), obs=y2)
-
-        nuts_kernel = pyro.infer.NUTS(model_example_multiple_obs)
-        mcmc = pyro.infer.MCMC(nuts_kernel, num_samples=10)
-        mcmc.run(y1=y1, y2=y2)
-        inference_data = from_pyro(mcmc)
-        test_dict = {
-            "posterior": ["x"],
-            "sample_stats": ["diverging"],
-            "log_likelihood": ["y1", "y2"],
-            "observed_data": ["y1", "y2"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails
-        assert not hasattr(inference_data.sample_stats, "log_likelihood")
-
-    def test_inference_data_constant_data(self):
-        x1 = 10
-        x2 = 12
-        y1 = torch.randn(10)
-
-        def model_constant_data(x, y1=None):
-            _x = pyro.sample("x", dist.Normal(1, 3))
-            pyro.sample("y1", dist.Normal(x * _x, 1), obs=y1)
-
-        nuts_kernel = pyro.infer.NUTS(model_constant_data)
-        mcmc = pyro.infer.MCMC(nuts_kernel, num_samples=10)
-        mcmc.run(x=x1, y1=y1)
-        posterior = mcmc.get_samples()
-        posterior_predictive = Predictive(model_constant_data, posterior)(x1)
-        predictions = Predictive(model_constant_data, posterior)(x2)
-        inference_data = from_pyro(
-            mcmc,
-            posterior_predictive=posterior_predictive,
-            predictions=predictions,
-            constant_data={"x1": x1},
-            predictions_constant_data={"x2": x2},
-        )
-        test_dict = {
-            "posterior": ["x"],
-            "posterior_predictive": ["y1"],
-            "sample_stats": ["diverging"],
-            "log_likelihood": ["y1"],
-            "predictions": ["y1"],
-            "observed_data": ["y1"],
-            "constant_data": ["x1"],
-            "predictions_constant_data": ["x2"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails
-
-    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.sizes["chain"]
-        assert nchains == chains
-
-    @pytest.mark.parametrize("log_likelihood", [True, False])
-    def test_log_likelihood(self, log_likelihood):
-        """Test behaviour when log likelihood cannot be retrieved.
-
-        If log_likelihood=True there is a warning to say log_likelihood group is skipped,
-        if log_likelihood=False there is no warning and log_likelihood is skipped.
-        """
-        x = torch.randn((10, 2))
-        y = torch.randn(10)
-
-        def model_constant_data(x, y=None):
-            beta = pyro.sample("beta", dist.Normal(torch.ones(2), 3))
-            pyro.sample("y", dist.Normal(x.matmul(beta), 1), obs=y)
-
-        nuts_kernel = pyro.infer.NUTS(model_constant_data)
-        mcmc = pyro.infer.MCMC(nuts_kernel, num_samples=10)
-        mcmc.run(x=x, y=y)
-        if log_likelihood:
-            with pytest.warns(UserWarning, match="Could not get vectorized trace"):
-                inference_data = from_pyro(mcmc, log_likelihood=log_likelihood)
-        else:
-            inference_data = from_pyro(mcmc, log_likelihood=log_likelihood)
-        test_dict = {
-            "posterior": ["beta"],
-            "sample_stats": ["diverging"],
-            "~log_likelihood": [""],
-            "observed_data": ["y"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails

arviz/tests/external_tests/test_data_pystan.py

@@ -1,307 +0,0 @@
-# pylint: disable=no-member, invalid-name, redefined-outer-name, too-many-function-args
-import importlib
-from collections import OrderedDict
-import os
-
-import numpy as np
-import pytest
-
-from ... import from_pystan
-
-from ...data.io_pystan import get_draws, get_draws_stan3  # pylint: disable=unused-import
-from ..helpers import (  # pylint: disable=unused-import
-    chains,
-    check_multiple_attrs,
-    draws,
-    eight_schools_params,
-    importorskip,
-    load_cached_models,
-    pystan_version,
-)
-
-# Check if either pystan or pystan3 is installed
-pystan_installed = (importlib.util.find_spec("pystan") is not None) or (
-    importlib.util.find_spec("stan") is not None
-)
-
-
-@pytest.mark.skipif(
-    not (pystan_installed or "ARVIZ_REQUIRE_ALL_DEPS" in os.environ),
-    reason="test requires pystan/pystan3 which is not installed",
-)
-class TestDataPyStan:
-    @pytest.fixture(scope="class")
-    def data(self, eight_schools_params, draws, chains):
-        class Data:
-            model, obj = load_cached_models(eight_schools_params, draws, chains, "pystan")["pystan"]
-
-        return Data
-
-    def get_inference_data(self, data, eight_schools_params):
-        """vars as str."""
-        return from_pystan(
-            posterior=data.obj,
-            posterior_predictive="y_hat",
-            predictions="y_hat",  # wrong, but fine for testing
-            prior=data.obj,
-            prior_predictive="y_hat",
-            observed_data="y",
-            constant_data="sigma",
-            predictions_constant_data="sigma",  # wrong, but fine for testing
-            log_likelihood={"y": "log_lik"},
-            coords={"school": np.arange(eight_schools_params["J"])},
-            dims={
-                "theta": ["school"],
-                "y": ["school"],
-                "sigma": ["school"],
-                "y_hat": ["school"],
-                "eta": ["school"],
-            },
-            posterior_model=data.model,
-            prior_model=data.model,
-        )
-
-    def get_inference_data2(self, data, eight_schools_params):
-        """vars as lists."""
-        return from_pystan(
-            posterior=data.obj,
-            posterior_predictive=["y_hat"],
-            predictions=["y_hat"],  # wrong, but fine for testing
-            prior=data.obj,
-            prior_predictive=["y_hat"],
-            observed_data=["y"],
-            log_likelihood="log_lik",
-            coords={
-                "school": np.arange(eight_schools_params["J"]),
-                "log_likelihood_dim": np.arange(eight_schools_params["J"]),
-            },
-            dims={
-                "theta": ["school"],
-                "y": ["school"],
-                "y_hat": ["school"],
-                "eta": ["school"],
-                "log_lik": ["log_likelihood_dim"],
-            },
-            posterior_model=data.model,
-            prior_model=data.model,
-        )
-
-    def get_inference_data3(self, data, eight_schools_params):
-        """multiple vars as lists."""
-        return from_pystan(
-            posterior=data.obj,
-            posterior_predictive=["y_hat", "log_lik"],  # wrong, but fine for testing
-            predictions=["y_hat", "log_lik"],  # wrong, but fine for testing
-            prior=data.obj,
-            prior_predictive=["y_hat", "log_lik"],  # wrong, but fine for testing
-            constant_data=["sigma", "y"],  # wrong, but fine for testing
-            predictions_constant_data=["sigma", "y"],  # wrong, but fine for testing
-            coords={"school": np.arange(eight_schools_params["J"])},
-            dims={
-                "theta": ["school"],
-                "y": ["school"],
-                "sigma": ["school"],
-                "y_hat": ["school"],
-                "eta": ["school"],
-            },
-            posterior_model=data.model,
-            prior_model=data.model,
-        )
-
-    def get_inference_data4(self, data):
-        """minimal input."""
-        return from_pystan(
-            posterior=data.obj,
-            posterior_predictive=None,
-            prior=data.obj,
-            prior_predictive=None,
-            coords=None,
-            dims=None,
-            posterior_model=data.model,
-            log_likelihood=[],
-            prior_model=data.model,
-            save_warmup=True,
-        )
-
-    def get_inference_data5(self, data):
-        """minimal input."""
-        return from_pystan(
-            posterior=data.obj,
-            posterior_predictive=None,
-            prior=data.obj,
-            prior_predictive=None,
-            coords=None,
-            dims=None,
-            posterior_model=data.model,
-            log_likelihood=False,
-            prior_model=data.model,
-            save_warmup=True,
-            dtypes={"eta": int},
-        )
-
-    def test_sampler_stats(self, data, eight_schools_params):
-        inference_data = self.get_inference_data(data, eight_schools_params)
-        test_dict = {"sample_stats": ["diverging"]}
-        fails = check_multiple_attrs(test_dict, inference_data)
-        assert not fails
-
-    def test_inference_data(self, data, eight_schools_params):
-        inference_data1 = self.get_inference_data(data, eight_schools_params)
-        inference_data2 = self.get_inference_data2(data, eight_schools_params)
-        inference_data3 = self.get_inference_data3(data, eight_schools_params)
-        inference_data4 = self.get_inference_data4(data)
-        inference_data5 = self.get_inference_data5(data)
-        # inference_data 1
-        test_dict = {
-            "posterior": ["theta", "~log_lik"],
-            "posterior_predictive": ["y_hat"],
-            "predictions": ["y_hat"],
-            "observed_data": ["y"],
-            "constant_data": ["sigma"],
-            "predictions_constant_data": ["sigma"],
-            "sample_stats": ["diverging", "lp"],
-            "log_likelihood": ["y", "~log_lik"],
-            "prior": ["theta"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data1)
-        assert not fails
-        # inference_data 2
-        test_dict = {
-            "posterior_predictive": ["y_hat"],
-            "predictions": ["y_hat"],
-            "observed_data": ["y"],
-            "sample_stats_prior": ["diverging"],
-            "sample_stats": ["diverging", "lp"],
-            "log_likelihood": ["log_lik"],
-            "prior_predictive": ["y_hat"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data2)
-        assert not fails
-        assert any(
-            item in inference_data2.posterior.attrs for item in ["stan_code", "program_code"]
-        )
-        assert any(
-            item in inference_data2.sample_stats.attrs for item in ["stan_code", "program_code"]
-        )
-        # inference_data 3
-        test_dict = {
-            "posterior_predictive": ["y_hat", "log_lik"],
-            "predictions": ["y_hat", "log_lik"],
-            "constant_data": ["sigma", "y"],
-            "predictions_constant_data": ["sigma", "y"],
-            "sample_stats_prior": ["diverging"],
-            "sample_stats": ["diverging", "lp"],
-            "log_likelihood": ["log_lik"],
-            "prior_predictive": ["y_hat", "log_lik"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data3)
-        assert not fails
-        # inference_data 4
-        test_dict = {
-            "posterior": ["theta"],
-            "prior": ["theta"],
-            "sample_stats": ["diverging", "lp"],
-            "~log_likelihood": [""],
-            "warmup_posterior": ["theta"],
-            "warmup_sample_stats": ["diverging", "lp"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data4)
-        assert not fails
-        # inference_data 5
-        test_dict = {
-            "posterior": ["theta"],
-            "prior": ["theta"],
-            "sample_stats": ["diverging", "lp"],
-            "~log_likelihood": [""],
-            "warmup_posterior": ["theta"],
-            "warmup_sample_stats": ["diverging", "lp"],
-        }
-        fails = check_multiple_attrs(test_dict, inference_data5)
-        assert not fails
-        assert inference_data5.posterior.eta.dtype.kind == "i"
-
-    def test_invalid_fit(self, data):
-        if pystan_version() == 2:
-            model = data.model
-            model_data = {
-                "J": 8,
-                "y": np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]),
-                "sigma": np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]),
-            }
-            fit_test_grad = model.sampling(
-                data=model_data, test_grad=True, check_hmc_diagnostics=False
-            )
-            with pytest.raises(AttributeError):
-                _ = from_pystan(posterior=fit_test_grad)
-            fit = model.sampling(data=model_data, iter=100, chains=1, check_hmc_diagnostics=False)
-            del fit.sim["samples"]
-            with pytest.raises(AttributeError):
-                _ = from_pystan(posterior=fit)
-
-    def test_empty_parameter(self):
-        model_code = """
-            parameters {
-                real y;
-                vector[3] x;
-                vector[0] a;
-                vector[2] z;
-            }
-            model {
-                y ~ normal(0,1);
-            }
-        """
-        if pystan_version() == 2:
-            from pystan import StanModel  # pylint: disable=import-error
-
-            model = StanModel(model_code=model_code)
-            fit = model.sampling(iter=500, chains=2, check_hmc_diagnostics=False)
-        else:
-            import stan  # pylint: disable=import-error
-
-            model = stan.build(model_code)
-            fit = model.sample(num_samples=500, num_chains=2)
-
-        posterior = from_pystan(posterior=fit)
-        test_dict = {"posterior": ["y", "x", "z", "~a"], "sample_stats": ["diverging"]}
-        fails = check_multiple_attrs(test_dict, posterior)
-        assert not fails
-
-    def test_get_draws(self, data):
-        fit = data.obj
-        if pystan_version() == 2:
-            draws, _ = get_draws(fit, variables=["theta", "theta"])
-        else:
-            draws, _ = get_draws_stan3(fit, variables=["theta", "theta"])
-        assert draws.get("theta") is not None
-
-    @pytest.mark.skipif(pystan_version() != 2, reason="PyStan 2.x required")
-    def test_index_order(self, data, eight_schools_params):
-        """Test 0-indexed data."""
-        # Skip test if pystan not installed
-        pystan = importorskip("pystan")  # pylint: disable=import-error
-
-        fit = data.model.sampling(data=eight_schools_params)
-        if pystan.__version__ >= "2.18":
-            # make 1-indexed to 0-indexed
-            for holder in fit.sim["samples"]:
-                new_chains = OrderedDict()
-                for i, (key, values) in enumerate(holder.chains.items()):
-                    if "[" in key:
-                        name, *shape = key.replace("]", "").split("[")
-                        shape = [str(int(item) - 1) for items in shape for item in items.split(",")]
-                        key = f"{name}[{','.join(shape)}]"
-                    new_chains[key] = np.full_like(values, fill_value=float(i))
-                setattr(holder, "chains", new_chains)
-            fit.sim["fnames_oi"] = list(fit.sim["samples"][0].chains.keys())
-        idata = from_pystan(posterior=fit)
-        assert idata is not None
-        for j, fpar in enumerate(fit.sim["fnames_oi"]):
-            par, *shape = fpar.replace("]", "").split("[")
-            if par in {"lp__", "log_lik"}:
-                continue
-            assert hasattr(idata.posterior, par), (par, list(idata.posterior.data_vars))
-            if shape:
-                shape = [slice(None), slice(None)] + list(map(int, shape))
-                assert idata.posterior[par][tuple(shape)].values.mean() == float(j)
-            else:
-                assert idata.posterior[par].values.mean() == float(j)