klib.describe.dist_plot()

Complexity

Conditions

10

Size

Total Lines	142
Code Lines	81

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

"""
def dist_plot(
    data: pd.DataFrame,
    mean_color: str = "orange",
    figsize: Tuple = (14, 2),
    fill_range: Tuple = (0.025, 0.975),
    hist: bool = False,
    bins: int = 10,
    showall: bool = False,
    kde_kws: Dict[str, Any] = None,
    rug_kws: Dict[str, Any] = None,
    fill_kws: Dict[str, Any] = None,
    font_kws: Dict[str, Any] = None,
):
    """ Two-dimensional visualization of the distribution of numerical features.

    Parameters
    ----------
    data : pd.DataFrame
        2D dataset that can be coerced into Pandas DataFrame. If a Pandas DataFrame is provided, the index/column \
    information is used to label the plots
    mean_color : str, optional
        Color of the vertical line indicating the mean of the data, by default "orange"
    figsize : Tuple, optional
        Controls the figure size, by default (14, 2)
    fill_range : Tuple, optional
        Set the quantiles for shading. Default spans 95% of the data, which is about two std. deviations \
        above and below the mean, by default (0.025, 0.975)
    hist : bool, optional
        Set to True to display histogram bars in the plot, by default False
    bins : int, optional
        Specification of the number of hist bins. Requires hist = True, by default 10
    showall : bool, optional
        Set to True to remove the output limit of 20 plots, by default False
    kde_kws : Dict[str, Any], optional
        Keyword arguments for kdeplot(), by default {'color': 'k', 'alpha': 0.7, 'linewidth': 1}
    rug_kws : Dict[str, Any], optional
        Keyword arguments for rugplot(), by default {'color': 'brown', 'alpha': 0.5, 'linewidth': 2, 'height': 0.04}
    fill_kws : Dict[str, Any], optional
        Keyword arguments to control the fill, by default {'color': 'brown', 'alpha': 0.1}
    font_kws : Dict[str, Any], optional
        Keyword arguments to control the font, by default {'color':  '#111111', 'weight': 'normal', 'size': 11}

    Returns
    -------
    [type]
        [description]
    """

    # Validate Inputs
    _validate_input_range(fill_range[0], "fill_range_lower", 0, 1)
    _validate_input_range(fill_range[1], "fill_range_upper", 0, 1)
    _validate_input_smaller(fill_range[0], fill_range[1], "fill_range")
    _validate_input_bool(hist, "hist")
    _validate_input_int(bins, "bins")
    _validate_input_range(bins, "bins", 0, data.shape[0])
    _validate_input_bool(showall, "showall")

    # Handle dictionary defaults
    kde_kws = {"alpha": 0.7, "linewidth": 1.5} if kde_kws is None else kde_kws.copy()
    rug_kws = {"color": "brown", "alpha": 0.5, "linewidth": 2, "height": 0.04} if rug_kws is None else rug_kws.copy()
    fill_kws = {"color": "brown", "alpha": 0.1} if fill_kws is None else fill_kws.copy()
    font_kws = {"color": "#111111", "weight": "normal", "size": 11} if font_kws is None else font_kws.copy()

    data = pd.DataFrame(data.copy()).dropna(axis=1, how="all")
    cols = list(data.select_dtypes(include=["number"]).columns)
    data = data[cols]

    if len(cols) == 0:
        print("No columns with numeric data were detected.")

    elif len(cols) >= 20 and showall is False:
        print(
            f"Note: The number of numerical features is very large ({len(cols)}), please consider splitting the data. "
            "Showing plots for the first 20 numerical features. Override this by setting showall=True."
        )
        cols = cols[:20]

    for col in cols:
        dropped_values = data[col].isna().sum()
        if dropped_values > 0:
            col_data = data[col].dropna(axis=0)
            print(f"Dropped {dropped_values} missing values from column {col}.")

        else:
            col_data = data[col]

        _, ax = plt.subplots(figsize=figsize)
        ax = sns.distplot(
            col_data,
            bins=bins,
            hist=hist,
            rug=True,
            kde_kws=kde_kws,
            rug_kws=rug_kws,
            hist_kws={"alpha": 0.5, "histtype": "step"},
        )

        # Vertical lines and fill
        x, y = ax.lines[0].get_xydata().T
        ax.fill_between(
            x,
            y,
            where=((x >= np.quantile(col_data, fill_range[0])) & (x <= np.quantile(col_data, fill_range[1]))),
            label=f"{fill_range[0]*100:.1f}% - {fill_range[1]*100:.1f}%",
            **fill_kws,
        )

        mean = np.mean(col_data)
        std = scipy.stats.tstd(col_data)
        ax.vlines(x=mean, ymin=0, ymax=np.interp(mean, x, y), ls="dotted", color=mean_color, lw=2, label="mean")
        ax.vlines(
            x=np.median(col_data), ymin=0, ymax=np.interp(np.median(col_data), x, y), ls=":", color=".3", label="median"
        )
        ax.vlines(
            x=[mean - std, mean + std],
            ymin=0,
            ymax=[np.interp(mean - std, x, y), np.interp(mean + std, x, y)],
            ls=":",
            color=".5",
            label="\u03BC \u00B1 \u03C3",
        )

        ax.set_ylim(0,)
        ax.set_xlim(ax.get_xlim()[0] * 1.15, ax.get_xlim()[1] * 1.15)

        # Annotations and legend
        ax.text(0.01, 0.85, f"Mean: {np.round(mean,2)}", fontdict=font_kws, transform=ax.transAxes)
        ax.text(0.01, 0.7, f"Std. dev: {np.round(std,2)}", fontdict=font_kws, transform=ax.transAxes)
        ax.text(
            0.01, 0.55, f"Skew: {np.round(scipy.stats.skew(col_data),2)}", fontdict=font_kws, transform=ax.transAxes
        )
        ax.text(
            0.01,
            0.4,
            f"Kurtosis: {np.round(scipy.stats.kurtosis(col_data),2)}",  # Excess Kurtosis
            fontdict=font_kws,
            transform=ax.transAxes,
        )
        ax.text(0.01, 0.25, f"Count: {np.round(len(col_data))}", fontdict=font_kws, transform=ax.transAxes)
        ax.legend(loc="upper right")

    return ax