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

arviz/plots/compareplot.py

@@ -1,177 +0,0 @@
-"""Summary plot for model comparison."""
-
-import numpy as np
-
-from ..labels import BaseLabeller
-from ..rcparams import rcParams
-from .plot_utils import get_plotting_function
-
-
-def plot_compare(
-    comp_df,
-    insample_dev=False,
-    plot_standard_error=True,
-    plot_ic_diff=False,
-    order_by_rank=True,
-    legend=False,
-    title=True,
-    figsize=None,
-    textsize=None,
-    labeller=None,
-    plot_kwargs=None,
-    ax=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    r"""Summary plot for model comparison.
-
-    Models are compared based on their expected log pointwise predictive density (ELPD).
-    This plot is in the style of the one used in [2]_. Chapter 6 in the first edition
-    or 7 in the second.
-
-    Notes
-    -----
-    The ELPD is estimated either by Pareto smoothed importance sampling leave-one-out
-    cross-validation (LOO) or using the widely applicable information criterion (WAIC).
-    We recommend LOO in line with the work presented by [1]_.
-
-    Parameters
-    ----------
-    comp_df : pandas.DataFrame
-        Result of the :func:`arviz.compare` method.
-    insample_dev : bool, default False
-        Plot in-sample ELPD, that is the value of the information criteria without the
-        penalization given by the effective number of parameters (p_loo or p_waic).
-    plot_standard_error : bool, default True
-        Plot the standard error of the ELPD.
-    plot_ic_diff : bool, default False
-        Plot standard error of the difference in ELPD between each model
-        and the top-ranked model.
-    order_by_rank : bool, default True
-        If True ensure the best model is used as reference.
-    legend : bool, default False
-        Add legend to figure.
-    figsize : (float, float), optional
-        If `None`, size is (6, num of models) inches.
-    title : bool, default True
-        Show a tittle with a description of how to interpret the plot.
-    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.
-    plot_kwargs : dict, optional
-        Optional arguments for plot elements. Currently accepts 'color_ic',
-        'marker_ic', 'color_insample_dev', 'marker_insample_dev', 'color_dse',
-        'marker_dse', 'ls_min_ic' 'color_ls_min_ic',  'fontsize'
-    ax : matplotlib_axes or bokeh_figure, optional
-        Matplotlib axes or bokeh figure.
-    backend : {"matplotlib", "bokeh"}, default "matplotlib"
-        Select plotting backend.
-    backend_kwargs : bool, 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_figure
-
-    See Also
-    --------
-    plot_elpd : Plot pointwise elpd differences between two or more models.
-    compare : Compare models based on PSIS-LOO loo or WAIC waic cross-validation.
-    loo : Compute Pareto-smoothed importance sampling leave-one-out cross-validation (PSIS-LOO-CV).
-    waic : Compute the widely applicable information criterion.
-
-    References
-    ----------
-    .. [1] Vehtari et al. (2016). Practical Bayesian model evaluation using leave-one-out
-       cross-validation and WAIC https://arxiv.org/abs/1507.04544
-
-    .. [2] McElreath R. (2022). Statistical Rethinking A Bayesian Course with Examples in
-       R and Stan, Second edition, CRC Press.
-
-    Examples
-    --------
-    Show default compare plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> model_compare = az.compare({'Centered 8 schools': az.load_arviz_data('centered_eight'),
-        >>>                  'Non-centered 8 schools': az.load_arviz_data('non_centered_eight')})
-        >>> az.plot_compare(model_compare)
-
-    Include the in-sample ELDP
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_compare(model_compare, insample_dev=True)
-
-    """
-    if plot_kwargs is None:
-        plot_kwargs = {}
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    yticks_pos, step = np.linspace(0, -1, (comp_df.shape[0] * 2) - 1, retstep=True)
-    yticks_pos[1::2] = yticks_pos[1::2] + step / 2
-    labels = [labeller.model_name_to_str(model_name) for model_name in comp_df.index]
-
-    if plot_ic_diff:
-        yticks_labels = [""] * len(yticks_pos)
-        yticks_labels[0] = labels[0]
-        yticks_labels[2::2] = labels[1:]
-    else:
-        yticks_labels = labels
-
-    _information_criterion = ["elpd_loo", "elpd_waic"]
-    column_index = [c.lower() for c in comp_df.columns]
-    for information_criterion in _information_criterion:
-        if information_criterion in column_index:
-            break
-    else:
-        raise ValueError(
-            "comp_df must contain one of the following "
-            f"information criterion: {_information_criterion}"
-        )
-
-    if order_by_rank:
-        comp_df.sort_values(by="rank", inplace=True)
-
-    compareplot_kwargs = dict(
-        ax=ax,
-        comp_df=comp_df,
-        legend=legend,
-        title=title,
-        figsize=figsize,
-        plot_ic_diff=plot_ic_diff,
-        plot_standard_error=plot_standard_error,
-        insample_dev=insample_dev,
-        yticks_pos=yticks_pos,
-        yticks_labels=yticks_labels,
-        plot_kwargs=plot_kwargs,
-        information_criterion=information_criterion,
-        textsize=textsize,
-        step=step,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_compare", "compareplot", backend)
-    ax = plot(**compareplot_kwargs)
-
-    return ax

arviz/plots/densityplot.py

@@ -1,284 +0,0 @@
-"""KDE and histogram plots for multiple variables."""
-
-import warnings
-
-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
-from .plot_utils import default_grid, get_plotting_function
-
-
-# pylint:disable-msg=too-many-function-args
-def plot_density(
-    data,
-    group="posterior",
-    data_labels=None,
-    var_names=None,
-    filter_vars=None,
-    combine_dims=None,
-    transform=None,
-    hdi_prob=None,
-    point_estimate="auto",
-    colors="cycle",
-    outline=True,
-    hdi_markers="",
-    shade=0.0,
-    bw="default",
-    circular=False,
-    grid=None,
-    figsize=None,
-    textsize=None,
-    labeller=None,
-    ax=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    r"""Generate KDE plots for continuous variables and histograms for discrete ones.
-
-    Plots are truncated at their 100*(1-alpha)% highest density intervals. Plots are grouped per
-    variable and colors assigned to models.
-
-    Parameters
-    ----------
-    data : InferenceData or iterable of InferenceData
-        Any object that can be converted to an :class:`arviz.InferenceData` object, or an Iterator
-        returning a sequence of such objects.
-        Refer to documentation of :func:`arviz.convert_to_dataset` for details.
-    group : {"posterior", "prior"}, default "posterior"
-        Specifies which InferenceData group should be plotted. If "posterior", then the values
-        in `posterior_predictive` group are compared to the ones in `observed_data`, if "prior" then
-        the same comparison happens, but with the values in `prior_predictive` group.
-    data_labels : list of str, default None
-        List with names for the datasets passed as "data." Useful when plotting more than one
-        dataset.  Must be the same shape as the data parameter.
-    var_names : list of str, optional
-        List of variables to plot. If multiple datasets are supplied and `var_names` is not None,
-        will print the same set of variables for each dataset. Defaults to None, which results in
-        all the variables being plotted.
-    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.
-    combine_dims : set_like of str, optional
-        List of dimensions to reduce. Defaults to reducing only the "chain" and "draw" dimensions.
-        See :ref:`this section <common_combine_dims>` for usage examples.
-    transform : callable
-        Function to transform data (defaults to `None` i.e. the identity function).
-    hdi_prob : float, default 0.94
-        Probability for the highest density interval. Should be in the interval (0, 1].
-        See :ref:`this section <common_hdi_prob>` for usage examples.
-    point_estimate : str, optional
-        Plot point estimate per variable. Values should be 'mean', 'median', 'mode' or None.
-        Defaults to 'auto' i.e. it falls back to default set in ``rcParams``.
-    colors : str or list of str, optional
-        List with valid matplotlib colors, one color per model. Alternative a string can be passed.
-        If the string is `cycle`, it will automatically choose a color per model from matplotlib's
-        cycle. If a single color is passed, e.g. 'k', 'C2' or 'red' this color will be used for all
-        models. Defaults to `cycle`.
-    outline : bool, default True
-        Use a line to draw KDEs and histograms.
-    hdi_markers : str
-        A valid `matplotlib.markers` like 'v', used to indicate the limits of the highest density
-        interval. Defaults to empty string (no marker).
-    shade : float, default 0
-        Alpha blending value for the shaded area under the curve, between 0 (no shade) and 1
-        (opaque).
-    bw : float or str, optional
-        If numeric, indicates the bandwidth and must be positive.
-        If str, indicates the method to estimate the bandwidth and must be
-        one of "scott", "silverman", "isj" or "experimental" when `circular` is False
-        and "taylor" (for now) when `circular` is True.
-        Defaults to "default" which means "experimental" when variable is not circular
-        and "taylor" when it is.
-    circular : bool, default False
-        If True, it interprets the values passed are from a circular variable measured in radians
-        and a circular KDE is used. Only valid for 1D KDE.
-    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.
-    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_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 : 2D ndarray of matplotlib_axes or bokeh_figure
-
-    See Also
-    --------
-    plot_dist : Plot distribution as histogram or kernel density estimates.
-    plot_posterior : Plot Posterior densities in the style of John K. Kruschke's book.
-
-    Examples
-    --------
-    Plot default density plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> centered = az.load_arviz_data('centered_eight')
-        >>> non_centered = az.load_arviz_data('non_centered_eight')
-        >>> az.plot_density([centered, non_centered])
-
-    Plot variables in a 4x5 grid
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], grid=(4, 5))
-
-    Plot subset variables by specifying variable name exactly
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], var_names=["mu"])
-
-    Plot a specific `az.InferenceData` group
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], var_names=["mu"], group="prior")
-
-    Specify highest density interval
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], var_names=["mu"], hdi_prob=.5)
-
-    Shade plots and/or remove outlines
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], var_names=["mu"], outline=False, shade=.8)
-
-    Specify binwidth for kernel density estimation
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_density([centered, non_centered], var_names=["mu"], bw=.9)
-    """
-    if isinstance(data, (list, tuple)):
-        datasets = [convert_to_dataset(datum, group=group) for datum in data]
-    else:
-        datasets = [convert_to_dataset(data, group=group)]
-
-    if transform is not None:
-        datasets = [transform(dataset) for dataset in datasets]
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    var_names = _var_names(var_names, datasets, filter_vars)
-
-    n_data = len(datasets)
-
-    if data_labels is None:
-        data_labels = [f"{idx}" for idx in range(n_data)] if n_data > 1 else [""]
-    elif len(data_labels) != n_data:
-        raise ValueError(
-            f"The number of names for the models ({len(data_labels)}) "
-            f"does not match the number of models ({n_data})"
-        )
-
-    if hdi_prob is None:
-        hdi_prob = rcParams["stats.ci_prob"]
-    elif not 1 >= hdi_prob > 0:
-        raise ValueError("The value of hdi_prob should be in the interval (0, 1]")
-
-    to_plot = [
-        list(xarray_var_iter(data, var_names, combined=True, skip_dims=combine_dims))
-        for data in datasets
-    ]
-    all_labels = []
-    length_plotters = []
-    for plotters in to_plot:
-        length_plotters.append(len(plotters))
-        for var_name, selection, isel, _ in plotters:
-            label = labeller.make_label_vert(var_name, selection, isel)
-            if label not in all_labels:
-                all_labels.append(label)
-    length_plotters = len(all_labels)
-    max_plots = rcParams["plot.max_subplots"]
-    max_plots = length_plotters if max_plots is None else max_plots
-    if length_plotters > max_plots:
-        warnings.warn(
-            "rcParams['plot.max_subplots'] ({max_plots}) is smaller than the number "
-            "of variables to plot ({len_plotters}) in plot_density, generating only "
-            "{max_plots} plots".format(max_plots=max_plots, len_plotters=length_plotters),
-            UserWarning,
-        )
-        all_labels = all_labels[:max_plots]
-        to_plot = [
-            [
-                (var_name, selection, values)
-                for var_name, selection, isel, values in plotters
-                if labeller.make_label_vert(var_name, selection, isel) in all_labels
-            ]
-            for plotters in to_plot
-        ]
-        length_plotters = max_plots
-    rows, cols = default_grid(length_plotters, grid=grid, max_cols=3)
-
-    if bw == "default":
-        bw = "taylor" if circular else "experimental"
-
-    plot_density_kwargs = dict(
-        ax=ax,
-        all_labels=all_labels,
-        to_plot=to_plot,
-        colors=colors,
-        bw=bw,
-        circular=circular,
-        figsize=figsize,
-        length_plotters=length_plotters,
-        rows=rows,
-        cols=cols,
-        textsize=textsize,
-        labeller=labeller,
-        hdi_prob=hdi_prob,
-        point_estimate=point_estimate,
-        hdi_markers=hdi_markers,
-        outline=outline,
-        shade=shade,
-        n_data=n_data,
-        data_labels=data_labels,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_density", "densityplot", backend)
-    ax = plot(**plot_density_kwargs)
-    return ax

arviz/plots/distcomparisonplot.py

@@ -1,197 +0,0 @@
-"""Density Comparison plot."""
-
-import warnings
-from ..labels import BaseLabeller
-from ..rcparams import rcParams
-from ..utils import _var_names, get_coords
-from .plot_utils import get_plotting_function
-from ..sel_utils import xarray_var_iter, xarray_sel_iter
-
-
-def plot_dist_comparison(
-    data,
-    kind="latent",
-    figsize=None,
-    textsize=None,
-    var_names=None,
-    coords=None,
-    combine_dims=None,
-    transform=None,
-    legend=True,
-    labeller=None,
-    ax=None,
-    prior_kwargs=None,
-    posterior_kwargs=None,
-    observed_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    r"""Plot to compare fitted and unfitted distributions.
-
-    The resulting plots will show the compared distributions both on
-    separate axes (particularly useful when one of them is substantially tighter
-    than another), and plotted together, displaying a grid of three plots per
-    distribution.
-
-    Parameters
-    ----------
-    data : InferenceData
-        Any object that can be converted to an :class:`arviz.InferenceData` object
-        containing the posterior/prior data. Refer to documentation of
-        :func:`arviz.convert_to_dataset` for details.
-    kind : {"latent", "observed"}, default "latent"
-        kind of plot to display The "latent" option includes {"prior", "posterior"},
-        and the "observed" option includes
-        {"observed_data", "prior_predictive", "posterior_predictive"}.
-    figsize : (float, float), optional
-        Figure size. If ``None`` it will be defined automatically.
-    textsize : float
-        Text size scaling factor for labels, titles and lines. If ``None`` it will be
-        autoscaled based on `figsize`.
-    var_names : str, list, list of lists, optional
-        if str, plot the variable. if list, plot all the variables in list
-        of all groups. if list of lists, plot the vars of groups in respective lists.
-        See :ref:`this section <common_var_names>` for usage examples.
-    coords : dict
-        Dictionary mapping dimensions to selected coordinates to be plotted.
-        Dimensions without a mapping specified will include all coordinates for
-        that dimension. See :ref:`this section <common_coords>` for usage examples.
-    combine_dims : set_like of str, optional
-        List of dimensions to reduce. Defaults to reducing only the "chain" and "draw" dimensions.
-        See :ref:`this section <common_combine_dims>` for usage examples.
-    transform : callable
-        Function to transform data (defaults to `None` i.e. the identity function).
-    legend : bool
-        Add legend to figure. By default True.
-    labeller : Labeller, optional
-        Class providing the method ``make_pp_label`` to generate the labels in the plot titles.
-        Read the :ref:`label_guide` for more details and usage examples.
-    ax : (nvars, 3) array-like of matplotlib_axes, optional
-        Matplotlib axes: The ax argument should have shape (nvars, 3), where the
-        last column is for the combined before/after plots and columns 0 and 1 are
-        for the before and after plots, respectively.
-    prior_kwargs : dicts, optional
-        Additional keywords passed to :func:`arviz.plot_dist` for prior/predictive groups.
-    posterior_kwargs : dicts, optional
-        Additional keywords passed to :func:`arviz.plot_dist` for posterior/predictive groups.
-    observed_kwargs : dicts, optional
-        Additional keywords passed to :func:`arviz.plot_dist` for observed_data group.
-    backend : {"matplotlib", "bokeh"}, default "matplotlib"
-        Select plotting backend.
-    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 : 2D ndarray of matplotlib_axes
-        Returned object will have shape (nvars, 3),
-        where the last column is the combined plot and the first columns are the single plots.
-
-    See Also
-    --------
-    plot_bpv : Plot Bayesian p-value for observed data and Posterior/Prior predictive.
-
-    Examples
-    --------
-    Plot the prior/posterior plot for specified vars and coords.
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> data = az.load_arviz_data('rugby')
-        >>> az.plot_dist_comparison(data, var_names=["defs"], coords={"team" : ["Italy"]})
-
-    """
-    all_groups = ["prior", "posterior"]
-
-    if kind == "observed":
-        all_groups = ["observed_data", "prior_predictive", "posterior_predictive"]
-
-    if coords is None:
-        coords = {}
-
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    datasets = []
-    groups = []
-    for group in all_groups:
-        try:
-            datasets.append(getattr(data, group))
-            groups.append(group)
-        except:  # pylint: disable=bare-except
-            pass
-
-    if var_names is None:
-        var_names = list(datasets[0].data_vars)
-
-    if isinstance(var_names, str):
-        var_names = [var_names]
-
-    if isinstance(var_names[0], str):
-        var_names = [var_names for _ in datasets]
-
-    var_names = [_var_names(vars, dataset) for vars, dataset in zip(var_names, datasets)]
-
-    if transform is not None:
-        datasets = [transform(dataset) for dataset in datasets]
-
-    datasets = get_coords(datasets, coords)
-    len_plots = rcParams["plot.max_subplots"] // (len(groups) + 1)
-    len_plots = len_plots or 1
-    dc_plotters = [
-        list(xarray_var_iter(data, var_names=var, combined=True, skip_dims=combine_dims))[
-            :len_plots
-        ]
-        for data, var in zip(datasets, var_names)
-    ]
-
-    total_plots = sum(
-        1 for _ in xarray_sel_iter(datasets[0], var_names=var_names[0], combined=True)
-    ) * (len(groups) + 1)
-    maxplots = len(dc_plotters[0]) * (len(groups) + 1)
-
-    if total_plots > rcParams["plot.max_subplots"]:
-        warnings.warn(
-            "rcParams['plot.max_subplots'] ({rcParam}) is smaller than the number "
-            "of subplots to plot ({len_plotters}), generating only {max_plots} "
-            "plots".format(
-                rcParam=rcParams["plot.max_subplots"], len_plotters=total_plots, max_plots=maxplots
-            ),
-            UserWarning,
-        )
-
-    nvars = len(dc_plotters[0])
-    ngroups = len(groups)
-
-    distcomparisonplot_kwargs = dict(
-        ax=ax,
-        nvars=nvars,
-        ngroups=ngroups,
-        figsize=figsize,
-        dc_plotters=dc_plotters,
-        legend=legend,
-        groups=groups,
-        textsize=textsize,
-        labeller=labeller,
-        prior_kwargs=prior_kwargs,
-        posterior_kwargs=posterior_kwargs,
-        observed_kwargs=observed_kwargs,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_dist_comparison", "distcomparisonplot", backend)
-    axes = plot(**distcomparisonplot_kwargs)
-    return axes