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

arviz/plots/hdiplot.py

@@ -1,211 +0,0 @@
-"""Plot highest density intervals for regression data."""
-
-import warnings
-
-import numpy as np
-from scipy.interpolate import griddata
-from scipy.signal import savgol_filter
-from xarray import Dataset
-
-from ..rcparams import rcParams
-from ..stats import hdi
-from .plot_utils import get_plotting_function
-
-
-def plot_hdi(
-    x,
-    y=None,
-    hdi_prob=None,
-    hdi_data=None,
-    color="C1",
-    circular=False,
-    smooth=True,
-    smooth_kwargs=None,
-    figsize=None,
-    fill_kwargs=None,
-    plot_kwargs=None,
-    hdi_kwargs=None,
-    ax=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    r"""Plot HDI intervals for regression data.
-
-    Parameters
-    ----------
-    x : array-like
-        Values to plot.
-    y : array-like, optional
-        Values from which to compute the HDI. Assumed shape ``(chain, draw, \*shape)``.
-        Only optional if ``hdi_data`` is present.
-    hdi_data : array_like, optional
-        Precomputed HDI values to use. Assumed shape is ``(*x.shape, 2)``.
-    hdi_prob : float, optional
-        Probability for the highest density interval. Defaults to ``stats.ci_prob`` rcParam.
-        See :ref:`this section <common_ hdi_prob>` for usage examples.
-    color : str, default "C1"
-        Color used for the limits of the HDI and fill. Should be a valid matplotlib color.
-    circular : bool, default False
-        Whether to compute the HDI taking into account ``x`` is a circular variable
-        (in the range [-np.pi, np.pi]) or not. Defaults to False (i.e non-circular variables).
-    smooth : boolean, default True
-        If True the result will be smoothed by first computing a linear interpolation of the data
-        over a regular grid and then applying the Savitzky-Golay filter to the interpolated data.
-    smooth_kwargs : dict, optional
-        Additional keywords modifying the Savitzky-Golay filter. See
-        :func:`scipy:scipy.signal.savgol_filter` for details.
-    figsize : (float, float), optional
-        Figure size. If ``None``, it will be defined automatically.
-    fill_kwargs : dict, optional
-        Keywords passed to :meth:`mpl:matplotlib.axes.Axes.fill_between`
-        (use ``fill_kwargs={'alpha': 0}`` to disable fill) or to
-        :meth:`bokeh.plotting.Figure.patch`.
-    plot_kwargs : dict, optional
-        HDI limits keyword arguments, passed to :meth:`mpl:matplotlib.axes.Axes.plot` or
-        :meth:`bokeh.plotting.Figure.patch`.
-    hdi_kwargs : dict, optional
-        Keyword arguments passed to :func:`~arviz.hdi`. Ignored if ``hdi_data`` is present.
-    ax : axes, optional
-        Matplotlib axes or bokeh figures.
-    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 : matplotlib axes or bokeh figures
-
-    See Also
-    --------
-    hdi : Calculate highest density interval (HDI) of array for given probability.
-
-    Examples
-    --------
-    Plot HDI interval of simulated random-walk data using `y` argument:
-
-    .. plot::
-        :context: close-figs
-
-        >>> import numpy as np
-        >>> import arviz as az
-        >>> # time-steps random walk
-        >>> x_data =np.arange(0,100)
-        >>> # Mean random walk
-        >>> mu = np.zeros(100)
-        >>> for i in x_data: mu[i] = mu[i-1] + np.random.normal(0, 1, 1)
-        >>> # Simulated pp samples form the random walk time series
-        >>> y_data = np.random.normal(2 + mu * 0.5, 0.5, size = (2, 50, 100))
-        >>> az.plot_hdi(x_data, y_data)
-
-    ``plot_hdi`` can also be given precalculated values with the argument ``hdi_data``. This example
-    shows how to use :func:`~arviz.hdi` to precalculate the values and pass these values to
-    ``plot_hdi``. Similarly to an example in ``hdi`` we are using the ``input_core_dims``
-    argument of :func:`~arviz.wrap_xarray_ufunc` to manually define the dimensions over which
-    to calculate the HDI.
-
-    .. plot::
-        :context: close-figs
-
-        >>> hdi_data = az.hdi(y_data, input_core_dims=[["draw"]])
-        >>> ax = az.plot_hdi(x_data, hdi_data=hdi_data[0], color="r", fill_kwargs={"alpha": .2})
-        >>> az.plot_hdi(x_data, hdi_data=hdi_data[1], color="k", ax=ax, fill_kwargs={"alpha": .2})
-
-    ``plot_hdi`` can also be used with Inference Data objects. Here we use the posterior predictive
-    to plot the HDI interval.
-
-    .. plot::
-        :context: close-figs
-
-        >>> X = np.random.normal(0,1,100)
-        >>> Y = np.random.normal(2 + X * 0.5, 0.5, size=(2,10,100))
-        >>> idata = az.from_dict(posterior={"y": Y}, constant_data={"x":X})
-        >>> x_data = idata.constant_data.x
-        >>> y_data = idata.posterior.y
-        >>> az.plot_hdi(x_data, y_data)
-
-    """
-    if hdi_kwargs is None:
-        hdi_kwargs = {}
-
-    x = np.asarray(x)
-    x_shape = x.shape
-
-    if isinstance(x[0], str):
-        raise NotImplementedError(
-            "The `arviz.plot_hdi()` function does not support categorical data. "
-            "Consider using `arviz.plot_forest()`."
-        )
-    if y is None and hdi_data is None:
-        raise ValueError("One of {y, hdi_data} is required")
-    if hdi_data is not None and y is not None:
-        warnings.warn("Both y and hdi_data arguments present, ignoring y")
-    elif hdi_data is not None:
-        hdi_prob = (
-            hdi_data.hdi.attrs.get("hdi_prob", np.nan) if hasattr(hdi_data, "hdi") else np.nan
-        )
-        if isinstance(hdi_data, Dataset):
-            data_vars = list(hdi_data.data_vars)
-            if len(data_vars) != 1:
-                raise ValueError(
-                    "Found several variables in hdi_data. Only single variable Datasets are "
-                    "supported."
-                )
-            hdi_data = hdi_data[data_vars[0]]
-    else:
-        y = np.asarray(y)
-        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]")
-        hdi_data = hdi(y, hdi_prob=hdi_prob, circular=circular, multimodal=False, **hdi_kwargs)
-
-    hdi_shape = hdi_data.shape
-    if hdi_shape[:-1] != x_shape:
-        msg = (
-            "Dimension mismatch for x: {} and hdi: {}. Check the dimensions of y and"
-            "hdi_kwargs to make sure they are compatible"
-        )
-        raise TypeError(msg.format(x_shape, hdi_shape))
-
-    if smooth:
-        if isinstance(x[0], np.datetime64):
-            raise TypeError("Cannot deal with x as type datetime. Recommend setting smooth=False.")
-
-        if smooth_kwargs is None:
-            smooth_kwargs = {}
-        smooth_kwargs.setdefault("window_length", 55)
-        smooth_kwargs.setdefault("polyorder", 2)
-        x_data = np.linspace(x.min(), x.max(), 200)
-        x_data[0] = (x_data[0] + x_data[1]) / 2
-        hdi_interp = griddata(x, hdi_data, x_data)
-        y_data = savgol_filter(hdi_interp, axis=0, **smooth_kwargs)
-    else:
-        idx = np.argsort(x)
-        x_data = x[idx]
-        y_data = hdi_data[idx]
-
-    hdiplot_kwargs = dict(
-        ax=ax,
-        x_data=x_data,
-        y_data=y_data,
-        color=color,
-        figsize=figsize,
-        plot_kwargs=plot_kwargs,
-        fill_kwargs=fill_kwargs,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    plot = get_plotting_function("plot_hdi", "hdiplot", backend)
-    ax = plot(**hdiplot_kwargs)
-    return ax

arviz/plots/kdeplot.py

@@ -1,357 +0,0 @@
-# pylint: disable=unexpected-keyword-arg
-"""One-dimensional kernel density estimate plots."""
-import warnings
-
-import xarray as xr
-
-from ..data import InferenceData
-from ..rcparams import rcParams
-from ..stats.density_utils import _fast_kde_2d, kde, _find_hdi_contours
-from .plot_utils import get_plotting_function, _init_kwargs_dict
-
-
-def plot_kde(
-    values,
-    values2=None,
-    cumulative=False,
-    rug=False,
-    label=None,
-    bw="default",
-    adaptive=False,
-    quantiles=None,
-    rotated=False,
-    contour=True,
-    hdi_probs=None,
-    fill_last=False,
-    figsize=None,
-    textsize=None,
-    plot_kwargs=None,
-    fill_kwargs=None,
-    rug_kwargs=None,
-    contour_kwargs=None,
-    contourf_kwargs=None,
-    pcolormesh_kwargs=None,
-    is_circular=False,
-    ax=None,
-    legend=True,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-    return_glyph=False,
-    **kwargs
-):
-    """1D or 2D KDE plot taking into account boundary conditions.
-
-    Parameters
-    ----------
-    values : array-like
-        Values to plot
-    values2 : array-like, optional
-        Values to plot. If present, a 2D KDE will be estimated
-    cumulative : bool, dafault False
-        If True plot the estimated cumulative distribution function. Ignored for 2D KDE.
-    rug : bool, default False
-        Add a `rug plot <https://en.wikipedia.org/wiki/Rug_plot>`_ for a specific subset of
-        values. Ignored for 2D KDE.
-    label : string, optional
-        Text to include as part of the legend.
-    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 ``is_circular`` is False
-        and "taylor" (for now) when ``is_circular`` is True.
-        Defaults to "default" which means "experimental" when variable is not circular
-        and "taylor" when it is.
-    adaptive : bool, default False
-        If True, an adaptative bandwidth is used. Only valid for 1D KDE.
-    quantiles : list, optional
-        Quantiles in ascending order used to segment the KDE. Use [.25, .5, .75] for quartiles.
-    rotated : bool, default False
-        Whether to rotate the 1D KDE plot 90 degrees.
-    contour : bool, default True
-        If True plot the 2D KDE using contours, otherwise plot a smooth 2D KDE.
-    hdi_probs : list, optional
-        Plots highest density credibility regions for the provided probabilities for a 2D KDE.
-        Defaults to [0.5, 0.8, 0.94].
-    fill_last : bool, default False
-        If True fill the last contour of the 2D KDE plot.
-    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``. Not implemented for bokeh backend.
-    plot_kwargs : dict, optional
-        Keywords passed to the pdf line of a 1D KDE. See :meth:`mpl:matplotlib.axes.Axes.plot`
-        or :meth:`bokeh:bokeh.plotting.Figure.line` for a description of accepted values.
-    fill_kwargs : dict, optional
-        Keywords passed to the fill under the line (use ``fill_kwargs={'alpha': 0}``
-        to disable fill). Ignored for 2D KDE. Passed to
-        :meth:`bokeh.plotting.Figure.patch`.
-    rug_kwargs : dict, optional
-        Keywords passed to the rug plot. Ignored if ``rug=False`` or for 2D KDE
-        Use ``space`` keyword (float) to control the position of the rugplot. The larger this number
-        the lower the rugplot. Passed to :class:`bokeh:bokeh.models.glyphs.Scatter`.
-    contour_kwargs : dict, optional
-        Keywords passed to :meth:`mpl:matplotlib.axes.Axes.contour`
-        to draw contour lines or :meth:`bokeh.plotting.Figure.patch`.
-        Ignored for 1D KDE.
-    contourf_kwargs : dict, optional
-        Keywords passed to :meth:`mpl:matplotlib.axes.Axes.contourf`
-        to draw filled contours. Ignored for 1D KDE.
-    pcolormesh_kwargs : dict, optional
-        Keywords passed to :meth:`mpl:matplotlib.axes.Axes.pcolormesh` or
-        :meth:`bokeh.plotting.Figure.image`.
-        Ignored for 1D KDE.
-    is_circular : {False, True, "radians", "degrees"}. Default False
-        Select input type {"radians", "degrees"} for circular histogram or KDE plot. If True,
-        default input type is "radians". When this argument is present, it interprets ``values``
-        as a circular variable measured in radians and a circular KDE is used. Inputs in
-        "degrees" will undergo an internal conversion to radians.
-    ax : axes, optional
-        Matplotlib axes or bokeh figures.
-    legend : bool, default True
-        Add legend to the figure.
-    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.
-    return_glyph : bool, optional
-        Internal argument to return glyphs for bokeh.
-
-    Returns
-    -------
-    axes : matplotlib.Axes or bokeh.plotting.Figure
-        Object containing the kde plot
-    glyphs : list, optional
-        Bokeh glyphs present in plot.  Only provided if ``return_glyph`` is True.
-
-    See Also
-    --------
-    kde : One dimensional density estimation.
-    plot_dist : Plot distribution as histogram or kernel density estimates.
-
-    Examples
-    --------
-    Plot default KDE
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> non_centered = az.load_arviz_data('non_centered_eight')
-        >>> mu_posterior = np.concatenate(non_centered.posterior["mu"].values)
-        >>> tau_posterior = np.concatenate(non_centered.posterior["tau"].values)
-        >>> az.plot_kde(mu_posterior)
-
-
-    Plot KDE with rugplot
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, rug=True)
-
-    Plot KDE with adaptive bandwidth
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, adaptive=True)
-
-    Plot KDE with a different bandwidth estimator
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, bw="scott")
-
-    Plot KDE with a bandwidth specified manually
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, bw=0.4)
-
-    Plot KDE for a circular variable
-
-    .. plot::
-        :context: close-figs
-
-        >>> rvs = np.random.vonmises(mu=np.pi, kappa=2, size=500)
-        >>> az.plot_kde(rvs, is_circular=True)
-
-
-    Plot a cumulative distribution
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, cumulative=True)
-
-
-
-    Rotate plot 90 degrees
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, rotated=True)
-
-
-    Plot 2d contour KDE
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, values2=tau_posterior)
-
-
-    Plot 2d contour KDE, without filling and contour lines using viridis cmap
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, values2=tau_posterior,
-        ...             contour_kwargs={"colors":None, "cmap":plt.cm.viridis},
-        ...             contourf_kwargs={"alpha":0});
-
-    Plot 2d contour KDE, set the number of levels to 3.
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(
-        ...     mu_posterior, values2=tau_posterior,
-        ...     contour_kwargs={"levels":3}, contourf_kwargs={"levels":3}
-        ... );
-
-    Plot 2d contour KDE with 30%, 60% and 90% HDI contours.
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, values2=tau_posterior, hdi_probs=[0.3, 0.6, 0.9])
-
-    Plot 2d smooth KDE
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_kde(mu_posterior, values2=tau_posterior, contour=False)
-
-    """
-    if isinstance(values, xr.Dataset):
-        raise ValueError(
-            "Xarray dataset object detected. Use plot_posterior, plot_density "
-            "or plot_pair instead of plot_kde"
-        )
-    if isinstance(values, InferenceData):
-        raise ValueError(
-            " Inference Data object detected. Use plot_posterior "
-            "or plot_pair instead of plot_kde"
-        )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    if values2 is None:
-        if bw == "default":
-            bw = "taylor" if is_circular else "experimental"
-
-        grid, density = kde(values, is_circular, bw=bw, adaptive=adaptive, cumulative=cumulative)
-        lower, upper = grid[0], grid[-1]
-
-        density_q = density if cumulative else density.cumsum() / density.sum()
-
-        # This is just a hack placeholder for now
-        xmin, xmax, ymin, ymax, gridsize = [None] * 5
-    else:
-        gridsize = (128, 128) if contour else (256, 256)
-        density, xmin, xmax, ymin, ymax = _fast_kde_2d(values, values2, gridsize=gridsize)
-
-        if hdi_probs is None:
-            hdi_probs = [0.5, 0.8, 0.94]
-
-        if hdi_probs is not None:
-            # Check hdi probs are within bounds (0, 1)
-            if min(hdi_probs) <= 0 or max(hdi_probs) >= 1:
-                raise ValueError("Highest density interval probabilities must be between 0 and 1")
-
-            # Calculate contour levels and sort for matplotlib
-            contour_levels = _find_hdi_contours(density, hdi_probs)
-            contour_levels.sort()
-
-            contour_level_list = [0] + list(contour_levels) + [density.max()]
-
-            # Add keyword arguments to contour, contourf
-            contour_kwargs = _init_kwargs_dict(contour_kwargs)
-            if "levels" in contour_kwargs:
-                warnings.warn(
-                    "Both 'levels' in contour_kwargs and 'hdi_probs' have been specified."
-                    "Using 'hdi_probs' in favor of 'levels'.",
-                    UserWarning,
-                )
-
-            if backend == "bokeh":
-                contour_kwargs["levels"] = contour_level_list
-            elif backend == "matplotlib":
-                contour_kwargs["levels"] = contour_level_list[1:]
-
-            contourf_kwargs = _init_kwargs_dict(contourf_kwargs)
-            if "levels" in contourf_kwargs:
-                warnings.warn(
-                    "Both 'levels' in contourf_kwargs and 'hdi_probs' have been specified."
-                    "Using 'hdi_probs' in favor of 'levels'.",
-                    UserWarning,
-                )
-            contourf_kwargs["levels"] = contour_level_list
-
-        lower, upper, density_q = [None] * 3
-
-    kde_plot_args = dict(
-        # Internal API
-        density=density,
-        lower=lower,
-        upper=upper,
-        density_q=density_q,
-        xmin=xmin,
-        xmax=xmax,
-        ymin=ymin,
-        ymax=ymax,
-        gridsize=gridsize,
-        # User Facing API that can be simplified
-        values=values,
-        values2=values2,
-        rug=rug,
-        label=label,
-        quantiles=quantiles,
-        rotated=rotated,
-        contour=contour,
-        fill_last=fill_last,
-        figsize=figsize,
-        textsize=textsize,
-        plot_kwargs=plot_kwargs,
-        fill_kwargs=fill_kwargs,
-        rug_kwargs=rug_kwargs,
-        contour_kwargs=contour_kwargs,
-        contourf_kwargs=contourf_kwargs,
-        pcolormesh_kwargs=pcolormesh_kwargs,
-        is_circular=is_circular,
-        ax=ax,
-        legend=legend,
-        backend_kwargs=backend_kwargs,
-        show=show,
-        return_glyph=return_glyph,
-        **kwargs,
-    )
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_kde", "kdeplot", backend)
-    ax = plot(**kde_plot_args)
-
-    return ax