klib.describe.dist_plot()

Complexity

Conditions

11

Size

Total Lines	139
Code Lines	72

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 None
        Keyword arguments for kdeplot().

    rug_kws: dict, default None
        Keyword arguments for rugplot().

    fill_kws: dict, default None
        Keyword arguments to control the fill.

    font_kws: dict, default None
        Keyword arguments to control the font.

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

    '''

    # Validate Inputs
    _validate_input_range(fill_range[0], 'fill_range_lower', 0, 1)
    _validate_input_range(fill_range[1], 'fill_range_upper', 0, 1)
    if fill_range[0] >= fill_range[1]:
        raise ValueError('Start value for fill_range must be lower than upper value.')
    _validate_input_bool(hist, 'hist')
    _validate_input_bool(showall, 'showall')

    # Handle dictionary defaults
    kde_kws = {} if kde_kws is None else kde_kws.copy()
    rug_kws = {} if rug_kws is None else rug_kws.copy()
    fill_kws = {} if fill_kws is None else fill_kws.copy()
    font_kws = {} if font_kws is None else font_kws.copy()

    data = drop_missing(pd.DataFrame(data).copy())  # drop empty columns and rows
    cols = list(data.select_dtypes(include=['number']).columns)  # numeric cols
    data = data[cols]

    # Default settings
    kde_kws = {'color': 'k', 'alpha': 0.7, 'linewidth': 1, **kde_kws}
    rug_kws = {'color': 'brown', 'alpha': 0.5, 'linewidth': 2, 'height': 0.04, **rug_kws}
    fill_kws = {'color': 'brown', 'alpha': 0.1, **fill_kws}
    font_kws = {'color':  '#111111', 'weight': 'normal', 'size': 11, **font_kws}

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

    else:
        if 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]

        ax = []
        for col in cols:
            # Drop missing values
            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
            line = ax.lines[0]
            x = line.get_xydata()[:, 0]
            y = line.get_xydata()[:, 1]
            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:.0f}% - {fill_range[1]*100:.0f}%',
                            **fill_kws)

            ax.vlines(x=np.mean(col_data),
                      ymin=0,
                      ymax=np.interp(np.mean(col_data), 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=np.quantile(col_data, 0.25),
                      ymin=0,
                      ymax=np.interp(np.quantile(col_data, 0.25), x, y), ls=':', color='.5', label='25%')
            ax.vlines(x=np.quantile(col_data, 0.75),
                      ymin=0,
                      ymax=np.interp(np.quantile(col_data, 0.75), x, y), ls=':', color='.5', label='75%')

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

            # Annotations and legend
            ax.text(0.01, 0.85, f'Mean: {np.round(np.mean(col_data),2)}',
                    fontdict=font_kws, transform=ax.transAxes)
            ax.text(0.01, 0.7, f'Std. dev: {np.round(scipy.stats.tstd(col_data),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