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

arviz/data/io_zarr.py

@@ -1,46 +0,0 @@
-"""Input and output support for zarr data."""
-
-from .converters import convert_to_inference_data
-from .inference_data import InferenceData
-
-
-def from_zarr(store):
-    return InferenceData.from_zarr(store)
-
-
-from_zarr.__doc__ = InferenceData.from_zarr.__doc__
-
-
-def to_zarr(data, store=None, **kwargs):
-    """
-    Convert data to zarr, optionally saving to disk if ``store`` is provided.
-
-    The zarr storage is using the same group names as the InferenceData.
-
-    Parameters
-    ----------
-    store : zarr.storage, MutableMapping or str, optional
-        Zarr storage class or path to desired DirectoryStore.
-        Default (None) a store is created in a temporary directory.
-    **kwargs : dict, optional
-        Passed to :py:func:`convert_to_inference_data`.
-
-    Returns
-    -------
-    zarr.hierarchy.group
-        A zarr hierarchy group containing the InferenceData.
-
-    Raises
-    ------
-    TypeError
-        If no valid store is found.
-
-
-    References
-    ----------
-    https://zarr.readthedocs.io/
-
-    """
-    inference_data = convert_to_inference_data(data, **kwargs)
-    zarr_group = inference_data.to_zarr(store=store)
-    return zarr_group

arviz/data/utils.py

@@ -1,139 +0,0 @@
-"""Data specific utilities."""
-
-import warnings
-import numpy as np
-
-from ..utils import _var_names
-from .converters import convert_to_dataset
-
-
-def extract_dataset(
-    data,
-    group="posterior",
-    combined=True,
-    var_names=None,
-    filter_vars=None,
-    num_samples=None,
-    rng=None,
-):
-    """Extract an InferenceData group or subset of it.
-
-    .. deprecated:: 0.13
-            `extract_dataset` will be removed in ArviZ 0.14, it is replaced by
-            `extract` because the latter allows to obtain both DataSets and DataArrays.
-    """
-    warnings.warn(
-        "extract_dataset has been deprecated, please use extract", FutureWarning, stacklevel=2
-    )
-
-    data = extract(
-        data=data,
-        group=group,
-        combined=combined,
-        var_names=var_names,
-        filter_vars=filter_vars,
-        num_samples=num_samples,
-        rng=rng,
-    )
-    return data
-
-
-def extract(
-    data,
-    group="posterior",
-    combined=True,
-    var_names=None,
-    filter_vars=None,
-    num_samples=None,
-    keep_dataset=False,
-    rng=None,
-):
-    """Extract an InferenceData group or subset of it.
-
-    Parameters
-    ----------
-    idata : InferenceData or InferenceData_like
-        InferenceData from which to extract the data.
-    group : str, optional
-        Which InferenceData data group to extract data from.
-    combined : bool, optional
-        Combine ``chain`` and ``draw`` dimensions into ``sample``. Won't work if
-        a dimension named ``sample`` already exists.
-    var_names : str or list of str, optional
-        Variables to be extracted. Prefix the variables by `~` when you want to exclude them.
-    filter_vars: {None, "like", "regex"}, optional
-        If `None` (default), interpret var_names as the real variables names. If "like",
-        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`.
-        Like with plotting, sometimes it's easier to subset saying what to exclude
-        instead of what to include
-    num_samples : int, optional
-        Extract only a subset of the samples. Only valid if ``combined=True``
-    keep_dataset : bool, optional
-        If true, always return a DataSet. If false (default) return a DataArray
-        when there is a single variable.
-    rng : bool, int, numpy.Generator, optional
-        Shuffle the samples, only valid if ``combined=True``. By default,
-        samples are shuffled if ``num_samples`` is not ``None``, and are left
-        in the same order otherwise. This ensures that subsetting the samples doesn't return
-        only samples from a single chain and consecutive draws.
-
-    Returns
-    -------
-    xarray.DataArray or xarray.Dataset
-
-    Examples
-    --------
-    The default behaviour is to return the posterior group after stacking the chain and
-    draw dimensions.
-
-    .. jupyter-execute::
-
-        import arviz as az
-        idata = az.load_arviz_data("centered_eight")
-        az.extract(idata)
-
-    You can also indicate a subset to be returned, but in variables and in samples:
-
-    .. jupyter-execute::
-
-        az.extract(idata, var_names="theta", num_samples=100)
-
-    To keep the chain and draw dimensions, use ``combined=False``.
-
-    .. jupyter-execute::
-
-        az.extract(idata, group="prior", combined=False)
-
-    """
-    if num_samples is not None and not combined:
-        raise ValueError("num_samples is only compatible with combined=True")
-    if rng is None:
-        rng = num_samples is not None
-    if rng is not False and not combined:
-        raise ValueError("rng is only compatible with combined=True")
-    data = convert_to_dataset(data, group=group)
-    var_names = _var_names(var_names, data, filter_vars)
-    if var_names is not None:
-        if len(var_names) == 1 and not keep_dataset:
-            var_names = var_names[0]
-        data = data[var_names]
-    if combined:
-        data = data.stack(sample=("chain", "draw"))
-    # 0 is a valid seed se we need to check for rng being exactly boolean
-    if rng is not False:
-        if rng is True:
-            rng = np.random.default_rng()
-        # default_rng takes ints or sequences of ints
-        try:
-            rng = np.random.default_rng(rng)
-            random_subset = rng.permutation(np.arange(len(data["sample"])))
-        except TypeError as err:
-            raise TypeError("Unable to initializate numpy random Generator from rng") from err
-        except AttributeError as err:
-            raise AttributeError("Unable to use rng to generate a permutation") from err
-        data = data.isel(sample=random_subset)
-    if num_samples is not None:
-        data = data.isel(sample=slice(None, num_samples))
-    return data

arviz/labels.py

@@ -1,210 +0,0 @@
-# pylint: disable=unused-argument
-"""Utilities to generate labels from xarray objects."""
-from typing import Union
-
-__all__ = [
-    "mix_labellers",
-    "BaseLabeller",
-    "DimCoordLabeller",
-    "DimIdxLabeller",
-    "MapLabeller",
-    "NoVarLabeller",
-    "NoModelLabeller",
-]
-
-
-def mix_labellers(labellers, class_name="MixtureLabeller"):
-    """Combine Labeller classes dynamically.
-
-    The Labeller class aims to split plot labeling in ArviZ into atomic tasks to maximize
-    extensibility, and the few classes provided are designed with small deviations
-    from the base class, in many cases only one method is modified by the child class.
-    It is to be expected then to want to use multiple classes "at once".
-
-    This functions helps combine classes dynamically.
-
-    For a general overview of ArviZ label customization, including
-    ``mix_labellers``, see the :ref:`label_guide` page.
-
-    Parameters
-    ----------
-    labellers : iterable of types
-        Iterable of Labeller types to combine
-    class_name : str, optional
-        The name of the generated class
-
-    Returns
-    -------
-        type
-            Mixture class object. **It is not initialized**, and it should be
-            initialized before passing it to ArviZ functions.
-
-    Examples
-    --------
-    Combine the :class:`~arviz.labels.DimCoordLabeller` with the
-    :class:`~arviz.labels.MapLabeller` to generate labels in the style of the
-    ``DimCoordLabeller`` but using the mappings defined by ``MapLabeller``.
-    Note that this works even though both modify the same methods because
-    ``MapLabeller`` implements the mapping and then calls `super().method`.
-
-    .. jupyter-execute::
-
-        from arviz.labels import mix_labellers, DimCoordLabeller, MapLabeller
-        l1 = DimCoordLabeller()
-        sel = {"dim1": "a", "dim2": "top"}
-        print(f"Output of DimCoordLabeller alone > {l1.sel_to_str(sel, sel)}")
-        l2 = MapLabeller(dim_map={"dim1": "$d_1$", "dim2": r"$d_2$"})
-        print(f"Output of MapLabeller alone > {l2.sel_to_str(sel, sel)}")
-        l3 = mix_labellers(
-            (MapLabeller, DimCoordLabeller)
-        )(dim_map={"dim1": "$d_1$", "dim2": r"$d_2$"})
-        print(f"Output of mixture labeller > {l3.sel_to_str(sel, sel)}")
-
-    We can see how the mappings are taken into account as well as the dim+coord style. However,
-    he order in the ``labellers`` arg iterator is important! See for yourself:
-
-    .. jupyter-execute::
-
-        l4 = mix_labellers(
-            (DimCoordLabeller, MapLabeller)
-        )(dim_map={"dim1": "$d_1$", "dim2": r"$d_2$"})
-        print(f"Output of inverted mixture labeller > {l4.sel_to_str(sel, sel)}")
-
-    """
-    return type(class_name, labellers, {})
-
-
-class BaseLabeller:
-    """WIP."""
-
-    def dim_coord_to_str(self, dim, coord_val, coord_idx):
-        """WIP."""
-        return f"{coord_val}"
-
-    def sel_to_str(self, sel: dict, isel: dict):
-        """WIP."""
-        if sel:
-            return ", ".join(
-                [
-                    self.dim_coord_to_str(dim, v, i)
-                    for (dim, v), (_, i) in zip(sel.items(), isel.items())
-                ]
-            )
-        return ""
-
-    def var_name_to_str(self, var_name: Union[str, None]):
-        """WIP."""
-        return var_name
-
-    def var_pp_to_str(self, var_name, pp_var_name):
-        """WIP."""
-        var_name_str = self.var_name_to_str(var_name)
-        pp_var_name_str = self.var_name_to_str(pp_var_name)
-        if var_name_str == pp_var_name_str:
-            return f"{var_name_str}"
-        return f"{var_name_str} / {pp_var_name_str}"
-
-    def model_name_to_str(self, model_name):
-        """WIP."""
-        return model_name
-
-    def make_label_vert(self, var_name: Union[str, None], sel: dict, isel: dict):
-        """WIP."""
-        var_name_str = self.var_name_to_str(var_name)
-        sel_str = self.sel_to_str(sel, isel)
-        if not sel_str:
-            return "" if var_name_str is None else var_name_str
-        if var_name_str is None:
-            return sel_str
-        return f"{var_name_str}\n{sel_str}"
-
-    def make_label_flat(self, var_name: str, sel: dict, isel: dict):
-        """WIP."""
-        var_name_str = self.var_name_to_str(var_name)
-        sel_str = self.sel_to_str(sel, isel)
-        if not sel_str:
-            return "" if var_name_str is None else var_name_str
-        if var_name_str is None:
-            return sel_str
-        return f"{var_name_str}[{sel_str}]"
-
-    def make_pp_label(self, var_name, pp_var_name, sel, isel):
-        """WIP."""
-        names = self.var_pp_to_str(var_name, pp_var_name)
-        return self.make_label_vert(names, sel, isel)
-
-    def make_model_label(self, model_name, label):
-        """WIP."""
-        model_name_str = self.model_name_to_str(model_name)
-        if model_name_str is None:
-            return label
-        if label is None or label == "":
-            return model_name_str
-        return f"{model_name_str}: {label}"
-
-
-class DimCoordLabeller(BaseLabeller):
-    """WIP."""
-
-    def dim_coord_to_str(self, dim, coord_val, coord_idx):
-        """WIP."""
-        return f"{dim}: {coord_val}"
-
-
-class IdxLabeller(BaseLabeller):
-    """WIP."""
-
-    def dim_coord_to_str(self, dim, coord_val, coord_idx):
-        """WIP."""
-        return f"{coord_idx}"
-
-
-class DimIdxLabeller(BaseLabeller):
-    """WIP."""
-
-    def dim_coord_to_str(self, dim, coord_val, coord_idx):
-        """WIP."""
-        return f"{dim}#{coord_idx}"
-
-
-class MapLabeller(BaseLabeller):
-    """WIP."""
-
-    def __init__(self, var_name_map=None, dim_map=None, coord_map=None, model_name_map=None):
-        """WIP."""
-        self.var_name_map = {} if var_name_map is None else var_name_map
-        self.dim_map = {} if dim_map is None else dim_map
-        self.coord_map = {} if coord_map is None else coord_map
-        self.model_name_map = {} if model_name_map is None else model_name_map
-
-    def dim_coord_to_str(self, dim, coord_val, coord_idx):
-        """WIP."""
-        dim_str = self.dim_map.get(dim, dim)
-        coord_str = self.coord_map.get(dim, {}).get(coord_val, coord_val)
-        return super().dim_coord_to_str(dim_str, coord_str, coord_idx)
-
-    def var_name_to_str(self, var_name):
-        """WIP."""
-        var_name_str = self.var_name_map.get(var_name, var_name)
-        return super().var_name_to_str(var_name_str)
-
-    def model_name_to_str(self, model_name):
-        """WIP."""
-        model_name_str = self.var_name_map.get(model_name, model_name)
-        return super().model_name_to_str(model_name_str)
-
-
-class NoVarLabeller(BaseLabeller):
-    """WIP."""
-
-    def var_name_to_str(self, var_name):
-        """WIP."""
-        return None
-
-
-class NoModelLabeller(BaseLabeller):
-    """WIP."""
-
-    def make_model_label(self, model_name, label):
-        """WIP."""
-        return label

arviz/plots/__init__.py

@@ -1,61 +0,0 @@
-"""Plotting functions."""
-
-from .autocorrplot import plot_autocorr
-from .bpvplot import plot_bpv
-from .bfplot import plot_bf
-from .compareplot import plot_compare
-from .densityplot import plot_density
-from .distcomparisonplot import plot_dist_comparison
-from .distplot import plot_dist
-from .dotplot import plot_dot
-from .ecdfplot import plot_ecdf
-from .elpdplot import plot_elpd
-from .energyplot import plot_energy
-from .essplot import plot_ess
-from .forestplot import plot_forest
-from .hdiplot import plot_hdi
-from .kdeplot import plot_kde
-from .khatplot import plot_khat
-from .lmplot import plot_lm
-from .loopitplot import plot_loo_pit
-from .mcseplot import plot_mcse
-from .pairplot import plot_pair
-from .parallelplot import plot_parallel
-from .posteriorplot import plot_posterior
-from .ppcplot import plot_ppc
-from .rankplot import plot_rank
-from .separationplot import plot_separation
-from .traceplot import plot_trace
-from .tsplot import plot_ts
-from .violinplot import plot_violin
-
-__all__ = [
-    "plot_autocorr",
-    "plot_bpv",
-    "plot_bf",
-    "plot_compare",
-    "plot_density",
-    "plot_dist",
-    "plot_dot",
-    "plot_ecdf",
-    "plot_elpd",
-    "plot_energy",
-    "plot_ess",
-    "plot_forest",
-    "plot_hdi",
-    "plot_kde",
-    "plot_khat",
-    "plot_lm",
-    "plot_loo_pit",
-    "plot_mcse",
-    "plot_pair",
-    "plot_parallel",
-    "plot_posterior",
-    "plot_ppc",
-    "plot_dist_comparison",
-    "plot_rank",
-    "plot_trace",
-    "plot_ts",
-    "plot_violin",
-    "plot_separation",
-]

arviz/plots/autocorrplot.py

@@ -1,171 +0,0 @@
-"""Autocorrelation plot of data."""
-
-from ..data import convert_to_dataset
-from ..labels import BaseLabeller
-from ..sel_utils import xarray_var_iter
-from ..rcparams import rcParams
-from ..utils import _var_names, get_coords
-from .plot_utils import default_grid, filter_plotters_list, get_plotting_function
-
-
-def plot_autocorr(
-    data,
-    var_names=None,
-    filter_vars=None,
-    max_lag=None,
-    combined=False,
-    coords=None,
-    grid=None,
-    figsize=None,
-    textsize=None,
-    labeller=None,
-    ax=None,
-    backend=None,
-    backend_config=None,
-    backend_kwargs=None,
-    show=None,
-):
-    r"""Bar plot of the autocorrelation function (ACF) for a sequence of data.
-
-    The ACF plots are helpful as a convergence diagnostic for posteriors from MCMC
-    samples which display autocorrelation.
-
-    Parameters
-    ----------
-    data : InferenceData
-        Any object that can be converted to an :class:`arviz.InferenceData` object
-        refer to documentation of :func:`arviz.convert_to_dataset` for details
-    var_names : list of str, optional
-        Variables to be plotted. Prefix the variables by ``~`` when you want to exclude
-        them from the plot. See :ref:`this section <common_var_names>` for usage examples.
-    filter_vars : {None, "like", "regex"}, default None
-        If `None` (default), interpret `var_names` as the real variables names. If "like",
-        interpret `var_names` as substrings of the real variables names. If "regex",
-        interpret `var_names` as regular expressions on the real variables names. See
-        :ref:`this section <common_filter_vars>` for usage examples.
-    coords: mapping, optional
-        Coordinates of var_names to be plotted. Passed to :meth:`xarray.Dataset.sel`
-    max_lag : int, optional
-        Maximum lag to calculate autocorrelation. By Default, the plot displays the
-        first 100 lag or the total number of draws, whichever is smaller.
-    combined : bool, default False
-        Flag for combining multiple chains into a single chain. If False, chains will be
-        plotted separately.
-    grid : tuple, optional
-        Number of rows and columns. Defaults to None, the rows and columns are
-        automatically inferred. See :ref:`this section <common_grid>` for usage examples.
-    figsize : (float, float), optional
-        Figure size. If None it will be defined automatically.
-        Note this is not used if `ax` is supplied.
-    textsize : float, optional
-        Text size scaling factor for labels, titles and lines. If None it will be autoscaled based
-        on `figsize`.
-    labeller : Labeller, optional
-        Class providing the method ``make_label_vert`` to generate the labels in the plot titles.
-        Read the :ref:`label_guide` for more details and usage examples.
-    ax : 2D array-like of matplotlib_axes or bokeh_figure, optional
-        A 2D array of locations into which to plot the densities. If not supplied, ArviZ will create
-        its own array of plot areas (and return it).
-    backend : {"matplotlib", "bokeh"}, default "matplotlib"
-        Select plotting backend.
-    backend_config : dict, optional
-        Currently specifies the bounds to use for bokeh axes. Defaults to value set in ``rcParams``.
-    backend_kwargs : dict, optional
-        These are kwargs specific to the backend being used, passed to
-        :func:`matplotlib.pyplot.subplots` or :class:`bokeh.plotting.figure`.
-        For additional documentation check the plotting method of the backend.
-    show : bool, optional
-        Call backend show function.
-
-    Returns
-    -------
-    axes : matplotlib_axes or bokeh_figures
-
-    See Also
-    --------
-    autocov : Compute autocovariance estimates for every lag for the input array.
-    autocorr : Compute autocorrelation using FFT for every lag for the input array.
-
-    Examples
-    --------
-    Plot default autocorrelation
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> data = az.load_arviz_data('centered_eight')
-        >>> az.plot_autocorr(data)
-
-    Plot subset variables by specifying variable name exactly
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_autocorr(data, var_names=['mu', 'tau'] )
-
-
-    Combine chains by variable and select variables by excluding some with partial naming
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_autocorr(data, var_names=['~thet'], filter_vars="like", combined=True)
-
-
-    Specify maximum lag (x axis bound)
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_autocorr(data, var_names=['mu', 'tau'], max_lag=200, combined=True)
-    """
-    data = convert_to_dataset(data, group="posterior")
-    var_names = _var_names(var_names, data, filter_vars)
-
-    # Default max lag to 100 or max length of chain
-    if max_lag is None:
-        max_lag = min(100, data["draw"].shape[0])
-
-    if coords is None:
-        coords = {}
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    plotters = filter_plotters_list(
-        list(
-            xarray_var_iter(
-                get_coords(data, coords), var_names, combined, dim_order=["chain", "draw"]
-            )
-        ),
-        "plot_autocorr",
-    )
-    rows, cols = default_grid(len(plotters), grid=grid)
-
-    autocorr_plot_args = dict(
-        axes=ax,
-        plotters=plotters,
-        max_lag=max_lag,
-        figsize=figsize,
-        rows=rows,
-        cols=cols,
-        combined=combined,
-        textsize=textsize,
-        labeller=labeller,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    if backend == "bokeh":
-        autocorr_plot_args.update(backend_config=backend_config)
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_autocorr", "autocorrplot", backend)
-    axes = plot(**autocorr_plot_args)
-
-    return axes