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

ads/dataset/plot.py

@@ -0,0 +1,710 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2020, 2022 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+from __future__ import print_function, absolute_import
+
+import random
+from collections import defaultdict
+from math import pi
+import pandas as pd
+import numpy as np
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import colors as mcolors
+from ads.dataset.helper import _log_yscale_not_set
+
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+from ads.common.utils import _log_plot_high_cardinality_warning, MAX_DISPLAY_VALUES
+from ads.type_discovery.latlon_detector import LatLonDetector
+from ads.type_discovery.typed_feature import (
+    ContinuousTypedFeature,
+    DateTimeTypedFeature,
+    ConstantTypedFeature,
+    DiscreteTypedFeature,
+    CreditCardTypedFeature,
+    ZipcodeTypedFeature,
+    OrdinalTypedFeature,
+    CategoricalTypedFeature,
+    GISTypedFeature,
+)
+
+from ads.dataset import logger
+
+
+class Plotting:
+    def __init__(self, df, feature_types, x, y=None, plot_type="infer", yscale=None):
+        self.df = df
+        self.feature_types = feature_types
+        self.x = x
+        self.y = y
+        self.x_type = self.feature_types[self.x]
+        self.y_type = self.feature_types[self.y] if self.y is not None else None
+        self.plot_type = plot_type
+        self.yscale = yscale
+
+    def __repr__(self):
+        choices = self._get_plot_method()  # add (plot_type='{0}') in plot method"
+        if len(choices) > 1:
+            logger.info(f"Recommended plot type is {choices[0][1].__name__}.")
+
+            logger.info(
+                "Available plot types are ",
+                ", ".join([x[1].__name__ for x in choices]),
+                ".",
+            )
+        self.show_in_notebook()
+        return ""
+
+    def select_best_plot(self):
+        """
+        Returns the best plot for a given dataset
+        """
+
+        #
+        # auto logic
+        #
+
+        choices = self._get_plot_method()
+
+        if len(choices) > 1:
+            logger.info(
+                "select_best_plot (%s, %s) called, possible plot types are %s"
+                % (
+                    self.x_type.meta_data["type"],
+                    self.y_type.meta_data["type"] if self.y_type is not None else "",
+                    ", ".join([x[0].__name__ for x in choices]),
+                )
+            )
+
+        if self.plot_type != "infer":
+            for choice in choices:
+                if choice[1].__name__.lower().startswith(self.plot_type.lower()):
+                    return choice
+            logger.info("invalid plot_type: {}".format(self.plot_type))
+            raise ValueError(
+                "plot_type: '%s' invalid, use one of: %s"
+                % (self.plot_type, ", ".join([x[0].__name__ for x in choices]))
+            )
+
+        return choices[0]
+
+    def show_in_notebook(self, **kwargs):
+
+        """
+        Visualizes the dataset by plotting the distribution of a feature or relationship between two features.
+
+        Parameters
+        ----------
+        figsize: tuple
+                defines the size of the fig
+        -------
+        """
+        plotlib_type, plot_method, plot_kwargs = self.select_best_plot()
+        plotlib_type(plot_method, **plot_kwargs, **kwargs)
+
+    @staticmethod
+    def _add_identity(ax, *line_args, **line_kwargs):
+        ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="-.3", transform=ax.transAxes)
+
+    @staticmethod
+    def _build_plot_key(x_type, y_type=None):
+        if y_type is None:
+            return x_type.__name__
+        return x_type.__name__ + "," + y_type.__name__
+
+    @staticmethod
+    @runtime_dependency(module="scipy", install_from=OptionalDependency.VIZ)
+    def _gaussian_heatmap(x, y, data, s=10, edgecolor="white", cmap=plt.cm.jet):
+        """
+        Generate a scatter plot and assign a color to each data point based on the local density (gaussian kernel) of
+        points.
+
+        Parameters
+        ----------
+        x: str
+            name of the feature
+        y: str
+            name of the feature
+        data: object
+            The dataframe that contains x and y
+        s: int
+            area of each marker
+        edgecolor: str
+            edge color of each point. string value, e.g. 'blue'
+        cmap: object
+            color map for the heatmap
+
+        Returns
+        -------
+        ax.scatter() object: a scatter plot with colored density
+
+        Raises
+        ------
+        ValueError
+            When the columns are identical or the columns are highly correlated.
+        """
+        try:
+            _x = np.array(data[x])
+            _y = np.array(data[y])
+            xy = np.vstack([_x, _y])
+            z = scipy.stats.gaussian_kde(xy)(xy)
+            sc = plt.scatter(_x, _y, c=z, s=s, edgecolor=edgecolor, cmap=cmap)
+            plt.xlabel(x)
+            plt.ylabel(y)
+            return plt.colorbar(sc)
+        except:
+            return plt.scatter(_x, _y)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _categorical_vs_continuous_violin_plot(x, y, data):
+        # when x is categorical, we set the order based on counts of each category
+        vc = data[x].value_counts()
+        if len(vc.keys()) > 10:
+            _log_plot_high_cardinality_warning(x, len(vc.keys()))
+            idxes = vc[:10].index
+        else:
+            idxes = vc.index
+        seaborn.violinplot(x=x, y=y, data=data[data[x].isin(idxes)], order=idxes)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_vs_continuous_violin_plot(x, y, data):
+        # when x is ordinal, we want to get a natural order to x values
+        vals = np.array(data[x].values)
+        sorted_x = list(np.sort(vals))
+        # get the frequency of each distinct element in the list using a dictionary.
+        freq = {}
+        for items in sorted_x:
+            freq[items] = sorted_x.count(items)
+        if len(freq) > MAX_DISPLAY_VALUES:
+            _log_plot_high_cardinality_warning(x, len(freq))
+            idxes = list(freq.keys())[:10]
+        else:
+            idxes = freq.keys()
+        seaborn.violinplot(x=x, y=y, data=data[data[x].isin(idxes)], order=idxes)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _categorical_vs_continuous_horizontal_violin_plot(x, y, data):
+        vc = data[x].value_counts()
+        if len(vc.keys()) > 10:
+            _log_plot_high_cardinality_warning(x, len(vc.keys()))
+            idxes = vc[:10].index
+        else:
+            idxes = vc.index
+        seaborn.violinplot(
+            x=y, y=x, data=data[data[x].isin(idxes)], order=idxes, orient="h"
+        )
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_vs_continuous_horizontal_violin_plot(x, y, data):
+        # when x is ordinal, we want to get a natural order to x values
+        vals = np.array(data[x].values)
+        sorted_x = list(np.sort(vals))
+        # get the frequency of each distinct element in the list using a dictionary.
+        freq = {}
+        for items in sorted_x:
+            freq[items] = sorted_x.count(items)
+        if len(freq) > MAX_DISPLAY_VALUES:
+            _log_plot_high_cardinality_warning(x, len(freq))
+            idxes = list(freq.keys())[:10]
+        else:
+            idxes = freq.keys()
+        seaborn.violinplot(
+            x=y, y=x, data=data[data[x].isin(idxes)], order=idxes, orient="h"
+        )
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _categorical_vs_continuous_box_plot(x, y, data):
+        vc = data[x].value_counts()
+        if len(vc.keys()) > 10:
+            _log_plot_high_cardinality_warning(x, len(vc.keys()))
+            idxes = vc[:10].index
+        else:
+            idxes = vc.index
+        seaborn.boxplot(x=x, y=y, data=data[data[x].isin(idxes)], order=idxes)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_vs_continuous_box_plot(x, y, data):
+        # when x is ordinal, we want to get a natural order to x values
+        vals = np.array(data[x].values)
+        sorted_x = list(np.sort(vals))
+        # get the frequency of each distinct element in the list using a dictionary.
+        freq = {}
+        for items in sorted_x:
+            freq[items] = sorted_x.count(items)
+        if len(freq) > MAX_DISPLAY_VALUES:
+            _log_plot_high_cardinality_warning(x, len(freq))
+            idxes = list(freq.keys())[:10]
+        else:
+            idxes = freq.keys()
+        seaborn.boxplot(x=x, y=y, data=data[data[x].isin(idxes)], order=idxes)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_vs_continuous_horizontal_box_plot(x, y, data):
+        # when x is ordinal, we want to get a natural order to x values
+        vals = np.array(data[x].values)
+        sorted_x = list(np.sort(vals))
+        # get the frequency of each distinct element in the list using a dictionary.
+        freq = {}
+        for items in sorted_x:
+            freq[items] = sorted_x.count(items)
+        if len(freq) > MAX_DISPLAY_VALUES:
+            _log_plot_high_cardinality_warning(x, len(freq))
+            idxes = list(freq.keys())[:10]
+        else:
+            idxes = freq.keys()
+        seaborn.boxplot(
+            x=y, y=x, data=data[data[x].isin(idxes)], order=idxes, orient="h"
+        )
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _count_plot(x, hue, data, yscale=None):
+        if not yscale:
+            _log_yscale_not_set()
+        # get the copy of data and convert categorical data type to object
+        data = data.copy()
+        data[hue] = data[hue].astype("object")
+        # get cardinality of categorical values
+        cat_cardi = data[hue].value_counts()
+        if len(cat_cardi) > 5:
+            top_categoricals = cat_cardi[:5].index
+            # modify the data to replace non top 5 categorical values to be the same value
+            data[hue] = np.where(
+                data[hue].isin(top_categoricals), data[hue], "all_other_categories"
+            )
+            cat_index = data[hue].value_counts().index
+        else:
+            cat_index = cat_cardi.index
+        # get cardinality of ordinal values
+        ordi_cardi = data[x].value_counts()
+        if len(ordi_cardi) > 10:
+            # bin the values and sort from small to large
+            data[x] = pd.cut(data[x], 10, precision=0)
+            data[x] = data[x].apply(lambda k: pd.Interval(int(k.left), int(k.right)))
+        g = seaborn.countplot(x=x, hue=hue, data=data, hue_order=cat_index)
+        if yscale:
+            g.set_yscale(yscale)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_count_plot(x, data, yscale=None):
+        if not yscale:
+            _log_yscale_not_set()
+        data = data.copy()
+        ordi_cardi = data[x].value_counts()
+        if len(ordi_cardi) > 20:
+            intervals = pd.cut(data[x], 20, precision=0)
+            intervals = intervals.apply(
+                lambda k: pd.Interval(int(k.left), int(k.right))
+            )
+        else:
+            intervals = data[x]
+        g = seaborn.countplot(x=intervals, color="#1f77b4")
+        if yscale:
+            g.set_yscale(yscale)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _ordinal_vs_constant_count_plot(x, hue, data, yscale=None):
+        if not yscale:
+            _log_yscale_not_set()
+        data = data.copy()
+        intervals = pd.cut(data[x], 20, precision=0)
+        intervals = intervals.apply(lambda k: pd.Interval(int(k.left), int(k.right)))
+        g = seaborn.countplot(x=intervals, hue=hue, data=data)
+        if yscale:
+            g.set_yscale(yscale)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _single_column_count_plot(x, data, yscale=None):
+        if not yscale:
+            _log_yscale_not_set()
+        order = data[x].value_counts().iloc[:24].index
+        g = seaborn.countplot(x=x, data=data, order=order)
+        if yscale:
+            g.set_yscale(yscale)
+
+    @staticmethod
+    @runtime_dependency(module="IPython", install_from=OptionalDependency.NOTEBOOK)
+    @runtime_dependency(module="folium", install_from=OptionalDependency.VIZ)
+    def _folium_map(x, data):
+        import folium.plugins
+        df = LatLonDetector.extract_x_y(data[x])
+        lat_min, lat_max, long_min, long_max = (
+            min(df.Y),
+            max(df.Y),
+            min(df.X),
+            max(df.X),
+        )
+        m = folium.Map(tiles="Stamen Terrain", zoom_control=False)
+
+        folium.plugins.HeatMap(df[["Y", "X"]]).add_to(m)
+        m.fit_bounds([[lat_min, long_min], [lat_max, long_max]])
+
+        from IPython.core.display import display
+
+        display(m)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _single_pdf(x, y, data):
+        seaborn.kdeplot(data[x], shade=True, shade_lowest=False)
+
+    @staticmethod
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _multiple_pdf(x, y, data):
+        colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)
+        hues = [
+            colors[x]
+            for x in colors.keys()
+            if isinstance(colors[x], str) and colors[x].startswith("#")
+        ]
+
+        for i, cat in enumerate(list(data[y].unique())):
+            s = data.loc[data[y] == cat][x]
+            color = random.choice(hues)
+            seaborn.kdeplot(s, color=color, shade=True, shade_lowest=False, label=cat)
+        plt.xlabel(x)
+        plt.ylabel(y)
+
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _matplot(self, plot_method, figsize=(4, 3), **kwargs):
+
+        plt.style.use("seaborn-white")
+
+        plt.rc("xtick", labelsize="x-small")
+        plt.rc("ytick", labelsize="x-small")
+        plt.rc("font", size=8)
+        plt.rc("figure", dpi=144)
+
+        fig = plt.figure(figsize=figsize)
+
+        #
+        # generate a title for the plot
+        #
+        text = '{}, "{}" ({})'.format(
+            plot_method.__name__.upper(), self.x, self.feature_types[self.x].type
+        )
+        if self.y:
+            text = '{} vs "{}" ({})'.format(
+                text, self.y, self.feature_types[self.y].type
+            )
+
+        plt.title(text, y=1.08)
+        plt.grid(linestyle="dotted")
+
+        # draw a 45 degree dotted or dashed line indicating equality when plot method is scatter plots and the span of x equals the span of y
+        if (
+            plot_method is plt.scatter or plot_method is Plotting._gaussian_heatmap
+        ) and (self.df[kwargs["x"]].values.ptp() == self.df[kwargs["y"]].values.ptp()):
+            Plotting._add_identity(fig.axes[0], color="grey", ls="--")
+
+        plot_method(**kwargs, data=self.df)
+
+        # set x and y axis label
+        if self.y:
+            plt.ylabel(self.y)
+        if self.x:
+            plt.xlabel(self.x)
+
+        # rename the y-axis label and x-axis label when "count" is the y-axis label
+        if self.y == "count":
+            plt.xlabel("Column: {} values ".format(self.x))
+            plt.ylabel("instance count")
+
+        # add y-axis label as "count" when plot type is hist
+        if plot_method is plt.hist:
+            plt.ylabel("instance count")
+            # add tickmark on x-axis to see labeled values on x-axis in historgram. It has 30 intervals because that's the most tickmarks on graph can fit.
+            plt.xticks(
+                np.arange(
+                    min(self.df[kwargs["x"]].values),
+                    max(self.df[kwargs["x"]].values) + 1,
+                    (
+                        max(self.df[kwargs["x"]].values)
+                        - min(self.df[kwargs["x"]].values)
+                    )
+                    / 30,
+                )
+            )
+        # override y-axis label as "count" when plot type is _count_plot or countplot
+        if plot_method is Plotting._count_plot or plot_method is seaborn.countplot:
+            plt.ylabel("count")
+
+        plt.xticks(rotation=90)
+
+    def _generic_plot(self, plot_method, **kwargs):
+        plot_method(**kwargs, data=self.df)
+
+    @runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+    def _get_plot_method(self):
+
+        #
+        # combos contains a dictionary with the key being a composite of the x and y types, the value will
+        # always be a list, possibly and empty list, indicating no match for combination
+        #
+        #
+
+        combos = defaultdict(list)
+
+        combos[
+            Plotting._build_plot_key(CategoricalTypedFeature, ContinuousTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._categorical_vs_continuous_violin_plot,
+                {"x": self.x, "y": self.y},
+            ),
+            (
+                self._matplot,
+                Plotting._categorical_vs_continuous_box_plot,
+                {"x": self.x, "y": self.y},
+            ),
+        ]
+        combos[
+            Plotting._build_plot_key(OrdinalTypedFeature, ContinuousTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._ordinal_vs_continuous_violin_plot,
+                {"x": self.x, "y": self.y},
+            ),
+            (
+                self._matplot,
+                Plotting._ordinal_vs_continuous_box_plot,
+                {"x": self.x, "y": self.y},
+            ),
+        ]
+        combos[
+            Plotting._build_plot_key(ContinuousTypedFeature, OrdinalTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._ordinal_vs_continuous_horizontal_violin_plot,
+                {"x": self.y, "y": self.x},
+            ),
+            (
+                self._matplot,
+                Plotting._ordinal_vs_continuous_horizontal_box_plot,
+                {"x": self.y, "y": self.x},
+            ),
+        ]
+        combos[
+            Plotting._build_plot_key(ContinuousTypedFeature, CategoricalTypedFeature)
+        ] = [(self._matplot, Plotting._multiple_pdf, {"x": self.x, "y": self.y})]
+        combos[
+            Plotting._build_plot_key(ConstantTypedFeature, ContinuousTypedFeature)
+        ] = [(self._matplot, seaborn.barplot, {"x": self.x, "y": self.y})]
+        combos[
+            Plotting._build_plot_key(ContinuousTypedFeature, ConstantTypedFeature)
+        ] = [(self._matplot, Plotting._single_pdf, {"x": self.x, "y": self.y})]
+        combos[Plotting._build_plot_key(ConstantTypedFeature, DiscreteTypedFeature)] = [
+            (self._matplot, seaborn.barplot, {"x": self.x, "y": self.y})
+        ]
+        combos[Plotting._build_plot_key(DiscreteTypedFeature, ConstantTypedFeature)] = [
+            (
+                self._matplot,
+                Plotting._ordinal_vs_constant_count_plot,
+                {"x": self.x, "hue": self.y, "yscale": self.yscale},
+            )
+        ]
+        combos[
+            Plotting._build_plot_key(DateTimeTypedFeature, ContinuousTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                plt.scatter,
+                {
+                    "x": self.x,
+                    "y": self.y,
+                    "s": pi / 10 * (matplotlib.rcParams["lines.markersize"] ** 2),
+                    "edgecolor": "white",
+                    "linewidths": "0.1",
+                },
+            )
+        ]
+        combos[Plotting._build_plot_key(DateTimeTypedFeature, OrdinalTypedFeature)] = [
+            (
+                self._matplot,
+                plt.scatter,
+                {"x": self.x, "y": self.y, "edgecolor": "white", "linewidths": "0.1"},
+            )
+        ]
+        combos[
+            Plotting._build_plot_key(ContinuousTypedFeature, ContinuousTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._gaussian_heatmap,
+                {
+                    "x": self.x,
+                    "y": self.y,
+                    "s": pi / 10 * (matplotlib.rcParams["lines.markersize"] ** 2),
+                },
+            ),
+            (
+                self._matplot,
+                plt.scatter,
+                {"x": self.x, "y": self.y, "edgecolor": "white", "linewidths": "0.1"},
+            ),
+        ]
+        combos[Plotting._build_plot_key(OrdinalTypedFeature, OrdinalTypedFeature)] = [
+            (
+                self._matplot,
+                seaborn.scatterplot,
+                {
+                    "x": self.x,
+                    "y": self.y,
+                    "s": pi / 10 * (matplotlib.rcParams["lines.markersize"] ** 2),
+                    "edgecolor": "white",
+                    "linewidths": "0.1",
+                },
+            )
+        ]
+        combos[Plotting._build_plot_key(OrdinalTypedFeature, DiscreteTypedFeature)] = [
+            (self._matplot, seaborn.countplot, {"x": self.x, "hue": self.y})
+        ]
+        combos[
+            Plotting._build_plot_key(OrdinalTypedFeature, CategoricalTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._count_plot,
+                {"x": self.x, "hue": self.y, "yscale": self.yscale},
+            )
+        ]
+        combos[
+            Plotting._build_plot_key(CategoricalTypedFeature, OrdinalTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                Plotting._count_plot,
+                {"x": self.y, "hue": self.x, "yscale": self.yscale},
+            )
+        ]
+        combos[Plotting._build_plot_key(DiscreteTypedFeature, OrdinalTypedFeature)] = [
+            (
+                self._matplot,
+                seaborn.countplot,
+                {
+                    "x": self.x,
+                    "hue": self.y,
+                    "order": self.df[self.x]
+                    .value_counts(ascending=True)
+                    .iloc[:10]
+                    .index,
+                },
+            )
+        ]
+        combos[
+            Plotting._build_plot_key(DiscreteTypedFeature, CategoricalTypedFeature)
+        ] = [
+            (
+                self._matplot,
+                seaborn.countplot,
+                {
+                    "x": self.x,
+                    "hue": self.y,
+                    "order": self.df[self.x].value_counts().iloc[:10].index,
+                },
+            )
+        ]
+        combos[Plotting._build_plot_key(DateTimeTypedFeature, DateTimeTypedFeature)] = [
+            (
+                self._matplot,
+                plt.scatter,
+                {
+                    "x": self.x,
+                    "y": self.y,
+                    "s": pi / 10 * (matplotlib.rcParams["lines.markersize"] ** 2),
+                    "edgecolor": "white",
+                    "linewidths": "0.1",
+                },
+            )
+        ]
+
+        combos[Plotting._build_plot_key(ContinuousTypedFeature, None)] = [
+            (self._matplot, plt.hist, {"x": self.x})
+        ]
+        combos[Plotting._build_plot_key(CategoricalTypedFeature, None)] = [
+            (
+                self._matplot,
+                Plotting._single_column_count_plot,
+                {"x": self.x, "yscale": self.yscale},
+            )
+        ]
+        combos[Plotting._build_plot_key(OrdinalTypedFeature, None)] = [
+            (
+                self._matplot,
+                Plotting._ordinal_count_plot,
+                {"x": self.x, "yscale": self.yscale},
+            )
+        ]
+        combos[Plotting._build_plot_key(ConstantTypedFeature, None)] = [
+            (self._matplot, seaborn.countplot, {"x": self.x})
+        ]
+        combos[Plotting._build_plot_key(DateTimeTypedFeature, None)] = [
+            (self._matplot, plt.hist, {"x": self.x, "bins": 10, "color": "#1f77b4"})
+        ]
+        combos[Plotting._build_plot_key(GISTypedFeature, None)] = [
+            (self._generic_plot, Plotting._folium_map, {"x": self.x})
+        ]
+
+        y_type_name = None if self.y_type is None else self.y_type.__class__
+        keys_to_check = list(
+            [Plotting._build_plot_key(self.x_type.__class__, y_type_name)]
+        )
+
+        new_x_type = Plotting._change_type(self.x_type)
+        new_y_type = Plotting._change_type(self.y_type)
+        keys_to_check.append(Plotting._build_plot_key(new_x_type, y_type_name))
+        keys_to_check.append(
+            Plotting._build_plot_key(self.x_type.__class__, new_y_type)
+        )
+        keys_to_check.append(Plotting._build_plot_key(new_x_type, new_y_type))
+        for key in keys_to_check:
+            if key in combos and combos[key]:
+                assert isinstance(combos[key][0], tuple)
+                return combos[key]
+
+        if y_type_name is not None:
+            raise NotImplementedError(
+                "Plotting for the feature combination ({0} vs {1}) is not yet supported.".format(
+                    self.x_type.meta_data["type"], self.y_type.meta_data["type"]
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Plotting for feature type {0} is not supported".format(
+                    self.x_type.meta_data["type"]
+                )
+            )
+
+    def _change_type(feature_type):
+        if feature_type is None:
+            return None
+
+        return (
+            DiscreteTypedFeature
+            if isinstance(feature_type, DiscreteTypedFeature)
+            or isinstance(feature_type, CreditCardTypedFeature)
+            or isinstance(feature_type, ZipcodeTypedFeature)
+            or isinstance(feature_type, OrdinalTypedFeature)
+            else feature_type.__class__
+        )