klib.describe.dist_plot()

Complexity

Conditions

10

Size

Total Lines	127
Code Lines	64

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

'''
def dist_plot(data, mean_color='orange', figsize=(14, 2), fill_range=(0.025, 0.975), hist=False, bins=None,
              showall=False, kde_kws=None, rug_kws=None, fill_kws=None, font_kws=None):
    '''
    Two-dimensional visualization of the distribution of numerical features.

    Parameters
    ----------
    data: 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: color, default 'orange'
        Color of the vertical line indicating the mean of the data.

    figsize: tuple, default (14, 2)
        Use to control the figure size.

    fill_range: tuple, default (0.025, 0.975)
        Use to control set the quantiles for shading. Default spans 95% of the data, which is about two std. deviations\
        above and below the mean.

    hist: bool, default False
        Set to True to display histogram bars in the plot.

    bins: integer, default None
        Specification of the number of hist bins. Requires hist = True

    showall: bool, default False
        Set to True to remove the output limit of 20 plots.

    kdw_kws: dict, default {'color': 'k', 'alpha': 0.7, 'linewidth': 1}
        Keyword arguments for kdeplot().

    rug_kws: dict, default {'color': 'brown', 'alpha': 0.5, 'linewidth': 2, 'height': 0.04}
        Keyword arguments for rugplot().

    fill_kws: dict, default {'color': 'brown', 'alpha': 0.1}
        Keyword arguments to control the fill.

    font_kws: dict, default {'color':  '#111111', 'weight': 'normal', 'size': 11}
        Keyword arguments to control the font.

    Returns
    -------
    ax: matplotlib Axes
        Returns the Axes object with the plot for further tweaking.

    '''

    # Validate Inputs
    _validate_input_bool(hist, 'hist')
    _validate_input_bool(showall, 'showall')
    _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')

    # 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 = drop_missing(pd.DataFrame(data).copy())  # remove empty columns / rows
    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:
            print(f'Dropped {dropped_values} missing values from column {col}.')
            col_data = data[col].dropna(axis=0)
        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