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

arviz/wrappers/__init__.py

@@ -1,13 +0,0 @@
-"""Sampling wrappers."""
-
-from .base import SamplingWrapper
-from .wrap_stan import PyStan2SamplingWrapper, PyStanSamplingWrapper, CmdStanPySamplingWrapper
-from .wrap_pymc import PyMCSamplingWrapper
-
-__all__ = [
-    "CmdStanPySamplingWrapper",
-    "PyMCSamplingWrapper",
-    "PyStan2SamplingWrapper",
-    "PyStanSamplingWrapper",
-    "SamplingWrapper",
-]

arviz/wrappers/base.py

@@ -1,236 +0,0 @@
-# pylint: disable=too-many-instance-attributes,too-many-arguments
-"""Base class for sampling wrappers."""
-from xarray import apply_ufunc
-
-# from ..data import InferenceData
-from ..stats import wrap_xarray_ufunc as _wrap_xarray_ufunc
-
-
-class SamplingWrapper:
-    """Class wrapping sampling routines for its usage via ArviZ.
-
-    Using a common class, all inference backends can be supported in ArviZ. Hence, statistical
-    functions requiring refitting like Leave Future Out or Simulation Based Calibration can be
-    performed from ArviZ.
-
-    For usage examples see user guide pages on :ref:`wrapper_guide`.See other
-    SamplingWrapper classes at :ref:`wrappers api section <wrappers_api>`.
-
-    Parameters
-    ----------
-    model
-        The model object used for sampling.
-    idata_orig : InferenceData, optional
-        Original InferenceData object.
-    log_lik_fun : callable, optional
-        For simple cases where the pointwise log likelihood is a Python function, this
-        function will be used to calculate the log likelihood. Otherwise,
-        ``point_log_likelihood`` method must be implemented. It's callback must be
-        ``log_lik_fun(*args, **log_lik_kwargs)`` and will be called using
-        :func:`wrap_xarray_ufunc` or :func:`xarray:xarray.apply_ufunc` depending
-        on the value of `is_ufunc`.
-
-        For more details on ``args`` or ``log_lik_kwargs`` see the notes and
-        parameters ``posterior_vars`` and ``log_lik_kwargs``.
-    is_ufunc : bool, default True
-        If True, call ``log_lik_fun`` using :func:`xarray:xarray.apply_ufunc` otherwise
-        use :func:`wrap_xarray_ufunc`.
-    posterior_vars : list of str, optional
-        List of variable names to unpack as ``args`` for ``log_lik_fun``. Each string in
-        the list will be used to retrieve a DataArray from the Dataset in the posterior
-        group and passed to ``log_lik_fun``.
-    sample_kwargs : dict, optional
-        Sampling kwargs are stored as class attributes for their usage in the ``sample``
-        method.
-    idata_kwargs : dict, optional
-        kwargs are stored as class attributes to be used in the ``get_inference_data`` method.
-    log_lik_kwargs : dict, optional
-        Keyword arguments passed to ``log_lik_fun``.
-    apply_ufunc_kwargs : dict, optional
-        Passed to :func:`xarray:xarray.apply_ufunc` or :func:`wrap_xarray_ufunc`.
-
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-
-    Notes
-    -----
-    Example of ``log_like_fun`` usage.
-    """
-
-    def __init__(
-        self,
-        model,
-        idata_orig=None,
-        log_lik_fun=None,
-        is_ufunc=True,
-        posterior_vars=None,
-        sample_kwargs=None,
-        idata_kwargs=None,
-        log_lik_kwargs=None,
-        apply_ufunc_kwargs=None,
-    ):
-        self.model = model
-
-        # if not isinstance(idata_orig, InferenceData) or idata_orig is not None:
-        #     raise TypeError("idata_orig must be of InferenceData type or None")
-        self.idata_orig = idata_orig
-
-        if log_lik_fun is None or callable(log_lik_fun):
-            self.log_lik_fun = log_lik_fun
-            self.is_ufunc = is_ufunc
-            self.posterior_vars = posterior_vars
-        else:
-            raise TypeError("log_like_fun must be a callable object or None")
-
-        self.sample_kwargs = {} if sample_kwargs is None else sample_kwargs
-        self.idata_kwargs = {} if idata_kwargs is None else idata_kwargs
-        self.log_lik_kwargs = {} if log_lik_kwargs is None else log_lik_kwargs
-        self.apply_ufunc_kwargs = {} if apply_ufunc_kwargs is None else apply_ufunc_kwargs
-
-    def sel_observations(self, idx):
-        """Select a subset of the observations in idata_orig.
-
-        **Not implemented**: This method must be implemented by the SamplingWrapper subclasses.
-        It is documented here to show its format and call signature.
-
-        Parameters
-        ----------
-        idx
-            Indexes to separate from the rest of the observed data.
-
-        Returns
-        -------
-        modified_observed_data
-            Observed data whose index is *not* ``idx``
-        excluded_observed_data
-            Observed data whose index is ``idx``
-        """
-        raise NotImplementedError("sel_observations method must be implemented for each subclass")
-
-    def sample(self, modified_observed_data):
-        """Sample ``self.model`` on the ``modified_observed_data`` subset.
-
-        **Not implemented**: This method must be implemented by the SamplingWrapper subclasses.
-        It is documented here to show its format and call signature.
-
-        Parameters
-        ----------
-        modified_observed_data
-            Data to fit the model on.
-
-        Returns
-        -------
-        fitted_model
-            Result of the fit.
-        """
-        raise NotImplementedError("sample method must be implemented for each subclass")
-
-    def get_inference_data(self, fitted_model):
-        """Convert the ``fitted_model`` to an InferenceData object.
-
-        **Not implemented**: This method must be implemented by the SamplingWrapper subclasses.
-        It is documented here to show its format and call signature.
-
-        Parameters
-        ----------
-        fitted_model
-            Result of the current fit.
-
-        Returns
-        -------
-        idata_current: InferenceData
-            InferenceData object containing the samples in ``fitted_model``
-        """
-        raise NotImplementedError("get_inference_data method must be implemented for each subclass")
-
-    def log_likelihood__i(self, excluded_obs, idata__i):
-        r"""Get the log likelilhood samples :math:`\log p_{post(-i)}(y_i)`.
-
-        Calculate the log likelihood of the data contained in excluded_obs using the
-        model fitted with this data excluded, the results of which are stored in ``idata__i``.
-
-        Parameters
-        ----------
-        excluded_obs
-            Observations for which to calculate their log likelihood. The second item from
-            the tuple returned by `sel_observations` is passed as this argument.
-        idata__i: InferenceData
-            Inference results of refitting the data excluding some observations. The
-            result of `get_inference_data` is used as this argument.
-
-        Returns
-        -------
-        log_likelihood: xr.Dataarray
-            Log likelihood of ``excluded_obs`` evaluated at each of the posterior samples
-            stored in ``idata__i``.
-        """
-        if self.log_lik_fun is None:
-            raise NotImplementedError(
-                "When `log_like_fun` is not set during class initialization "
-                "log_likelihood__i method must be overwritten"
-            )
-        posterior = idata__i.posterior
-        arys = (*excluded_obs, *[posterior[var_name] for var_name in self.posterior_vars])
-        ufunc_applier = apply_ufunc if self.is_ufunc else _wrap_xarray_ufunc
-        log_lik_idx = ufunc_applier(
-            self.log_lik_fun,
-            *arys,
-            kwargs=self.log_lik_kwargs,
-            **self.apply_ufunc_kwargs,
-        )
-        return log_lik_idx
-
-    def _check_method_is_implemented(self, method, *args):
-        """Check a given method is implemented."""
-        try:
-            getattr(self, method)(*args)
-        except NotImplementedError:
-            return False
-        except:  # pylint: disable=bare-except
-            return True
-        return True
-
-    def check_implemented_methods(self, methods):
-        """Check that all methods listed are implemented.
-
-        Not all functions that require refitting need to have all the methods implemented in
-        order to work properly. This function should be used before using the SamplingWrapper and
-        its subclasses to get informative error messages.
-
-        Parameters
-        ----------
-        methods: list
-            Check all elements in methods are implemented.
-
-        Returns
-        -------
-            List with all non implemented methods
-        """
-        supported_methods_1arg = (
-            "sel_observations",
-            "sample",
-            "get_inference_data",
-        )
-        supported_methods_2args = ("log_likelihood__i",)
-        supported_methods = [*supported_methods_1arg, *supported_methods_2args]
-        bad_methods = [method for method in methods if method not in supported_methods]
-        if bad_methods:
-            raise ValueError(
-                f"Not all method(s) in {bad_methods} supported. "
-                f"Supported methods in SamplingWrapper subclasses are:{supported_methods}"
-            )
-
-        not_implemented = []
-        for method in methods:
-            if method in supported_methods_1arg:
-                if self._check_method_is_implemented(method, 1):
-                    continue
-                not_implemented.append(method)
-            elif method in supported_methods_2args:
-                if self._check_method_is_implemented(method, 1, 1):
-                    continue
-                not_implemented.append(method)
-        return not_implemented

arviz/wrappers/wrap_pymc.py

@@ -1,36 +0,0 @@
-# pylint: disable=arguments-differ
-"""Base class for PyMC interface wrappers."""
-from .base import SamplingWrapper
-
-
-# pylint: disable=abstract-method
-class PyMCSamplingWrapper(SamplingWrapper):
-    """PyMC (4.0+) sampling wrapper base class.
-
-    See the documentation on  :class:`~arviz.SamplingWrapper` for a more detailed
-    description. An example of ``PyMCSamplingWrapper`` usage can be found
-    in the :ref:`pymc_refitting` notebook.
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-    """
-
-    def sample(self, modified_observed_data):
-        """Update data and sample model on modified_observed_data."""
-        import pymc  # pylint: disable=import-error
-
-        with self.model:
-            pymc.set_data(modified_observed_data)
-            idata = pymc.sample(
-                **self.sample_kwargs,
-            )
-        return idata
-
-    def get_inference_data(self, fitted_model):
-        """Return sampling result without modifying.
-
-        PyMC sampling already returns and InferenceData object.
-        """
-        return fitted_model

arviz/wrappers/wrap_stan.py

@@ -1,148 +0,0 @@
-# pylint: disable=arguments-differ
-"""Base class for Stan interface wrappers."""
-from typing import Union
-
-from ..data import from_cmdstanpy, from_pystan
-from .base import SamplingWrapper
-
-
-# pylint: disable=abstract-method
-class StanSamplingWrapper(SamplingWrapper):
-    """Stan sampling wrapper base class.
-
-    See the documentation on  :class:`~arviz.SamplingWrapper` for a more detailed
-    description. An example of ``PyStanSamplingWrapper`` usage can be found
-    in the :ref:`pystan_refitting` notebook. For usage examples of other wrappers
-    see the user guide pages on :ref:`wrapper_guide`.
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-
-    See Also
-    --------
-    SamplingWrapper
-    """
-
-    def sel_observations(self, idx):
-        """Select a subset of the observations in idata_orig.
-
-        **Not implemented**: This method must be implemented on a model basis.
-        It is documented here to show its format and call signature.
-
-        Parameters
-        ----------
-        idx
-            Indexes to separate from the rest of the observed data.
-
-        Returns
-        -------
-        modified_observed_data : dict
-            Dictionary containing both excluded and included data but properly divided
-            in the different keys. Passed to ``data`` argument of ``model.sampling``.
-        excluded_observed_data : str
-            Variable name containing the pointwise log likelihood data of the excluded
-            data. As PyStan cannot call C++ functions and log_likelihood__i is already
-            calculated *during* the simulation, instead of the value on which to evaluate
-            the likelihood, ``log_likelihood__i`` expects a string so it can extract the
-            corresponding data from the InferenceData object.
-        """
-        raise NotImplementedError("sel_observations must be implemented on a model basis")
-
-    def get_inference_data(self, fitted_model):  # pylint: disable=arguments-renamed
-        """Convert the fit object returned by ``self.sample`` to InferenceData."""
-        if fitted_model.__class__.__name__ == "CmdStanMCMC":
-            idata = from_cmdstanpy(posterior=fitted_model, **self.idata_kwargs)
-        else:
-            idata = from_pystan(posterior=fitted_model, **self.idata_kwargs)
-        return idata
-
-    def log_likelihood__i(self, excluded_obs, idata__i):
-        """Retrieve the log likelihood of the excluded observations from ``idata__i``."""
-        return idata__i.log_likelihood[excluded_obs]
-
-
-class PyStan2SamplingWrapper(StanSamplingWrapper):
-    """PyStan (2.x) sampling wrapper base class.
-
-    See the documentation on  :class:`~arviz.SamplingWrapper` for a more detailed
-    description. An example of ``PyStanSamplingWrapper`` usage can be found
-    in the :ref:`pystan_refitting` notebook. For usage examples of other wrappers
-    see the user guide pages on :ref:`wrapper_guide`.
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-
-    See Also
-    --------
-    SamplingWrapper
-    """
-
-    def sample(self, modified_observed_data):
-        """Resample the PyStan model stored in self.model on modified_observed_data."""
-        fit = self.model.sampling(data=modified_observed_data, **self.sample_kwargs)
-        return fit
-
-
-class PyStanSamplingWrapper(StanSamplingWrapper):
-    """PyStan (3.0+) sampling wrapper base class.
-
-    See the documentation on  :class:`~arviz.SamplingWrapper` for a more detailed
-    description. An example of ``PyStanSamplingWrapper`` usage can be found
-    in the :ref:`pystan_refitting` notebook.
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-    """
-
-    def sample(self, modified_observed_data):
-        """Rebuild and resample the PyStan model on modified_observed_data."""
-        import stan  # pylint: disable=import-error,import-outside-toplevel
-
-        self.model: Union[str, stan.Model]
-        if isinstance(self.model, str):
-            program_code = self.model
-        else:
-            program_code = self.model.program_code
-        self.model = stan.build(program_code, data=modified_observed_data)
-        fit = self.model.sample(**self.sample_kwargs)
-        return fit
-
-
-class CmdStanPySamplingWrapper(StanSamplingWrapper):
-    """CmdStanPy sampling wrapper base class.
-
-    See the documentation on  :class:`~arviz.SamplingWrapper` for a more detailed
-    description. An example of ``CmdStanPySamplingWrapper`` usage can be found
-    in the :ref:`cmdstanpy_refitting` notebook.
-
-    Warnings
-    --------
-    Sampling wrappers are an experimental feature in a very early stage. Please use them
-    with caution.
-    """
-
-    def __init__(self, data_file, **kwargs):
-        """Initialize the CmdStanPySamplingWrapper.
-
-        Parameters
-        ----------
-        data_file : str
-            Filename on which to store the data for every refit.
-            It's contents will be overwritten.
-        """
-        super().__init__(**kwargs)
-        self.data_file = data_file
-
-    def sample(self, modified_observed_data):
-        """Resample cmdstanpy model on modified_observed_data."""
-        from cmdstanpy import write_stan_json
-
-        write_stan_json(self.data_file, modified_observed_data)
-        fit = self.model.sample(**{**self.sample_kwargs, "data": self.data_file})
-        return fit