oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.9rc1__py3-none-any.whl

ads/dataset/sampled_dataset.py

@@ -0,0 +1,1050 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2020, 2024 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import itertools
+
+from matplotlib.patches import BoxStyle
+
+from ads.dataset.label_encoder import DataFrameLabelEncoder
+from sklearn.feature_selection import SelectKBest
+from sklearn.feature_selection import chi2
+from sklearn.preprocessing import MinMaxScaler
+
+import matplotlib.font_manager
+from ads.common import utils, logger
+from ads.dataset.helper import (
+    fix_column_names,
+    convert_columns,
+    get_feature_type,
+    convert_to_html,
+)
+from ads.dataset.plot import Plotting
+from ads.dataset.progress import DummyProgressBar
+from ads.dataset.timeseries import Timeseries
+from ads.type_discovery.type_discovery_driver import TypeDiscoveryDriver
+from ads.type_discovery.typed_feature import (
+    DateTimeTypedFeature,
+    ContinuousTypedFeature,
+    GISTypedFeature,
+    ConstantTypedFeature,
+    CreditCardTypedFeature,
+    ZipcodeTypedFeature,
+    PhoneNumberTypedFeature,
+    OrdinalTypedFeature,
+    CategoricalTypedFeature,
+    DocumentTypedFeature,
+    AddressTypedFeature,
+)
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+
+NATURAL_EARTH_DATASET = "naturalearth_lowres"
+
+
+class PandasDataset(object):
+    """
+    This class provides APIs that can work on a sampled dataset.
+    """
+
+    def __init__(
+        self,
+        sampled_df,
+        type_discovery=True,
+        types={},
+        metadata=None,
+        progress=DummyProgressBar(),
+    ):
+        self.client = None
+        self.sampled_df = fix_column_names(sampled_df)
+        self.correlation = None
+        self.feature_dist_html_dict = {}
+        self.feature_types = metadata if metadata is not None else {}
+        self.world = None
+
+        self.numeric_columns = self.sampled_df.select_dtypes(
+            utils.numeric_pandas_dtypes()
+        ).columns.values
+
+        # run type discovery
+        if len(self.feature_types) == 0:
+            if len(types) != 0:
+                # update feature types as it is for the types given by user
+                self._update_feature_types(types.keys())
+            if type_discovery:
+                try:
+                    #
+                    # perform type-discovery
+                    #
+                    progress.update("Running data type discovery")
+                    tdd = TypeDiscoveryDriver()
+                    self.feature_types = {
+                        col_name: tdd.discover(col_name, col_vals)
+                        for col_name, col_vals in self.sampled_df.items()
+                        if col_name not in types
+                    }
+                except Exception as e:
+                    print(
+                        f"An error occured while performing typed discovery on this dataset. Try running again with "
+                        f"`type_discovery=False`"
+                    )
+                    raise e
+
+        # convert dataframe columns to the data types discovered.
+        self.sampled_df = convert_columns(self.sampled_df, self.feature_types)
+
+        # update feature types for rest of the columns - no type discovery, does not include user overrides
+        self._update_feature_types(
+            set(self.sampled_df.columns.values) - set(self.feature_types.keys())
+        )
+        self.sampled_df = self.sampled_df.reset_index(drop=True)
+
+    def _find_feature_subset(self, df, target_name, include_n_features=32):
+        if len(df.columns) <= include_n_features:
+            return self.sampled_df
+        else:
+            try:
+                y = df[target_name]
+                X = df.drop(columns=[target_name])
+                X_columns = X.columns
+
+                X = X.fillna(X.mode().iloc[0])
+                X = DataFrameLabelEncoder().fit_transform(X)
+                X = MinMaxScaler().fit_transform(X)
+
+                from sklearn.impute import SimpleImputer
+
+                imp_most_freq = SimpleImputer(strategy="most_frequent")
+                X = imp_most_freq.fit_transform(X)
+
+                est = SelectKBest(score_func=chi2, k=include_n_features)
+                est.fit_transform(X, y)
+
+                subset_features = [self.target.name] + list(
+                    itertools.compress(X_columns, est.get_support())
+                )
+
+                return self.sampled_df.filter(subset_features, axis=1)
+
+            except Exception as e:
+                print("_find_feature_subset failed: ", str(e))
+                return pd.DataFrame()
+
+    def _update_multiple_outputs(self, out, msg):
+        if isinstance(out, (list, tuple)):
+            for o in out:
+                o.value = msg
+        else:
+            self._update_multiple_outputs([out], msg)
+
+    def _calculate_dataset_statistics(self, is_wide_dataset, out):
+        #
+        # first the missing values for non-wide datasets
+        #
+        df_missing = pd.DataFrame()
+        df_skew = pd.DataFrame()
+
+        if is_wide_dataset:
+            df_missing = pd.DataFrame()  # empty dataframe when not calculating
+            df_skew = pd.DataFrame()  # empty dataframe when not calculating
+        else:
+            #
+            # count missing values
+            #
+            d = {column_name: np.nan for column_name in self.df.columns}  # default
+            for column_name in self.df.columns:
+                self._update_multiple_outputs(
+                    out, f"calculating missing values (<code>{column_name}</code>)..."
+                )
+                d[column_name] = self.df[column_name].isna().sum()
+
+            df_missing = pd.DataFrame.from_dict(d, orient="index", columns=["missing"])
+
+            #
+            # calculate skew
+            #
+            d = {column_name: np.nan for column_name in self.df.columns}  # default
+            for column_name in self.numeric_columns:
+                self._update_multiple_outputs(
+                    out, f"calculating skew (<code>{column_name}</code>)..."
+                )
+                if len(self.df[column_name].dropna()) > 0:
+                    d[column_name] = self.df[column_name].dropna().skew()
+                else:
+                    d[column_name] = np.nan
+            df_skew = pd.DataFrame.from_dict(d, orient="index", columns=["skew"])
+            self._update_multiple_outputs(out, "calculating dataset statistics...")
+            for col in self.df.columns:
+                if df_missing["missing"][col] == len(self.df[col]):
+                    self.df[col] = self.df[col].astype("object")
+
+        #
+        # compute descriptive dataset statistics
+        df_stats = self.df.describe(include="all").round(2)
+
+        self._update_multiple_outputs(out, "transpose dataset statistics...")
+        df_stats = df_stats.transpose()
+
+        self._update_multiple_outputs(out, "finalizing dataset statistics...")
+        df_stats = df_stats.fillna("")
+
+        #
+        # we join the stats with missing df if we computed that
+        #
+        self._update_multiple_outputs(
+            out, "Assembling statistics into single result..."
+        )
+        if not df_missing.empty:
+            df_stats = df_stats.join(df_missing).fillna("")
+        if not df_skew.empty:
+            df_stats = df_stats.join(df_skew).fillna("")
+
+        return df_stats
+
+    def _generate_features_html(
+        self, is_wide_dataset, n_features, df_stats, visualizations_follow
+    ):
+        html = utils.get_bootstrap_styles()
+
+        if is_wide_dataset:
+            html += """<p>The dataset has too many columns ({:,}) to
+                efficiently show feature visualizations, instead only showing table of
+                statistics</p>""".format(
+                n_features
+            )
+
+        html += "<p><b>&#x2022; Note</b> these are computed on the entire dataset.</p>"
+        html += "<hr>"
+        html += (
+            df_stats.replace(np.nan, "")
+            .style.set_table_styles(utils.get_dataframe_styles(max_width=125))
+            .set_table_attributes("class=table")
+            .format(
+                lambda x: "{:.8g}".format(x)
+                if ("float" in str(type(x))) or ("int" in str(type(x)))
+                else x
+            )
+            .to_html()
+        )
+
+        if visualizations_follow:
+            html += "<br><hr><h2>Feature Visualizations...</h2>"
+
+        return html
+
+    def _generate_warnings_html(
+        self, is_wide_dataset, n_rows, n_features, df_stats, out, accordion
+    ):
+        #
+        # create the "Warnings" accordion section:
+        #  - show high cardinal categoricals
+        #  - show high missing values
+        #  - large number of zeros (not for wide datasets - slow to compute)
+        #
+        #
+
+        accum = []
+
+        ignored_feature_types = ["document"]
+
+        # more than 5% missing is a warning
+        #
+
+        if "missing" in df_stats.columns:
+            df_missing = df_stats[["missing"]][df_stats["missing"] != ""]
+            if not df_missing.empty:
+                # ignore document types
+                for column_name, missing in df_missing.iterrows():
+                    if (
+                        self.feature_types[column_name]["type"]
+                        not in ignored_feature_types
+                    ):
+                        missing_values = float(missing[0])
+                        missing_pct = 100 * missing_values / n_rows
+                        if missing_pct >= 5:
+                            accum.append(
+                                {
+                                    "label": "missing",
+                                    "message": f"<code>{column_name}</code> has {missing_values} ({missing_pct:.1f}%) missing values. Consider remove the column or replace null values.",
+                                }
+                            )
+                        if missing_pct == 100:
+                            accum.append(
+                                {
+                                    "label": "missing",
+                                    "message": f"<code>{column_name}</code> is excluded from correlation computation due to {missing_values} ({missing_pct:.1f}%) missing values.",
+                                }
+                            )
+
+        # abs skew > 20 skewness warning issues
+        #
+
+        if "skew" in df_stats.columns:
+            df_skew = df_stats[["skew"]][df_stats["skew"] != ""]
+            if not df_skew.empty:
+                # ignore document types
+                for column_name, skew in df_skew.iterrows():
+                    if (
+                        self.feature_types[column_name]["type"]
+                        not in ignored_feature_types
+                    ):
+                        skewness = float(skew[0])
+                        if abs(skewness) >= 20:
+                            accum.append(
+                                {
+                                    "label": "skew",
+                                    "message": f"<code>{column_name}</code> has skew of {skewness:.3f}",
+                                }
+                            )
+
+        # high cardinality (> 15 unique values) is a warning
+        #
+
+        if "unique" in df_stats.columns:
+            for column_name, count in df_stats[["unique"]][
+                df_stats["unique"] != ""
+            ].iterrows():
+                # ignore document types
+                if self.feature_types[column_name]["type"] not in ignored_feature_types:
+                    out.value = (
+                        f"Analyzing cadinalities (<code>{column_name}</code>)..."
+                    )
+                    unique = self.df[column_name].unique().shape[0]
+                    if unique == n_rows:
+                        accum.append(
+                            {
+                                "label": "high-cardinality",
+                                "message": f"<code>{column_name}</code> has a high cardinality: every value is distinct",
+                            }
+                        )
+                    elif unique > 15:
+                        accum.append(
+                            {
+                                "label": "high-cardinality",
+                                "message": f"<code>{column_name}</code> has a high cardinality: {unique} distinct values",
+                            }
+                        )
+
+        if not is_wide_dataset:
+            # more than 10% zeros is a warning
+            if "min" in df_stats.columns:
+                for column_name, count in df_stats[["min"]][
+                    df_stats["min"] != ""
+                ].iterrows():
+                    if (
+                        self.feature_types[column_name]["type"]
+                        not in ignored_feature_types
+                    ):
+                        out.value = f"Analyzing zeros (<code>{column_name}</code>)..."
+                        # we've filtered on only columns that have a min value of 0 for speed
+                        zeros = self.df[self.df[column_name] == 0].shape[0]
+                        zeros_pct = 100 * zeros / n_rows
+                        if zeros_pct >= 10:
+                            accum.append(
+                                {
+                                    "label": "zeros",
+                                    "message": f"<code>{column_name}</code> has {zeros} ({zeros_pct:.2f}%) zeros)",
+                                }
+                            )
+
+        #
+        # collect the warnings into an HTML presentation
+        #
+
+        out.value = "Assembling results..."
+
+        if accum:
+            html = utils.get_bootstrap_styles()
+
+            html += utils.highlight_text(f"{len(accum)} WARNING(S) found")
+
+            accordion.set_title(3, f"Warnings ({len(accum)})")
+
+            html += "<hr>"
+
+            tr_rows = [
+                f"""
+                <tr style="border-top:0">
+                       <td>
+                        {feature_warning['message']}
+                       <td>
+                        <span class="label label-{feature_warning['label']}">{feature_warning['label']}</span>
+                       </td>
+                </tr>
+            """.strip()
+                for feature_warning in accum
+            ]
+
+            html += """
+                <table style="width: 100%; max-width: 100%;">
+                <tbody>
+                {}
+                </tbody>
+                </table>""".format(
+                "\n".join(tr_rows)
+            )
+
+            return html
+
+        else:
+            return "<h3>No Feature warnings found</h3>"
+
+    def summary(self, feature_name=None):
+        """
+        Display list of features & their datatypes.
+        Shows the column name and the feature's meta_data if given a specific feature name.
+
+        Parameters
+        ----------
+        date_col: str
+            The name of the feature
+
+        Returns
+        -------
+        dict
+            a dictionary that contains requested information
+        """
+
+        feature_n_datatype = {}
+        list_of_dfs = []
+
+        if feature_name is None:
+            feature_n_datatype = {
+                col: self.feature_types[col].type
+                + "/"
+                + self.feature_types[col].low_level_type
+                for col in self.sampled_df.columns
+            }
+            df = pd.DataFrame(
+                feature_n_datatype.items(), columns=["Feature", "Datatype"]
+            )
+        else:
+            if isinstance(feature_name, (list, tuple, pd.core.indexes.base.Index)):
+                feature_names = list(feature_name)
+            else:
+                feature_names = [feature_name]
+
+            for col in feature_names:
+                if col in self.sampled_df.columns:
+                    feature_n_datatype[col] = {
+                        k: v
+                        for k, v in self.feature_types[col].meta_data.items()
+                        if k not in ["internal", "feature_name"]
+                    }
+                    new_dict = utils.flatten(feature_n_datatype[col])
+                    tmp_df = pd.DataFrame.from_dict(
+                        new_dict,
+                        orient="index",
+                        columns=[feature_names[feature_names.index(str(col))]],
+                    )
+                    list_of_dfs.append(tmp_df)
+                else:
+                    feature_n_datatype[col] = None
+
+            df = pd.concat(list_of_dfs, axis=1).transpose().fillna("-")
+
+            # get all the unique types from df
+            new_list_dfs = []
+            for t in df.type.unique():
+                new_list_dfs.append(df[df["type"] == t])
+            df = pd.concat(new_list_dfs)
+
+            # reorder columns in df
+
+            # get a list of columns
+            cols = list(df)
+            # move the column to head of list using index, pop and insert
+            cols.insert(0, cols.pop(cols.index("low_level_type")))
+            cols.insert(0, cols.pop(cols.index("type")))
+            df = df.loc[:, cols]
+
+        return df
+
+    def timeseries(self, date_col):
+        """
+        Supports any plotting operations where x=datetime.
+
+        Parameters
+        ----------
+        date_col: str
+            The name of the feature to plot
+
+        Returns
+        -------
+        func
+            a plotting object that contains a date column and dataframe
+        """
+
+        if date_col in self.feature_types and isinstance(
+            self.feature_types[date_col], DateTimeTypedFeature
+        ):
+            return Timeseries(date_col, self.sampled_df)
+        else:
+            raise ValueError("Not a date time column.")
+
+    def plot(
+        self, x, y=None, plot_type="infer", yscale=None, verbose=True, sample_size=0
+    ):
+        """
+        Supports plotting feature distribution, and relationship between features.
+
+        Parameters
+        ----------
+        x: str
+            The name of the feature to plot
+        y: str, optional
+            Name of the feature to plot against x
+        plot_type: str, default: infer
+            Override the inferred plot type for certain combinations of the data types of x and y.
+            By default, the best plot type is inferred based on x and y data types.
+            Valid values:
+
+            - box_plot - discrete feature vs continuous feature. Draw a box plot to show
+              distributions with respect to categories,
+            - scatter - continuous feature vs continuous feature. Draw a scatter plot
+              with possibility of several semantic groupings.
+
+        yscale : str, optional
+            One of {"linear", "log", "symlog", "logit"}.
+            The y axis scale type to apply. Can be used when either x or y is an ordinal feature.
+        verbose: bool, default True
+            Displays Note/Tips if True
+        """
+        sample_size = int(sample_size)
+        min_sample_size = 10000
+        if sample_size == 0:
+            sub_samp_size = len(self.sampled_df)
+            sub_samp_df = self.sampled_df
+        else:
+            sub_samp_size = max(min(sample_size, len(self.sampled_df)), min_sample_size)
+            sub_samp_df = self.sampled_df.sample(n=sub_samp_size)
+        plot = Plotting(
+            sub_samp_df, self.feature_types, x, y=y, plot_type=plot_type, yscale=yscale
+        )
+        if verbose:
+            if len(self.df) != sub_samp_size:
+                logger.info(f"Downsampling from dataset for graphing.")
+        return plot
+
+    @runtime_dependency(module="geopandas", install_from=OptionalDependency.GEO)
+    def plot_gis_scatter(self, lon="longitude", lat="latitude", ax=None):
+        """
+        Supports plotting Choropleth maps
+
+        Parameters
+        ----------
+        df: pandas dataframe
+            The dataframe to plot
+        x: str
+            The name of the feature to plot, usually the longitude
+        y: str
+            THe name of the feature to plot, usually the latitude
+        """
+        if lon in self.sampled_df.columns and lat in self.sampled_df.columns:
+            if ax is None:
+                fig, ax = plt.subplots(1, figsize=(10, 10))
+            gdf = geopandas.GeoDataFrame(
+                self.sampled_df,
+                geometry=geopandas.points_from_xy(
+                    self.sampled_df[lon], self.sampled_df[lat]
+                ),
+            )
+            world = geopandas.read_file(
+                geopandas.datasets.get_path(NATURAL_EARTH_DATASET)
+            )
+            ax1 = world.plot(ax=ax, color="lightgrey", linewidth=0.5, edgecolor="white")
+            gdf.plot(ax=ax1, color="blue", markersize=10)
+
+        else:
+            if len(self.sampled_df.columns) > 0:
+                logger.info(
+                    "The available latitude and longitude columns are: "
+                    + ", ".join(self.sampled_df.columns)
+                    + "."
+                )
+            else:
+                logger.info("There are no latitude and longitude columns available.")
+
+    """
+    Internal methods
+    """
+
+    def _update_feature_types(self, columns):
+        # Build feature types for columns which are not type discovered, by using the inferred type as it is
+        for column in columns:
+            self.feature_types[column] = get_feature_type(
+                column, self.sampled_df[column]
+            )
+
+    @runtime_dependency(module="geopandas", install_from=OptionalDependency.GEO)
+    def _visualize_feature_distribution(self, html_widget):
+        """
+        This function is called once per dataset to generate html for feature distribution plots.
+        """
+        if len(self.feature_dist_html_dict) > 0:
+            return self.feature_dist_html_dict
+
+        feature_dist_html = ""
+        figsize = (6.5, 2)
+
+        props = {
+            "boxstyle": BoxStyle("Round", pad=0),
+            "facecolor": "white",
+            "linestyle": "solid",
+            "linewidth": 0,
+            "edgecolor": "white",
+        }
+
+        font = {"size": 10}
+
+        matplotlib.rc("font", **font)
+
+        red_square = dict(markerfacecolor="r", marker="s")
+
+        blues = [
+            "#AED6F1",
+            "#85C1E9",
+            "#5DADE2",
+            "#3498DB",
+            "#2E86C1",
+            "#2874A6",
+            "#1B4F72",
+        ]
+        bright_colors = ["red", "green", "blue", "yellow", "green"]
+
+        for col_index, col in enumerate(self.sampled_df.columns):
+            feature_metadata = self.feature_types[col].meta_data
+            text = "\n".join(
+                [
+                    f"{col}\n",
+                    "  - type: {} ({})".format(
+                        self.feature_types[col].type,
+                        self.feature_types[col].low_level_type,
+                    ),
+                    "  - missing_percentage: {:.1f}%".format(
+                        self.feature_types[col].missing_percentage
+                    ),
+                ]
+            )
+
+            fig, ax = PandasDataset._init_fig_ax(figsize)
+
+            if isinstance(self.feature_types[col], ContinuousTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                self.sampled_df[col].plot(
+                    kind="box",
+                    vert=False,
+                    flierprops=red_square,
+                    ax=ax,
+                    figsize=figsize,
+                )
+
+            elif isinstance(self.feature_types[col], DateTimeTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                from matplotlib.dates import AutoDateFormatter, AutoDateLocator
+
+                loc = AutoDateLocator(interval_multiples=False)
+                ax.xaxis.set_major_locator(loc)
+                ax.xaxis.set_major_formatter(AutoDateFormatter(loc))
+                self.sampled_df[col].hist(
+                    bins=50,
+                    grid=False,
+                    xrot=45,
+                    ax=ax,
+                    rwidth=0.95,
+                    color=blues[-1],
+                    figsize=figsize,
+                )
+
+            elif isinstance(self.feature_types[col], GISTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                df = pd.DataFrame(
+                    feature_metadata["internal"]["sample"], columns=["lat", "lon"]
+                )
+                gdf = geopandas.GeoDataFrame(
+                    df, geometry=geopandas.points_from_xy(df["lon"], df["lat"])
+                )
+
+                if not self.world:
+                    self.world = geopandas.read_file(
+                        geopandas.datasets.get_path(NATURAL_EARTH_DATASET)
+                    )
+
+                self.world.plot(
+                    ax=ax, color="lightgrey", linewidth=0.5, edgecolor="white"
+                )
+                gdf.plot(ax=ax, color="blue", markersize=10)
+                ax.set_aspect("auto")
+
+            elif (
+                isinstance(self.feature_types[col], ConstantTypedFeature)
+                and feature_metadata["missing_percentage"] < 100
+            ):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                pd.Series(
+                    feature_metadata["internal"]["counts"],
+                    name=col,
+                    index=feature_metadata["internal"]["counts"].keys(),
+                ).plot(kind="barh", ax=ax, width=0.95, figsize=figsize, color=["black"])
+
+            elif isinstance(self.feature_types[col], CreditCardTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                sorted_by_value = sorted(
+                    feature_metadata["internal"]["counts"],
+                    key=feature_metadata["internal"]["counts"].get,
+                    reverse=True,
+                )
+                pd.Series(
+                    feature_metadata["internal"]["counts"],
+                    name=col,
+                    index=sorted_by_value,
+                ).plot(kind="bar", ax=ax, width=0.95, figsize=figsize, color=blues)
+
+            elif isinstance(self.feature_types[col], ZipcodeTypedFeature):
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                pd.Series(
+                    feature_metadata["internal"]["histogram"],
+                    name=col,
+                    index=feature_metadata["internal"]["histogram"].keys(),
+                ).plot(kind="bar", ax=ax, figsize=figsize, color=blues)
+
+            elif isinstance(self.feature_types[col], PhoneNumberTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                pd.Series(
+                    feature_metadata["internal"]["counts"],
+                    name=col,
+                    index=feature_metadata["internal"]["counts"].keys(),
+                ).plot(kind="bar", ax=ax, figsize=figsize, color=blues)
+
+            elif isinstance(self.feature_types[col], OrdinalTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+                high_cardinality = feature_metadata["internal"]["high_cardinality"]
+                very_high_cardinality = feature_metadata["internal"][
+                    "very_high_cardinality"
+                ]
+
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+
+                if very_high_cardinality:
+                    addrtext = "Samples:\n\n"
+                    addrtext += ", ".join(
+                        feature_metadata["internal"]["counts"]
+                        .keys()
+                        .astype(str)
+                        .to_list()[:6]
+                    )
+
+                    ax.text(
+                        0.05,
+                        0.95,
+                        addrtext,
+                        transform=ax.transAxes,
+                        fontsize=10,
+                        verticalalignment="top",
+                        bbox=props,
+                    )
+                    ax.axis("off")
+
+                else:
+                    if high_cardinality:
+                        text += (
+                            "\n\n  NOTE: plot has been capped\n  from %d to show only most\n  common top %d "
+                            "categories"
+                            % (
+                                feature_metadata["internal"]["unique"],
+                                len(feature_metadata["internal"]["counts"].keys()),
+                            )
+                        )
+
+                    if feature_metadata["internal"]["unique"] < 24:
+                        pd.Series(
+                            feature_metadata["internal"]["counts"],
+                            name=col,
+                            index=feature_metadata["internal"]["counts"].keys(),
+                        ).plot(
+                            kind="bar",
+                            ax=ax,
+                            width=0.90,
+                            color=blues[-1],
+                            figsize=figsize,
+                        )
+                    else:
+                        self.sampled_df[col].plot(
+                            kind="hist",
+                            grid=False,
+                            rwidth=0.95,
+                            ax=ax,
+                            color=blues[-1],
+                            figsize=figsize,
+                        )
+
+            elif isinstance(self.feature_types[col], CategoricalTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type, feature_metadata["stats"]
+                )
+
+                high_cardinality = feature_metadata["internal"]["high_cardinality"]
+                very_high_cardinality = feature_metadata["internal"][
+                    "very_high_cardinality"
+                ]
+
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+
+                if very_high_cardinality:
+                    # grab the first few examples as strings
+                    addrtext = "Samples:\n\n"
+                    addrtext += "\n".join(
+                        [
+                            utils.ellipsis_strings(x, 65)
+                            for x in feature_metadata["internal"]["counts"]
+                            .keys()
+                            .astype(str)
+                            .to_list()[:3]
+                        ]
+                    )
+                    ax.text(
+                        0.05,
+                        0.95,
+                        addrtext,
+                        transform=ax.transAxes,
+                        fontsize=10,
+                        verticalalignment="top",
+                        bbox=props,
+                    )
+                    ax.axis("off")
+
+                else:
+                    text += PandasDataset._format_stats(
+                        self.feature_types[col].type, feature_metadata["stats"]
+                    )
+                    if high_cardinality:
+                        text += (
+                            "\n\n  NOTE: plot has been capped\n  to show only most\n  common top %d categories"
+                            % (len(feature_metadata["internal"]["counts"].keys()))
+                        )
+
+                    if feature_metadata["internal"]["unique"] == 2:
+                        #
+                        # binary
+                        #
+                        count_series = pd.Series(
+                            feature_metadata["internal"]["counts"],
+                            name=col,
+                            index=feature_metadata["internal"]["counts"].keys(),
+                        ).astype(float)
+                        ax1 = count_series.plot(
+                            kind="barh",
+                            ax=ax,
+                            width=0.95,
+                            figsize=figsize,
+                            color=[blues[0], blues[-1]],
+                        )
+                        # x_labels = utils.ellipsis_strings(feature_metadata['internal']['counts'].keys().astype(str))
+                        # ax1.set_xticklabels(x_labels)
+                    else:
+                        #
+                        # multiclass, potentially high cardinality
+                        #
+
+                        ax1 = pd.Series(
+                            feature_metadata["internal"]["counts"],
+                            name=col,
+                            index=feature_metadata["internal"]["counts"].keys(),
+                        ).plot(
+                            kind="bar", ax=ax, width=0.95, color=blues, figsize=figsize
+                        )
+
+                        x_labels = utils.ellipsis_strings(
+                            feature_metadata["internal"]["counts"].keys()
+                        )
+                        ax1.set_xticklabels(x_labels)
+
+            elif isinstance(
+                self.feature_types[col], DocumentTypedFeature
+            ) or isinstance(self.feature_types[col], AddressTypedFeature):
+                text += PandasDataset._format_stats(
+                    self.feature_types[col].type,
+                    {k: v for k, v in feature_metadata["stats"].items()},
+                )
+
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                )
+                if "word_frequencies" in feature_metadata["internal"]:
+                    word_freqs = feature_metadata["internal"]["word_frequencies"]
+                    stats = "\n".join(["  - word count: %d" % (len(word_freqs.keys()))])
+                    text = text + "\n"
+                    text += stats
+                    try:
+                        from wordcloud import WordCloud, STOPWORDS
+
+                        wordcloud = WordCloud(
+                            width=1000,
+                            height=int(1000 * (figsize[1] / figsize[0])),
+                            background_color="white",
+                            stopwords=set(STOPWORDS),
+                            max_words=50,
+                            max_font_size=75,
+                        ).fit_words(word_freqs)
+
+                        plt.imshow(wordcloud, interpolation="bilinear")
+                        plt.axis("off")
+                    except ModuleNotFoundError as e:
+                        utils._log_missing_module("wordcloud", OptionalDependency.TEXT)
+                        logger.info(
+                            "The text word cloud is not plotted due to missing dependency wordcloud."
+                        )
+
+            else:
+                ax.text(
+                    -1.1,
+                    1,
+                    text,
+                    transform=ax.transAxes,
+                    verticalalignment="top",
+                    bbox=props,
+                    weight="bold",
+                )
+                if feature_metadata["missing_percentage"] == 100:
+                    addrtext = "NOTE: plot has been disabled as all values in this column are missing."
+                else:
+                    addrtext = "NOTE: plot has been disabled,\nfor features of unknown type\nno visualization is available"
+                ax.text(
+                    0.05,
+                    0.95,
+                    addrtext,
+                    transform=ax.transAxes,
+                    fontsize=14,
+                    verticalalignment="top",
+                    bbox=props,
+                    weight="bold",
+                )
+                ax.axis("off")
+
+            self.feature_dist_html_dict[col] = convert_to_html(plt)
+            plt.close()
+
+            html_widget.value += self.feature_dist_html_dict[col]
+
+    @staticmethod
+    def _init_fig_ax(figsize, dpi=288):
+        fig, ax = plt.subplots(figsize=figsize, dpi=dpi)
+        fig.set(facecolor="white")
+        return fig, ax
+
+    @staticmethod
+    def _format_stats(feature_type_name, stats):
+        text = "\n  - %s statistics:" % (feature_type_name)
+        for k in list(stats.keys()):
+            if "percentage" in k:
+                text += "\n    - {}: {:.3f}%".format(k, stats[k])
+            elif isinstance(stats[k], (int, np.int64)) or (
+                isinstance(stats[k], float)
+                and not np.isnan(stats[k])
+                and stats[k] == int(stats[k])
+            ):
+                text += "\n    - {}: {:,}".format(k, int(stats[k]))
+            elif isinstance(stats[k], bool):
+                text += "\n    - {}: {s}".format(k, "yes" if stats[k] else "no")
+            elif isinstance(stats[k], (float, np.float64)):
+                text += "\n    - {}: {:.3f}".format(k, stats[k])
+            else:
+                text += "\n    - {}: {}".format(k, stats[k])
+
+        return text