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

arviz/plots/backends/matplotlib/kdeplot.py

@@ -1,177 +0,0 @@
-"""Matplotlib kdeplot."""
-
-import numpy as np
-from matplotlib import pyplot as plt
-from matplotlib import _pylab_helpers
-import matplotlib.ticker as mticker
-
-
-from ...plot_utils import _scale_fig_size, _init_kwargs_dict
-from . import backend_kwarg_defaults, backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_kde(
-    density,
-    lower,
-    upper,
-    density_q,
-    xmin,
-    xmax,
-    ymin,
-    ymax,
-    gridsize,
-    values,
-    values2,
-    rug,
-    label,
-    quantiles,
-    rotated,
-    contour,
-    fill_last,
-    figsize,
-    textsize,
-    plot_kwargs,
-    fill_kwargs,
-    rug_kwargs,
-    contour_kwargs,
-    contourf_kwargs,
-    pcolormesh_kwargs,
-    is_circular,
-    ax,
-    legend,
-    backend_kwargs,
-    show,
-    return_glyph,  # pylint: disable=unused-argument
-):
-    """Matplotlib kde plot."""
-    backend_kwargs = _init_kwargs_dict(backend_kwargs)
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, *_, xt_labelsize, linewidth, markersize = _scale_fig_size(figsize, textsize)
-
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-    backend_kwargs.setdefault("subplot_kw", {})
-    backend_kwargs["subplot_kw"].setdefault("polar", is_circular)
-
-    if ax is None:
-        fig_manager = _pylab_helpers.Gcf.get_active()
-        if fig_manager is not None:
-            ax = fig_manager.canvas.figure.gca()
-        else:
-            _, ax = create_axes_grid(
-                1,
-                backend_kwargs=backend_kwargs,
-            )
-
-    if values2 is None:
-        plot_kwargs = matplotlib_kwarg_dealiaser(plot_kwargs, "plot")
-        plot_kwargs.setdefault("color", "C0")
-
-        default_color = plot_kwargs.get("color")
-
-        fill_kwargs = matplotlib_kwarg_dealiaser(fill_kwargs, "hexbin")
-        fill_kwargs.setdefault("color", default_color)
-
-        rug_kwargs = matplotlib_kwarg_dealiaser(rug_kwargs, "plot")
-        rug_kwargs.setdefault("marker", "_" if rotated else "|")
-        rug_kwargs.setdefault("linestyle", "None")
-        rug_kwargs.setdefault("color", default_color)
-        rug_kwargs.setdefault("space", 0.2)
-
-        plot_kwargs.setdefault("linewidth", linewidth)
-        rug_kwargs.setdefault("markersize", 2 * markersize)
-
-        rug_space = max(density) * rug_kwargs.pop("space")
-
-        if is_circular:
-            if is_circular == "radians":
-                labels = [
-                    "0",
-                    f"{np.pi/4:.2f}",
-                    f"{np.pi/2:.2f}",
-                    f"{3*np.pi/4:.2f}",
-                    f"{np.pi:.2f}",
-                    f"{-3*np.pi/4:.2f}",
-                    f"{-np.pi/2:.2f}",
-                    f"{-np.pi/4:.2f}",
-                ]
-
-                ticks_loc = ax.get_xticks()
-                ax.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc))
-                ax.set_xticklabels(labels)
-
-            x = np.linspace(-np.pi, np.pi, len(density))
-            ax.set_yticklabels([])
-
-        else:
-            x = np.linspace(lower, upper, len(density))
-
-        fill_func = ax.fill_between
-        fill_x, fill_y = x, density
-        if rotated:
-            x, density = density, x
-            fill_func = ax.fill_betweenx
-
-        ax.tick_params(labelsize=xt_labelsize)
-
-        if rotated:
-            ax.set_xlim(0, auto=True)
-            rug_x, rug_y = np.zeros_like(values) - rug_space, values
-        else:
-            ax.set_ylim(0, auto=True)
-            rug_x, rug_y = values, np.zeros_like(values) - rug_space
-
-        if rug:
-            ax.plot(rug_x, rug_y, **rug_kwargs)
-
-        if quantiles is not None:
-            fill_kwargs.setdefault("alpha", 0.75)
-
-            idx = [np.sum(density_q < quant) for quant in quantiles]
-
-            fill_func(
-                fill_x,
-                fill_y,
-                where=np.isin(fill_x, fill_x[idx], invert=True, assume_unique=True),
-                **fill_kwargs,
-            )
-        else:
-            fill_kwargs.setdefault("alpha", 0)
-            if fill_kwargs.get("alpha") == 0:
-                label = plot_kwargs.setdefault("label", label)
-            else:
-                label = fill_kwargs.setdefault("label", label)
-            ax.plot(x, density, **plot_kwargs)
-            fill_func(fill_x, fill_y, **fill_kwargs)
-        if legend and label:
-            ax.legend()
-    else:
-        contour_kwargs = matplotlib_kwarg_dealiaser(contour_kwargs, "contour")
-        contour_kwargs.setdefault("colors", "0.5")
-        contourf_kwargs = matplotlib_kwarg_dealiaser(contourf_kwargs, "contour")
-        pcolormesh_kwargs = matplotlib_kwarg_dealiaser(pcolormesh_kwargs, "pcolormesh")
-        pcolormesh_kwargs.setdefault("shading", "auto")
-
-        g_s = complex(gridsize[0])
-        x_x, y_y = np.mgrid[xmin:xmax:g_s, ymin:ymax:g_s]
-
-        ax.grid(False)
-        if contour:
-            qcfs = ax.contourf(x_x, y_y, density, antialiased=True, **contourf_kwargs)
-            ax.contour(x_x, y_y, density, **contour_kwargs)
-            if not fill_last:
-                alpha = np.ones(len(qcfs.allsegs), dtype=float)
-                alpha[0] = 0
-                qcfs.set_alpha(alpha)
-        else:
-            ax.pcolormesh(x_x, y_y, density, **pcolormesh_kwargs)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax

arviz/plots/backends/matplotlib/khatplot.py

@@ -1,241 +0,0 @@
-"""Matplotlib khatplot."""
-
-import warnings
-
-import matplotlib as mpl
-from matplotlib import cm
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.colors import to_rgba_array
-from packaging import version
-
-from ....stats.density_utils import histogram
-from ...plot_utils import _scale_fig_size, color_from_dim, set_xticklabels, vectorized_to_hex
-from . import backend_show, create_axes_grid, matplotlib_kwarg_dealiaser
-
-
-def plot_khat(
-    hover_label,
-    hover_format,
-    ax,
-    figsize,
-    xdata,
-    khats,
-    good_k,
-    kwargs,
-    threshold,
-    coord_labels,
-    show_hlines,
-    show_bins,
-    hlines_kwargs,
-    xlabels,
-    legend,
-    color,
-    dims,
-    textsize,
-    markersize,
-    n_data_points,
-    bin_format,
-    backend_kwargs,
-    show,
-):
-    """Matplotlib khat plot."""
-    if version.parse(mpl.__version__) >= version.parse("3.9.0.dev0"):
-        interactive_backends = mpl.backends.backend_registry.list_builtin(
-            mpl.backends.BackendFilter.INTERACTIVE
-        )
-    else:
-        interactive_backends = mpl.rcsetup.interactive_bk
-    if hover_label and mpl.get_backend() not in interactive_backends:
-        hover_label = False
-        warnings.warn(
-            "hover labels are only available with interactive backends. To switch to an "
-            "interactive backend from ipython or jupyter, use `%matplotlib` there should be "
-            "no need to restart the kernel. For other cases, see "
-            "https://matplotlib.org/3.1.0/tutorials/introductory/usage.html#backends",
-            UserWarning,
-        )
-
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwargs,
-    }
-
-    (figsize, ax_labelsize, _, xt_labelsize, linewidth, scaled_markersize) = _scale_fig_size(
-        figsize, textsize
-    )
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs["squeeze"] = True
-
-    if good_k is None:
-        good_k = 0.7
-
-    hlines_kwargs = matplotlib_kwarg_dealiaser(hlines_kwargs, "hlines")
-    hlines_kwargs.setdefault("hlines", [0, good_k, 1])
-    hlines_kwargs.setdefault("linestyle", [":", "-.", "--", "-"])
-    hlines_kwargs.setdefault("alpha", 0.7)
-    hlines_kwargs.setdefault("zorder", -1)
-    hlines_kwargs.setdefault("color", "C1")
-    hlines_kwargs["color"] = vectorized_to_hex(hlines_kwargs["color"])
-
-    if markersize is None:
-        markersize = scaled_markersize**2  # s in scatter plot mus be markersize square
-        # for dots to have the same size
-
-    kwargs = matplotlib_kwarg_dealiaser(kwargs, "scatter")
-    kwargs.setdefault("s", markersize)
-    kwargs.setdefault("marker", "+")
-
-    c_kwarg = kwargs.get("c", None)
-
-    if c_kwarg is None:
-        color_mapping = None
-        cmap = None
-        if isinstance(color, str):
-            if color in dims:
-                colors, color_mapping = color_from_dim(khats, color)
-                cmap_name = kwargs.get("cmap", plt.rcParams["image.cmap"])
-                cmap = getattr(cm, cmap_name)
-                rgba_c = cmap(colors)
-            else:
-                legend = False
-                rgba_c = to_rgba_array(np.full(n_data_points, color))
-        else:
-            legend = False
-            try:
-                rgba_c = to_rgba_array(color)
-            except ValueError:
-                cmap_name = kwargs.get("cmap", plt.rcParams["image.cmap"])
-                cmap = getattr(cm, cmap_name)
-                norm_fun = kwargs.get("norm", mpl.colors.Normalize(color.min(), color.max()))
-                rgba_c = cmap(norm_fun(color))
-
-        khats = khats if isinstance(khats, np.ndarray) else khats.values.flatten()
-        alphas = 0.5 + 0.2 * (khats > good_k) + 0.3 * (khats > 1)
-        rgba_c[:, 3] = alphas
-        rgba_c = vectorized_to_hex(rgba_c)
-        kwargs["c"] = rgba_c
-    else:
-        if isinstance(c_kwarg, str):
-            if c_kwarg in dims:
-                colors, color_mapping = color_from_dim(khats, c_kwarg)
-            else:
-                legend = False
-        else:
-            legend = False
-
-    if ax is None:
-        fig, ax = create_axes_grid(
-            1,
-            backend_kwargs=backend_kwargs,
-        )
-    else:
-        fig = ax.get_figure()
-
-    sc_plot = ax.scatter(xdata, khats, **kwargs)
-
-    if threshold is not None:
-        idxs = xdata[khats > threshold]
-        for idx in idxs:
-            ax.text(
-                idx,
-                khats[idx],
-                coord_labels[idx],
-                horizontalalignment="center",
-                verticalalignment="bottom",
-                fontsize=0.8 * xt_labelsize,
-            )
-
-    xmin, xmax = ax.get_xlim()
-    if show_bins:
-        xmax += n_data_points / 12
-    ylims1 = ax.get_ylim()
-    ylims2 = ax.get_ylim()
-    ymin = min(ylims1[0], ylims2[0])
-    ymax = min(ylims1[1], ylims2[1])
-
-    if show_hlines:
-        ax.hlines(
-            hlines_kwargs.pop("hlines"), xmin=xmin, xmax=xmax, linewidth=linewidth, **hlines_kwargs
-        )
-
-    if show_bins:
-        bin_edges = np.array([ymin, good_k, 1, ymax])
-        bin_edges = bin_edges[(bin_edges >= ymin) & (bin_edges <= ymax)]
-        hist, _, _ = histogram(khats, bin_edges)
-        for idx, count in enumerate(hist):
-            ax.text(
-                (n_data_points - 1 + xmax) / 2,
-                np.mean(bin_edges[idx : idx + 2]),
-                bin_format.format(count, count / n_data_points * 100),
-                horizontalalignment="center",
-                verticalalignment="center",
-            )
-
-    ax.set_xlabel("Data Point", fontsize=ax_labelsize)
-    ax.set_ylabel(r"Shape parameter k", fontsize=ax_labelsize)
-    ax.tick_params(labelsize=xt_labelsize)
-    if xlabels:
-        set_xticklabels(ax, coord_labels)
-        fig.autofmt_xdate()
-        fig.tight_layout()
-    if legend:
-        kwargs.pop("c")
-        ncols = len(color_mapping) // 6 + 1
-        for label, float_color in color_mapping.items():
-            ax.scatter([], [], c=[cmap(float_color)], label=label, **kwargs)
-        ax.legend(ncol=ncols, title=color)
-
-    if hover_label and mpl.get_backend() in mpl.rcsetup.interactive_bk:
-        _make_hover_annotation(fig, ax, sc_plot, coord_labels, rgba_c, hover_format)
-
-    if backend_show(show):
-        plt.show()
-
-    return ax
-
-
-def _make_hover_annotation(fig, ax, sc_plot, coord_labels, rgba_c, hover_format):
-    """Show data point label when hovering over it with mouse."""
-    annot = ax.annotate(
-        "",
-        xy=(0, 0),
-        xytext=(0, 0),
-        textcoords="offset points",
-        bbox=dict(boxstyle="round", fc="w", alpha=0.4),
-        arrowprops=dict(arrowstyle="->"),
-    )
-    annot.set_visible(False)
-    xmid = np.mean(ax.get_xlim())
-    ymid = np.mean(ax.get_ylim())
-    offset = 10
-
-    def update_annot(ind):
-        idx = ind["ind"][0]
-        pos = sc_plot.get_offsets()[idx]
-        annot_text = hover_format.format(idx, coord_labels[idx])
-        annot.xy = pos
-        annot.set_position(
-            (-offset if pos[0] > xmid else offset, -offset if pos[1] > ymid else offset)
-        )
-        annot.set_text(annot_text)
-        annot.get_bbox_patch().set_facecolor(rgba_c[idx])
-        annot.set_ha("right" if pos[0] > xmid else "left")
-        annot.set_va("top" if pos[1] > ymid else "bottom")
-
-    def hover(event):
-        vis = annot.get_visible()
-        if event.inaxes == ax:
-            cont, ind = sc_plot.contains(event)
-            if cont:
-                update_annot(ind)
-                annot.set_visible(True)
-                fig.canvas.draw_idle()
-            else:
-                if vis:
-                    annot.set_visible(False)
-                    fig.canvas.draw_idle()
-
-    fig.canvas.mpl_connect("motion_notify_event", hover)

arviz/plots/backends/matplotlib/lmplot.py

@@ -1,149 +0,0 @@
-"""Matplotlib plot linear regression figure."""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ...plot_utils import _scale_fig_size
-from ...hdiplot import plot_hdi
-from . import create_axes_grid, matplotlib_kwarg_dealiaser, backend_show, backend_kwarg_defaults
-
-
-def plot_lm(
-    x,
-    y,
-    y_model,
-    y_hat,
-    num_samples,
-    kind_pp,
-    kind_model,
-    xjitter,
-    length_plotters,
-    rows,
-    cols,
-    y_kwargs,
-    y_hat_plot_kwargs,
-    y_hat_fill_kwargs,
-    y_model_plot_kwargs,
-    y_model_fill_kwargs,
-    y_model_mean_kwargs,
-    backend_kwargs,
-    show,
-    figsize,
-    textsize,
-    axes,
-    legend,
-    grid,
-):
-    """Matplotlib Linear Regression."""
-    if backend_kwargs is None:
-        backend_kwargs = {}
-
-    backend_kwargs = {
-        **backend_kwarg_defaults(),
-        **backend_kwargs,
-    }
-
-    figsize, _, _, xt_labelsize, _, _ = _scale_fig_size(figsize, textsize, rows, cols)
-    backend_kwargs.setdefault("figsize", figsize)
-    backend_kwargs.setdefault("squeeze", False)
-
-    if axes is None:
-        _, axes = create_axes_grid(length_plotters, rows, cols, backend_kwargs=backend_kwargs)
-
-    for i, ax_i in enumerate(np.ravel(axes)[:length_plotters]):
-        # All the kwargs are defined here beforehand
-        y_kwargs = matplotlib_kwarg_dealiaser(y_kwargs, "plot")
-        y_kwargs.setdefault("color", "C3")
-        y_kwargs.setdefault("marker", ".")
-        y_kwargs.setdefault("markersize", 15)
-        y_kwargs.setdefault("linewidth", 0)
-        y_kwargs.setdefault("zorder", 10)
-        y_kwargs.setdefault("label", "observed_data")
-
-        y_hat_plot_kwargs = matplotlib_kwarg_dealiaser(y_hat_plot_kwargs, "plot")
-        y_hat_plot_kwargs.setdefault("color", "C1")
-        y_hat_plot_kwargs.setdefault("alpha", 0.3)
-        y_hat_plot_kwargs.setdefault("markersize", 10)
-        y_hat_plot_kwargs.setdefault("marker", ".")
-        y_hat_plot_kwargs.setdefault("linewidth", 0)
-
-        y_hat_fill_kwargs = matplotlib_kwarg_dealiaser(y_hat_fill_kwargs, "fill_between")
-        y_hat_fill_kwargs.setdefault("color", "C3")
-
-        y_model_plot_kwargs = matplotlib_kwarg_dealiaser(y_model_plot_kwargs, "plot")
-        y_model_plot_kwargs.setdefault("color", "C6")
-        y_model_plot_kwargs.setdefault("alpha", 0.5)
-        y_model_plot_kwargs.setdefault("linewidth", 0.5)
-        y_model_plot_kwargs.setdefault("zorder", 9)
-
-        y_model_fill_kwargs = matplotlib_kwarg_dealiaser(y_model_fill_kwargs, "fill_between")
-        y_model_fill_kwargs.setdefault("color", "C0")
-        y_model_fill_kwargs.setdefault("linewidth", 0.5)
-        y_model_fill_kwargs.setdefault("zorder", 9)
-        y_model_fill_kwargs.setdefault("alpha", 0.5)
-
-        y_model_mean_kwargs = matplotlib_kwarg_dealiaser(y_model_mean_kwargs, "plot")
-        y_model_mean_kwargs.setdefault("color", "C6")
-        y_model_mean_kwargs.setdefault("linewidth", 0.8)
-        y_model_mean_kwargs.setdefault("zorder", 11)
-
-        y_var_name, _, _, y_plotters = y[i]
-        x_var_name, _, _, x_plotters = x[i]
-        ax_i.plot(x_plotters, y_plotters, **y_kwargs)
-        ax_i.set_xlabel(x_var_name)
-        ax_i.set_ylabel(y_var_name)
-
-        if y_hat is not None:
-            _, _, _, y_hat_plotters = y_hat[i]
-            if kind_pp == "samples":
-                for j in range(num_samples):
-                    if xjitter is True:
-                        jitter_scale = x_plotters[1] - x_plotters[0]
-                        scale_high = jitter_scale * 0.2
-                        x_plotters_jitter = x_plotters + np.random.uniform(
-                            low=-scale_high, high=scale_high, size=len(x_plotters)
-                        )
-                        ax_i.plot(x_plotters_jitter, y_hat_plotters[..., j], **y_hat_plot_kwargs)
-                    else:
-                        ax_i.plot(x_plotters, y_hat_plotters[..., j], **y_hat_plot_kwargs)
-                ax_i.plot([], **y_hat_plot_kwargs, label="Posterior predictive samples")
-            else:
-                plot_hdi(x_plotters, y_hat_plotters, ax=ax_i, **y_hat_fill_kwargs)
-                ax_i.plot(
-                    [], color=y_hat_fill_kwargs["color"], label="Posterior predictive samples"
-                )
-
-        if y_model is not None:
-            _, _, _, y_model_plotters = y_model[i]
-
-            if kind_model == "lines":
-                # y_model_plotters should be (points, samples)
-                y_points = y_model_plotters.shape[0]
-                if x_plotters.shape[0] == y_points:
-                    for j in range(num_samples):
-                        ax_i.plot(x_plotters, y_model_plotters[:, j], **y_model_plot_kwargs)
-
-                    ax_i.plot([], **y_model_plot_kwargs, label="Uncertainty in mean")
-                    y_model_mean = np.mean(y_model_plotters, axis=1)
-                    ax_i.plot(x_plotters, y_model_mean, **y_model_mean_kwargs, label="Mean")
-
-            else:
-                plot_hdi(
-                    x_plotters,
-                    y_model_plotters,
-                    fill_kwargs=y_model_fill_kwargs,
-                    ax=ax_i,
-                )
-
-                ax_i.plot([], color=y_model_fill_kwargs["color"], label="Uncertainty in mean")
-                y_model_mean = np.mean(y_model_plotters, axis=0)
-                ax_i.plot(x_plotters, y_model_mean, **y_model_mean_kwargs, label="Mean")
-
-        if legend:
-            ax_i.legend(fontsize=xt_labelsize, loc="upper left")
-        if grid:
-            ax_i.grid(True)
-
-    if backend_show(show):
-        plt.show()
-    return axes