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

arviz/plots/distplot.py

@@ -1,233 +0,0 @@
-# pylint: disable=unexpected-keyword-arg
-"""Plot distribution as histogram or kernel density estimates."""
-import numpy as np
-import xarray as xr
-
-from ..data import InferenceData
-from ..rcparams import rcParams
-from .plot_utils import get_plotting_function
-
-
-def plot_dist(
-    values,
-    values2=None,
-    color="C0",
-    kind="auto",
-    cumulative=False,
-    label=None,
-    rotated=False,
-    rug=False,
-    bw="default",
-    quantiles=None,
-    contour=True,
-    fill_last=True,
-    figsize=None,
-    textsize=None,
-    plot_kwargs=None,
-    fill_kwargs=None,
-    rug_kwargs=None,
-    contour_kwargs=None,
-    contourf_kwargs=None,
-    pcolormesh_kwargs=None,
-    hist_kwargs=None,
-    is_circular=False,
-    ax=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-    **kwargs,
-):
-    r"""Plot distribution as histogram or kernel density estimates.
-
-    By default continuous variables are plotted using KDEs and discrete ones using histograms
-
-    Parameters
-    ----------
-    values : array-like
-        Values to plot from an unknown continuous or discrete distribution.
-    values2 : array-like, optional
-        Values to plot. If present, a 2D KDE or a hexbin will be estimated.
-    color : string
-        valid matplotlib color.
-    kind : string, default "auto"
-        By default ("auto") continuous variables will use the kind defined by rcParam
-        ``plot.density_kind`` and discrete ones will use histograms.
-        To override this use "hist" to plot histograms and "kde" for KDEs.
-    cumulative : bool, default False
-        If true plot the estimated cumulative distribution function. Defaults to False.
-        Ignored for 2D KDE.
-    label : string
-        Text to include as part of the legend.
-    rotated : bool, default False
-        Whether to rotate the 1D KDE plot 90 degrees.
-    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.
-    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 "experimental" when variable is not circular and "taylor" when it is.
-    quantiles : list, optional
-        Quantiles in ascending order used to segment the KDE. Use [.25, .5, .75] for quartiles.
-    contour : bool, default True
-        If True plot the 2D KDE using contours, otherwise plot a smooth 2D KDE.
-    fill_last : bool, default True
-        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
-        Keywords passed to the pdf line of a 1D KDE. Passed to :func:`arviz.plot_kde` as
-        ``plot_kwargs``.
-    fill_kwargs : dict
-        Keywords passed to the fill under the line (use fill_kwargs={'alpha': 0} to disable fill).
-        Ignored for 2D KDE. Passed to :func:`arviz.plot_kde` as ``fill_kwargs``.
-    rug_kwargs : dict
-        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
-        :func:`arviz.plot_kde` as ``rug_kwargs``.
-    contour_kwargs : dict
-        Keywords passed to the contourplot. Ignored for 1D KDE.
-    contourf_kwargs : dict
-        Keywords passed to :meth:`matplotlib.axes.Axes.contourf`. Ignored for 1D KDE.
-    pcolormesh_kwargs : dict
-        Keywords passed to :meth:`matplotlib.axes.Axes.pcolormesh`. Ignored for 1D KDE.
-    hist_kwargs : dict
-        Keyword arguments used to customize the histogram. Ignored when plotting a KDE.
-        They are passed to :meth:`matplotlib.axes.Axes.hist` if using matplotlib,
-        or to :meth:`bokeh.plotting.figure.quad` if using bokeh. In bokeh case,
-        the following extra keywords are also supported:
-
-        * ``color``: replaces the ``fill_color`` and ``line_color`` of the ``quad`` method
-        * ``bins``: taken from ``hist_kwargs`` and passed to :func:`numpy.histogram` instead
-        * ``density``: normalize histogram to represent a probability density function,
-          Defaults to ``True``
-
-        * ``cumulative``: plot the cumulative counts. Defaults to ``False``.
-
-    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 the
-        values passed are from a circular variable measured in radians and a circular KDE is
-        used. Inputs in "degrees" will undergo an internal conversion to radians. Only valid
-        for 1D KDE.
-    ax : matplotlib_axes or bokeh_figure, optional
-        Matplotlib or bokeh targets on which to plot. If not supplied, Arviz will create
-        its own plot area (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 : matplotlib axes or bokeh figure
-
-    See Also
-    --------
-    plot_posterior : Plot Posterior densities in the style of John K. Kruschke's book.
-    plot_density : Generate KDE plots for continuous variables and histograms for discrete ones.
-    plot_kde : 1D or 2D KDE plot taking into account boundary conditions.
-
-    Examples
-    --------
-    Plot an integer distribution
-
-    .. plot::
-        :context: close-figs
-
-        >>> import numpy as np
-        >>> import arviz as az
-        >>> a = np.random.poisson(4, 1000)
-        >>> az.plot_dist(a)
-
-    Plot a continuous distribution
-
-    .. plot::
-        :context: close-figs
-
-        >>> b = np.random.normal(0, 1, 1000)
-        >>> az.plot_dist(b)
-
-    Add a rug under the Gaussian distribution
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dist(b, rug=True)
-
-    Segment into quantiles
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dist(b, rug=True, quantiles=[.25, .5, .75])
-
-    Plot as the cumulative distribution
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dist(b, rug=True, quantiles=[.25, .5, .75], cumulative=True)
-    """
-    values = np.asarray(values)
-
-    if isinstance(values, (InferenceData, xr.Dataset)):
-        raise ValueError(
-            "InferenceData or xarray.Dataset object detected,"
-            " use plot_posterior, plot_density or plot_pair"
-            " instead of plot_dist"
-        )
-
-    if kind not in ["auto", "kde", "hist"]:
-        raise TypeError(f'Invalid "kind":{kind}. Select from {{"auto","kde","hist"}}')
-
-    if kind == "auto":
-        kind = "hist" if values.dtype.kind == "i" else rcParams["plot.density_kind"]
-
-    dist_plot_args = dict(
-        # User Facing API that can be simplified
-        values=values,
-        values2=values2,
-        color=color,
-        kind=kind,
-        cumulative=cumulative,
-        label=label,
-        rotated=rotated,
-        rug=rug,
-        bw=bw,
-        quantiles=quantiles,
-        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,
-        hist_kwargs=hist_kwargs,
-        ax=ax,
-        backend_kwargs=backend_kwargs,
-        is_circular=is_circular,
-        show=show,
-        **kwargs,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    plot = get_plotting_function("plot_dist", "distplot", backend)
-    ax = plot(**dist_plot_args)
-    return ax

arviz/plots/dotplot.py

@@ -1,233 +0,0 @@
-"""Plot distribution as dot plot or quantile dot plot."""
-
-import numpy as np
-
-
-from ..rcparams import rcParams
-from .plot_utils import get_plotting_function
-
-
-def plot_dot(
-    values,
-    binwidth=None,
-    dotsize=1,
-    stackratio=1,
-    hdi_prob=None,
-    rotated=False,
-    dotcolor="C0",
-    intervalcolor="C3",
-    markersize=None,
-    markercolor="C0",
-    marker="o",
-    figsize=None,
-    linewidth=None,
-    point_estimate="auto",
-    nquantiles=50,
-    quartiles=True,
-    point_interval=False,
-    ax=None,
-    show=None,
-    plot_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    **kwargs
-):
-    r"""Plot distribution as dot plot or quantile dot plot.
-
-    This function uses the Wilkinson's Algorithm [1]_ to allot dots to bins.
-    The quantile dot plots was inspired from [2]_.
-
-    Parameters
-    ----------
-    values : array-like
-        Values to plot from an unknown continuous or discrete distribution.
-    binwidth : float, optional
-        Width of the bin for drawing the dot plot.
-    dotsize : float, default 1
-        The size of the dots relative to the bin width. The default makes dots be
-        just about as wide as the bin width.
-    stackratio : float, default 1
-        The distance between the center of the dots in the same stack relative to the bin height.
-        The default makes dots in the same stack just touch each other.
-    point_interval : bool, default False
-        Plots the point interval. Uses ``hdi_prob`` to plot the HDI interval
-    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.
-    dotcolor : string, optional
-        The color of the dots. Should be a valid matplotlib color.
-    intervalcolor : string, optional
-        The color of the interval. Should be a valid matplotlib color.
-    linewidth : int, default None
-        Line width throughout. If None it will be autoscaled based on `figsize`.
-    markersize : int, default None
-        Markersize throughout. If None it will be autoscaled based on `figsize`.
-    markercolor : string, optional
-        The color of the marker when plot_interval is True. Should be a valid matplotlib color.
-    marker : string, default "o"
-        The shape of the marker. Valid for matplotlib backend.
-    hdi_prob : float, optional
-        Valid only when point_interval is True. Plots HDI for chosen percentage of density.
-        Defaults to ``stats.ci_prob`` rcParam. See :ref:`this section <common_hdi_prob>`
-        for usage examples.
-    rotated : bool, default False
-        Whether to rotate the dot plot by 90 degrees.
-    nquantiles : int, default 50
-        Number of quantiles to plot, used for quantile dot plots.
-    quartiles : bool, default True
-        If True then the quartile interval will be plotted with the HDI.
-    figsize : (float,float), optional
-        Figure size. If ``None`` it will be defined automatically.
-    plot_kwargs : dict, optional
-        Keywords passed for customizing the dots. Passed to :class:`mpl:matplotlib.patches.Circle`
-        in matplotlib and :meth:`bokeh.plotting.figure.circle` in bokeh.
-    backend :{"matplotlib", "bokeh"}, default "matplotlib"
-        Select plotting backend.
-    ax : axes, optional
-        Matplotlib_axes or bokeh_figure.
-    show : bool, optional
-        Call backend show function.
-    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.
-
-    Returns
-    -------
-    axes : matplotlib_axes or bokeh_figure
-
-    See Also
-    --------
-    plot_dist : Plot distribution as histogram or kernel density estimates.
-
-    References
-    ----------
-    .. [1] Leland Wilkinson (1999) Dot Plots, The American Statistician, 53:3, 276-281,
-        DOI: 10.1080/00031305.1999.10474474
-    .. [2] Matthew Kay, Tara Kola, Jessica R. Hullman,
-        and Sean A. Munson. 2016. When (ish) is My Bus? User-centered Visualizations of Uncertainty
-        in Everyday, Mobile Predictive Systems. DOI:https://doi.org/10.1145/2858036.2858558
-
-    Examples
-    --------
-    Plot dot plot for a set of data points
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> import numpy as np
-        >>> values = np.random.normal(0, 1, 500)
-        >>> az.plot_dot(values)
-
-    Manually adjust number of quantiles to plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dot(values, nquantiles=100)
-
-    Add a point interval under the dot plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dot(values, point_interval=True)
-
-    Rotate the dot plots by 90 degrees i.e swap x and y axis
-
-    .. plot::
-        :context: close-figs
-
-        >>> az.plot_dot(values, point_interval=True, rotated=True)
-
-    """
-    if nquantiles == 0:
-        raise ValueError("Number of quantiles should be greater than 0")
-
-    if marker != "o" and backend == "bokeh":
-        raise ValueError("marker argument is valid only for matplotlib backend")
-
-    values = np.ravel(values)
-    values = values[np.isfinite(values)]
-    values.sort()
-
-    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]")
-
-    if point_estimate == "auto":
-        point_estimate = rcParams["plot.point_estimate"]
-    elif point_estimate not in {"mean", "median", "mode", None}:
-        raise ValueError("The value of point_estimate must be either mean, median, mode or None.")
-
-    if not isinstance(nquantiles, int):
-        raise TypeError("nquantiles must be of integer type, refer to docs for further details")
-
-    dot_plot_args = dict(
-        values=values,
-        binwidth=binwidth,
-        dotsize=dotsize,
-        stackratio=stackratio,
-        hdi_prob=hdi_prob,
-        quartiles=quartiles,
-        rotated=rotated,
-        dotcolor=dotcolor,
-        intervalcolor=intervalcolor,
-        markersize=markersize,
-        markercolor=markercolor,
-        marker=marker,
-        figsize=figsize,
-        linewidth=linewidth,
-        point_estimate=point_estimate,
-        nquantiles=nquantiles,
-        point_interval=point_interval,
-        ax=ax,
-        show=show,
-        backend_kwargs=backend_kwargs,
-        plot_kwargs=plot_kwargs,
-        **kwargs
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    plot = get_plotting_function("plot_dot", "dotplot", backend)
-    ax = plot(**dot_plot_args)
-
-    return ax
-
-
-def wilkinson_algorithm(values, binwidth):
-    """Wilkinson's algorithm to distribute dots into horizontal stacks."""
-    ndots = len(values)
-    count = 0
-    stack_locs, stack_counts = [], []
-
-    while count < ndots:
-        stack_first_dot = values[count]
-        num_dots_stack = 0
-        while values[count] < (binwidth + stack_first_dot):
-            num_dots_stack += 1
-            count += 1
-            if count == ndots:
-                break
-        stack_locs.append((stack_first_dot + values[count - 1]) / 2)
-        stack_counts.append(num_dots_stack)
-
-    return stack_locs, stack_counts
-
-
-def layout_stacks(stack_locs, stack_counts, binwidth, stackratio, rotated):
-    """Use count and location of stacks to get coordinates of dots."""
-    dotheight = stackratio * binwidth
-    binradius = binwidth / 2
-
-    x = np.repeat(stack_locs, stack_counts)
-    y = np.hstack([dotheight * np.arange(count) + binradius for count in stack_counts])
-    if rotated:
-        x, y = y, x
-
-    return x, y