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

ads/explanations/mlx_global_explainer.py

@@ -0,0 +1,1050 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2020, 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import numpy as np
+from abc import ABC, abstractmethod
+
+from ads.common import logger, utils
+from ads.explanations.base_explainer import GlobalExplainer
+from ads.explanations.mlx_interface import check_tabular_or_text
+from ads.explanations.mlx_interface import init_lime_explainer
+from ads.explanations.mlx_interface import init_permutation_importance_explainer
+from ads.explanations.mlx_interface import (
+    init_partial_dependence_explainer,
+    init_ale_explainer,
+)
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+from ads.common.decorator.deprecate import deprecated
+
+
+class MLXGlobalExplainer(GlobalExplainer):
+    """
+    Global Explainer class.
+
+    Generates global explanations to help understand the general model
+    behavior. Supported explanations:
+
+        - (Tabular) Feature Permutation Importance.
+        - (Tabular) Partial Dependence Plots (PDP) & Individual Conditional
+          Expectation (ICE).
+        - (Text) Aggregate local explanations (global explanation approximation
+          constructed from multiple local explanations).
+
+    Supports:
+
+        - Binary classification.
+        - Multi-class classification.
+        - Regression.
+
+    """
+
+    @deprecated(
+        details="Working with AutoML has moved from within ADS to working directly with the AutoMLx library. AutoMLx are preinstalled in conda pack automlx_p38_cpu_v2 and later, and can now be updated independently of ADS. AutoMLx documentation may be found at https://docs.oracle.com/en-us/iaas/tools/automlx/latest/html/multiversion/v23.1.1/index.html. Notebook examples are in Oracle's samples repository: https://github.com/oracle-samples/oci-data-science-ai-samples/tree/master/notebook_examples and a migration tutorial can be found at https://accelerated-data-science.readthedocs.io/en/latest/user_guide/model_training/automl/quick_start.html .",
+        raise_error=True,
+    )
+    def __init__(self):
+        super(GlobalExplainer, self).__init__()
+        self.explainer = None
+        self.selected_features = None
+        self.pdp_explainer = None
+        self.ale_explainer = None
+
+    def compute_feature_importance(
+        self,
+        n_iter=20,
+        sampling=None,
+        balance=False,
+        scoring_metric=None,
+        selected_features=None,
+    ):
+        """
+        Generates a global explanation to help understand the general behavior
+        of the model. This explainer identifies which features are most important
+        to the model.
+
+        If the dataset is tabular, computes a global feature permutation importance
+        explanation. If the dataset is text, approximates a global explanation by
+        generating and aggregating multiple local explanations.
+
+        Parameters
+        ----------
+        n_iter : int, optional
+            Number of iterations of the permutation importance algorithm to
+            perform. Increasing this value increases the quality/stability of
+            the explanation, but increases the explanation time. Default value is 20.
+        sampling : dict, optional
+            If not `None`, the dataset is clustered or sampled according to the
+            provided technique. `sampling` is a dictionary containing the technique
+            to use and the corresponding parameters. Format is described below:
+
+            - `technique`: Either `cluster` or `random`.
+            - If `cluster`, also requires:
+
+                - `eps`: Maximum distance between two samples to be considered
+                  in the same cluster.
+                - `min_samples`: Minimum number of samples to include in each
+                  cluster.
+
+            - If `random`, also requires:
+
+                - `n_samples`: Number of samples to return.
+
+            By default None. Note that text datasets are always sampled. If not provided
+            with a sampling option, defaults to 40 random samples.
+        balance : bool, optional
+            If True, the dataset will be balanced via sampling. If 'sampling' is not
+            set, the sampling technique defaults to 'random'.
+        scoring_metric : string, optional
+            If specified, propegates a string indicating the supported scoring metric.
+            The scoring metrics available out of the box are the ones made available
+            by ScyPy. Supported Metrics:
+
+            - Multi-class Classification
+
+                `f1_weighted`, `f1_micro`, `f1_macro`, `recall_weighted`, `recall_micro`, `recall_macro`,
+                `accuracy`, `balanced_accuracy`, `roc_auc`, `precision_weighted`, `precision_macro`,
+                `precision_micro`
+
+            - Binary Classification
+
+                Same as multi-class classification
+
+            - Regression
+
+                `r2`, `neg_mean_squared_error`, `neg_root_mean_squared_error`, `neg_mean_absolute_error`,
+                `neg_median_absolute_error`, `neg_mean_absolute_percentage_error`,
+                `neg_symmetric_mean_absolute_percentage_error`
+        selected_features: list[str], list[int], optional
+            List of the selected features. It can be any subset of
+            the original features that are in the dataset provided to the model.
+            Default value is None.
+
+        Returns
+        -------
+        :class:FeatureImportance
+            `FeaturePermutationImportance` explanation object.
+
+        """
+        self.selected_features = selected_features
+        self.configure_feature_importance(selected_features=self.selected_features)
+        if self.explainer.config.type == "text":
+            labels = list(range(len(self.class_names)))
+            # The requirement to downsample the text datasets should be fixed at somepoint
+            if sampling is None:
+                sampling = {"technique": "random", "n_samples": 40}
+            explanation = self.explainer.explain_aggregate_local(
+                self.X_test, sampling=sampling, labels=labels
+            )
+        else:
+            if self.mode_ == "regression":
+                allowed_metrics = [
+                    "r2",
+                    "neg_mean_squared_error",
+                    "neg_root_mean_squared_error",
+                    "neg_mean_absolute_error",
+                    "neg_median_absolute_error",
+                    "neg_mean_absolute_percentage_error",
+                    "neg_symmetric_mean_absolute_percentage_error",
+                ]
+            elif self.mode_ == "classification" and len(self.class_names) == 2:
+                # Binary classification
+                allowed_metrics = [
+                    "f1_weighted",
+                    "f1_micro",
+                    "f1_macro",
+                    "recall_weighted",
+                    "recall_micro",
+                    "recall_macro",
+                    "accuracy",
+                    "balanced_accuracy",
+                    "roc_auc",
+                    "precision_weighted",
+                    "precision_macro",
+                    "precision_micro",
+                ]
+            else:
+                # Multiclass classification
+                allowed_metrics = [
+                    "f1_weighted",
+                    "f1_micro",
+                    "f1_macro",
+                    "recall_weighted",
+                    "recall_micro",
+                    "recall_macro",
+                    "accuracy",
+                    "balanced_accuracy",
+                    "roc_auc",
+                    "precision_weighted",
+                    "precision_macro",
+                    "precision_micro",
+                ]
+            if scoring_metric not in allowed_metrics and scoring_metric is not None:
+                raise Exception(
+                    "Scoring Metric not supported for this type of problem: {}, for problem type {}, the availble supported metrics are {}".format(
+                        scoring_metric, self.mode_, allowed_metrics
+                    )
+                )
+            if balance and sampling is None:
+                sampling = {"technique": "random"}
+            try:
+                explanation = self.explainer.compute(
+                    self.X_test,
+                    self.y_test,
+                    n_iter=n_iter,
+                    sampling=sampling,
+                    balance=balance,
+                    scoring_metric=scoring_metric,
+                )
+            except IndexError as e:
+                if selected_features is not None:
+                    raise IndexError(
+                        f"Unable to calculate permutation importance due to: {e}. "
+                        f"selected_features must be a list of features within the bounds of the existing features "
+                        f"(that were provided to model). Provided selected_features: {selected_features}."
+                    )
+            except Exception as e:
+                logger.error(
+                    f"Unable to calculate permutation importance scores due to: {e}."
+                )
+                raise e
+        return FeatureImportance(explanation, self.class_names, self.explainer.config)
+
+    def compute_partial_dependence(
+        self, features, partial_range=(0.00, 1.0), num_samples=30, sampling=None
+    ):
+        """
+        Generates a global partial dependence plot (PDP) and individual conditional
+        expectation (ICE) plots to help understand the relationship between feature
+        values and the model target.
+
+        Only supported for tabular datasets.
+
+        Parameters
+        ----------
+
+        features : list of int, list of str
+            List of feature names or feature indices to explain.
+        partial_range : tuple, optional
+            2-tuple with the minimum and maximum percentile values to consider for the PDP from
+            the feature's train distribution. Must be between 0.0 and 1.0.
+            Defaults to `partial_range = (0.05, 0.95)`.
+        num_samples : int, optional
+            Maximum number of samples to generate for each feature within the
+            `partial_range` of its value distribution. Increasing this value
+            generates more points to evaluate, but increases the explanation
+            time. If there are fewer unique values for a feature within the
+            `partial_range`, the number of unique values is selected. For two-feature
+            PDP, the total number of evaluated samples is the multiplication
+            of `num_samples`. Default value is 30.
+        sampling : dict, optional
+            If not None, the dataset will be clustered or sampled according to the
+            provided technique. 'sampling' is a dictionary containing the technique
+            to use and the corresponding parameters. Format is described below:
+
+            - `technique`: Either "cluster" or "random".
+            - `cluster` also requires:
+
+                - `eps`: Maximum distance between two samples to be considered
+                  in the same cluster.
+                - `min_samples`: Minimum number of samples to include in each
+                  cluster.
+
+            - `random` also requires:
+
+                - 'n_samples': Number of samples to return.
+
+            Default value is `None` (no sampling).
+
+        Returns
+        -------
+        :class:MLXPartialDependencies
+            `MLXPartialDependencies` object.
+
+        """
+        if self.pdp_explainer is None:
+            self._init_partial_dependence()
+
+        # Wrap in a list if a list is not provided
+        if not isinstance(features, list):
+            features = [features]
+
+        # Convert to uppercase to be case-insensitive
+        features = [str(f).upper() for f in features]
+        feature_names = np.char.upper(self.X_train.columns.tolist())
+
+        # Fail if we were not provided valid feature names
+        if not all(np.isin(features, feature_names)):
+            print("One or more features (%s) does not exist in data." % str(features))
+            print("Existing features: %s" % str(feature_names))
+            return
+
+        # Extract the feature ids
+        feature_ids = np.where(np.isin(feature_names, features))[0].tolist()
+
+        if check_tabular_or_text(self.est, self.X_train) == "tabular":
+            if len(feature_ids) > 2:
+                raise ValueError("Maximum number of partial dependency features is 2.")
+
+            return MLXPartialDependencies(
+                pdp=self.pdp_explainer.compute(
+                    data=self.X_train,
+                    partial_ids=feature_ids,
+                    partial_range=partial_range,
+                    num_samples=num_samples,
+                    sampling=sampling,
+                ),
+                pdp_exp=self.pdp_explainer,
+            )
+        else:
+            raise ValueError(
+                "Partial Dependence Plot is not supported for text classification dataset."
+            )
+
+    def compute_accumulated_local_effects(
+        self,
+        feature,
+        partial_range=(0.00, 1.0),
+        num_samples=30,
+        sampling=None,
+        corr_threshold=0.7,
+    ):
+        """
+        Generates the accumulated local effects plots to help understand the relationship between feature
+        values and the model target.
+
+        Only supported for tabular datasets.
+
+        Parameters
+        ----------
+        feature : str
+            Feature name to explain.
+        partial_range : tuple, optional
+            Min/max percentile values to consider for the ALE from the
+            feature's train distribution. Must be between 0.0 and 1.0.
+            By default `partial = (0.05, 0.95)`.
+        num_samples : int, optional
+            Maximum number of samples to generate for each feature within the
+            `partial_range` of its value distribution. Increasing this value
+            generates more points to evaluate, but increases the explanation
+            time. If there are fewer unique values for a feature within the
+            `partial_range`, the number of unique values is selected.
+        sampling : dict, optional
+            If not `None`, the dataset is clustered or sampled according to the
+            provided technique. `sampling` is a dictionary containing the technique
+            to use and the corresponding parameters. The format is:
+
+            - `technique`: Can be either "cluster" or "random".
+            - `cluster` also requires:
+
+                - `eps`: Maximum distance between two samples to be considered
+                  in the same cluster.
+                - `min_samples`: Minimum number of samples to include in each
+                  cluster.
+
+            - `random` also requires:
+
+                - `n_samples`: Number of samples to return.
+
+            Defaults to `None` (no sampling).
+
+        corr_threshold : float, optional
+             Value between 0.0 and 1.0 for which a feature is considered highly correlated with
+             another feature (Default = 0.7).
+
+        Returns
+        -------
+        :class:MLXAccumulatedLocalEffects
+            `AccumulatedLocalEffects` explanation object.
+
+        """
+        if self.ale_explainer is None:
+            self._init_accumulated_local_effects()
+
+        # Wrap in a list if a list is not provide, to be able support list of two features in the near future.
+        if not isinstance(feature, list):
+            feature = [feature]
+
+        # Convert to uppercase to be case-insensitive
+        feature = [str(f).upper() for f in feature]
+        feature_names = np.char.upper(self.X_train.columns.tolist())
+
+        # Fail if we were not provided valid feature names
+        if not all(np.isin(feature, feature_names)):
+            print("One or more features (%s) does not exist in data." % str(feature))
+            print("Existing features: %s" % str(feature_names))
+            return
+
+        # Extract the feature ids
+        feature_ids = np.where(np.isin(feature_names, feature))[0].tolist()
+
+        if check_tabular_or_text(self.est, self.X_train) == "tabular":
+            if len(feature_ids) > 1:
+                raise ValueError(
+                    "Maximum number of Accumulated Local Effects features is 1."
+                )
+
+            return MLXAccumulatedLocalEffects(
+                ale=self.ale_explainer.compute(
+                    data=self.X_train,
+                    partial_ids=feature_ids,
+                    partial_range=partial_range,
+                    num_samples=num_samples,
+                    sampling=sampling,
+                    corr_threshold=corr_threshold,
+                ),
+                ale_exp=self.ale_explainer,
+            )
+        else:
+            raise ValueError(
+                "Accumulated Local Effects Plot is not supported for text classification dataset."
+            )
+
+    @runtime_dependency(module="IPython", install_from=OptionalDependency.NOTEBOOK)
+    def show_in_notebook(self):  # pragma: no cover
+        """
+        Generates and visualizes the global feature importance explanation.
+        """
+        with utils.get_progress_bar(3, description="Model Explanation") as bar:
+            bar.update("begin computing")
+            bar.update("calculating feature importance")
+            explainer_holder = self.compute_feature_importance(
+                selected_features=self.selected_features
+            )
+            plot1 = explainer_holder.show_in_notebook()
+            bar.update("calculating partial dependence plot")
+            pdp_plot_feature_name = explainer_holder.explanation
+            # pdp_plot_feature_name = explainer_holder.explanation.get_global_explanation().index[0]
+            pdp_plot = self.compute_partial_dependence([pdp_plot_feature_name])
+            # plot2 = pdp_plot.show_in_notebook()
+
+        from IPython.core.display import display, HTML
+
+        display(HTML(plot1.data))
+        # display(HTML(plot1.data + plot2.data))
+
+    def configure_feature_importance(self, **kwargs):
+        """
+        Validates and initializes the feature importance explainer based on the provided
+        configuration parameters in kwargs. Tabular datasets use the feature permutation
+        importance explainer, text datasets use the aggregate local explainer.
+
+        Supported configuration options:
+
+        - For tabular datasets:
+
+            - `client`: Currently only allowed to be None to disable parallelization.
+            - `random_state`: None, int, or instance of Randomstate.
+            - `selected_features`: None, or list of the selected features.
+
+        - For text datasets:
+
+            - `surrogate_model`: Surrogate model to use. Can be 'linear' or 'decision_tree'.
+            - `num_samples`: Number of generated samples to fit the surrogate model. Int.
+            - `exp_sorting`: Feature importance sorting. Can be 'absolute' or 'ordered'.
+            - `scale_weight`: Normalizes the feature importance coefficients from LIME to sum to one.
+            - `client`: Currently only allowed to be None to disable parallelization.
+            - `batch_size`: Number of local explanations per Dask worker.
+            - `random_state`: None, int, or instance of Randomstate.
+            - `selected_features`: None, or list of the selected features.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+
+        Returns
+        -------
+        MLXGlobalExplainer
+            the modified instance (self)
+
+        """
+
+        if check_tabular_or_text(self.est, self.X_train) == "tabular":
+            avail_args = ["client", "random_state", "selected_features"]
+        else:
+            avail_args = [
+                "client",
+                "random_state",
+                "surrogate_model",
+                "num_samples",
+                "exp_sorting",
+                "scale_weight",
+                "batch_size",
+                "selected_features",
+            ]
+
+        for k, _ in kwargs.items():
+            if k not in avail_args:
+                raise ValueError(
+                    "Unexpected argument for the feature importance explainer: {}".format(
+                        k
+                    )
+                )
+
+        if kwargs.get("client", None) is not None:
+            raise ValueError(
+                "Invalid client provided. Currently only supports disabling parallelization "
+                "by setting client=None"
+            )
+        if kwargs.get("surrogate_model", None) not in ["linear", "decision_tree", None]:
+            raise ValueError(
+                "Invalid surrogate_model provided. Currently only supports linear or decision_tree"
+            )
+        selected_features = kwargs.get("selected_features")
+        if selected_features is not None and not isinstance(selected_features, list):
+            raise ValueError(
+                f"selected_features ({selected_features}) value must be a list of features, "
+                f"but it is of type: {type(selected_features)}."
+            )
+
+        self._init_feature_importance(**kwargs)
+        return self
+
+    def configure_partial_dependence(self, **kwargs):
+        """
+        Validates and initializes the partial dependence explainer based on the provided
+        configuration parameters in kwargs. Only supports tabular datasets.
+
+        Supported configuration options:
+            client: Currently only supports 'None' to disable parallelization.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+
+        Returns
+        -------
+        MLXGlobalExplainer
+            the modified instance (self)
+        """
+
+        for k, _ in kwargs.items():
+            if k not in ["client"]:
+                raise ValueError(
+                    "Unexpected argument for the partial dependence explainer: {}".format(
+                        k
+                    )
+                )
+        if kwargs.get("client", None) is not None:
+            raise ValueError(
+                "Invalid client provided. Currently only supports disabling parallelization "
+                "by setting client=None"
+            )
+        self._init_partial_dependence(**kwargs)
+        return self
+
+    def configure_accumulated_local_effects(self, **kwargs):
+        """
+        Validates and initializes the accumulated local effects explainer based on the provided
+        configuration parameters in kwargs. Only supports tabular datasets.
+
+        Supported configuration options:
+
+        - client: Currently only supports 'None' to disable parallelization.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+
+        Returns
+        -------
+        MLXGlobalExplainer
+            the modified instance (self)
+        """
+
+        for k, _ in kwargs.items():
+            if k not in ["client"]:
+                raise ValueError(
+                    "Unexpected argument for the accumulated local effects explainer: {}".format(
+                        k
+                    )
+                )
+        if kwargs.get("client", None) is not None:
+            raise ValueError(
+                "Invalid client provided. Currently only supports disabling parallelization "
+                "by setting client=None"
+            )
+        self._init_accumulated_local_effects(**kwargs)
+        return self
+
+    def feature_importance_summary(self):
+        """
+        Displays detailed information about the feature importance explainer.
+
+        Returns
+        -------
+        str
+            HTML object representing the explainer summary.
+
+        """
+
+        if self.explainer is None:
+            self.compute_feature_importance(selected_features=self.selected_features)
+        return self.explainer.show_in_notebook()
+
+    def partial_dependence_summary(self):
+        """
+        Displays detailed information about the partial dependence explainer.
+
+        Returns
+        -------
+        str
+            HTML object representing the explainer summary.
+        """
+
+        if self.pdp_explainer is None:
+            self._init_partial_dependence()
+        return self.pdp_explainer.show_in_notebook()
+
+    def accumulated_local_effects_summary(self):
+        """
+        Displays detailed information about the accumulated local effects explainer.
+
+        Returns
+        -------
+        str
+            HTML object representing the explainer summary.
+        """
+
+        if self.ale_explainer is None:
+            self._init_accumulated_local_effects()
+        return self.ale_explainer.show_in_notebook()
+
+    def _init_feature_importance(self, **kwargs):
+        """
+        Internal function to initialize the feature importance explainer. Tabular datasets
+        use the feature permutation importance explainer, text datasets use the aggregate local
+        explainer.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+        """
+        if self.mode == "regression":
+            self.class_names_ = ["Target"]
+        if check_tabular_or_text(self.est, self.X_train) == "tabular":
+            self.explainer = init_permutation_importance_explainer(
+                self.explainer,
+                self.est,
+                self.X_train,
+                self.y_train,
+                self.mode,
+                class_names=self.class_names,
+                **kwargs,
+            )
+        else:
+            self.explainer = init_lime_explainer(
+                self.explainer,
+                self.est,
+                self.X_train,
+                self.y_train,
+                self.mode,
+                class_names=self.class_names,
+                **kwargs,
+            )
+
+    def _init_partial_dependence(self, **kwargs):
+        """
+        Internal function to initialize the partial dependence explainer.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+        """
+        if self.mode == "regression":
+            self.class_names_ = ["Target"]
+        self.pdp_explainer = init_partial_dependence_explainer(
+            self.pdp_explainer,
+            self.est,
+            self.X_train,
+            self.y_train,
+            self.mode,
+            class_names=self.class_names,
+            **kwargs,
+        )
+
+    def _init_accumulated_local_effects(self, **kwargs):
+        """
+        Internal function to initialize the accumulated local effects explainer.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword parameter dictionary.
+        """
+        if self.mode == "regression":
+            self.class_names_ = ["Target"]
+        self.ale_explainer = init_ale_explainer(
+            self.ale_explainer,
+            self.est,
+            self.X_train,
+            self.y_train,
+            self.mode,
+            class_names=self.class_names,
+            **kwargs,
+        )
+
+
+class MLXFeatureDependenceExplanation(ABC):
+
+    __name__ = "MLXFeatureDependenceExplanation"
+
+    def __init__(self, fd, fd_exp):
+        self.fd = fd
+        self.fd_exp = fd_exp
+
+    @abstractmethod
+    def show_in_notebook(
+        self,
+        labels=None,
+        cscale="YIGnBu",
+        show_distribution=True,
+        discrete_threshold=0.15,
+        # line_gap=0,  # will add it back after ALE starts handling two features, remember to add the doc string too
+        show_correlation_warning=True,
+        centered=False,
+        show_median=True,
+    ):  # pragma: no cover
+        """
+        Visualize PDP/ICE plots in the Notebook.
+
+        Parameters
+        ----------
+        labels : tuple, list, int, bool, str, optional
+            labels to visualize.
+        cscale : str, optional
+            Plotly color scale to use for the heatmap. See the standard Plotly color scales for available options
+            Default value is "YIGnBu".
+        show_distribution : bool, optional
+            If `True`, the feature’s value distribution (from the train set) will be shown along the
+            corresponding axis in the 1-feature or 2-feature plot. Default is `True`.
+        discrete_threshold : float, optional
+            Value between 0.0 and 1.0 indicating the fraction of unique values required for a numerical feature
+            to be considered discrete or continuous. Default is 0.15.
+        show_correlation_warning : bool, optional
+            If `True`, the correlated feature warning is shown. Default is `True`.
+        centered : bool, optional
+            If `True`, ICE plots is centered based on the first value of each sample (i.e., all values are
+            subtracted from the first value). Default is False.
+        show_median : bool, optional
+            If True, a median line is included in the ICE explanation plot. Default is True.
+
+        Returns
+        -------
+        str
+            Plotly HTML object containing a line chart, heat map, or violin plot for this feature dependence explanation
+        """
+        pass
+
+    def as_dataframe(self):
+        """
+        Returns the raw explanation data as a pandas.DataFrame.
+
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame containing the raw PDP explanation data.
+        """
+        return self.fd.as_dataframe()
+
+    def get_diagnostics(self):
+        """
+        Extracts the raw explanation and evaluation data from the explanation object
+        (Used to generate the visualizations).
+
+        Returns
+        -------
+        dict
+            Dictionary containing the raw explanation/evaluation data.
+        """
+        return self.fd.get_diagnostic()
+
+
+class MLXPartialDependencies(MLXFeatureDependenceExplanation):
+    """
+    Represents the object constructed by the :class:`MLXGlobalExplainer`.
+
+    Contains functions to visualize the explanation and extract raw explanation data.
+    """
+
+    __name__ = "MLXPartialDependencies"
+
+    def __init__(self, pdp, pdp_exp):
+        super(MLXPartialDependencies, self).__init__(pdp, pdp_exp)
+
+    def show_in_notebook(
+        self,
+        mode="pdp",
+        labels=None,
+        cscale="YIGnBu",
+        show_distribution=True,
+        discrete_threshold=0.15,
+        line_gap=0,
+        show_correlation_warning=True,
+        centered=False,
+        show_median=True,
+    ):
+        """
+        Visualize PDP/ICE plots in the Notebook.
+
+        Parameters
+        ----------
+        mode : str, optional
+            Type to visualize. Either "pdp" or "ice". Default is "pdp".
+        labels : tuple, list, int, bool, str, optional
+            labels to visualize.
+        cscale : str, optional
+            Plotly color scale to use for the heatmap. See the standard Plotly color scales for available options
+            Default value is "YIGnBu".
+        show_distribution : bool, optional
+            If `True`, the feature’s value distribution (from the train set) will be shown along the
+            corresponding axis in the 1-feature or 2-feature plot. Default is `True`.
+        discrete_threshold : float, optional
+            Value between 0.0 and 1.0 indicating the fraction of unique values required for a numerical feature
+            to be considered discrete or continuous. Default is 0.15.
+        line_gap : int, optional
+            Width of the gap between values in the two-feature PDP heat map. Default is 0.
+        show_correlation_warning : bool, optional
+            If `True`, the correlated feature warning are shown. Default is `True`.
+        centered : bool, optional
+            If `True`, ICE plots are centered based on the first value of each sample (i.e., all values are
+            subtracted from the first value). Default is `False`.
+        show_median : bool, optional
+            If `True`, a median line is included in the ICE explanation plot. Default is `True`.
+
+        Returns
+        -------
+        str
+            Plotly HTML object containing a line chart, heat map, or violin plot for this feature dependence explanation
+        """
+        return self.fd.show_in_notebook(
+            mode=mode,
+            labels=labels,
+            cscale=cscale,
+            show_distribution=show_distribution,
+            discrete_threshold=discrete_threshold,
+            line_gap=line_gap,
+            show_correlation_warning=show_correlation_warning,
+            centered=centered,
+            show_median=show_median,
+        )
+
+
+class MLXAccumulatedLocalEffects(MLXFeatureDependenceExplanation):
+    """
+    Accumulated Local Effects explanation object constructed by the `:class:MLXGlobalExplainer`.
+
+    Contains functions to visualize the explanation in a Notebook and extract the
+    raw explanation data.
+    """
+
+    __name__ = "MLXAccumulatedLocalEffects"
+
+    def __init__(self, ale, ale_exp):
+        super(MLXAccumulatedLocalEffects, self).__init__(ale, ale_exp)
+
+    def show_in_notebook(
+        self,
+        labels=None,
+        cscale="YIGnBu",
+        show_distribution=True,
+        discrete_threshold=0.15,
+        show_correlation_warning=True,
+        centered=False,
+        show_median=True,
+    ):
+        """
+        Visualize ALE plots in the Notebook.
+
+        Parameters
+        ----------
+        labels : tuple, list, int, bool, str, optional
+            labels to visualize.
+        cscale : str, optional
+            Plotly color scale to use for the heatmap. See the standard Plotly color scales for available options
+            Default value is "YIGnBu".
+        show_distribution : bool, optional
+            If `True`, the feature’s value distribution (from the train set) will be shown along the
+            corresponding axis in the 1-feature. Default is `True`.
+        discrete_threshold : float, optional
+            Value between 0.0 and 1.0 indicating the fraction of unique values required for a numerical feature
+            to be considered discrete or continuous. Default is 0.15.
+        show_correlation_warning : bool, optional
+            If `True`, the correlated feature warning will be shown. Default is `True`.
+        centered : bool, optional
+            If `True`, ALE plots will be centered based on the first value of each sample (i.e., all values are
+            subtracted from the first value). Default is `False`.
+        show_median : bool, optional
+            If `True`, a median line is included in the ALE explanation plot. Default is `True`.
+
+        Returns
+        -------
+        str
+            Plotly HTML object containing a line chart, heat map, or violin plot for this feature dependence explanation
+        """
+        return self.fd.show_in_notebook(
+            mode="pdp",
+            labels=labels,
+            cscale=cscale,
+            show_distribution=show_distribution,
+            discrete_threshold=discrete_threshold,
+            line_gap=0,
+            show_correlation_warning=show_correlation_warning,
+            centered=centered,
+            show_median=show_median,
+        )
+
+
+class FeatureImportance:
+    """
+    Feature Permutation Importance explanation object constructed by the
+    :class:`MLXGlobalExplainer` class.
+
+    Contains functions to visualize the explanation in a Notebook and extract the
+    raw explanation data.
+    """
+
+    def __init__(self, explanation, class_names, type):
+        self.explanation = explanation
+        self.class_names = class_names
+        self.type = type
+        if isinstance(self.class_names, np.ndarray):
+            self.class_names = self.class_names.tolist()
+
+    def show_in_notebook(
+        self,
+        mode=None,
+        show=None,
+        labels=None,
+        cscale="YIGnBu",
+        colormap=None,
+        return_wordcloud=False,
+        n_features=None,
+        **kwargs,
+    ):
+        """
+        Generates a visualization for the local explanation. Depending on the type of explanation, different
+        visualizations are supported. See the "mode" and "show" parameters below.
+
+        Parameters
+        ----------
+        mode : str
+            Type of visualization to generate. Certain visualization modes are only supported for either text or
+            tabular datasets. Supported options:
+
+            - `bar`: Generates a horizontal bar chart for the most important features (text and tabular).
+            - `stacked`: Generates a stacked horizontal bar chart for the most important features (text and tabular).
+            - `box_plot`: Generates a box plot for the most important features, which provides more information
+              about the explanation over the different iterations of the feature permutation importance
+              algorithm (tabular only).
+            - `detailed`: Generates a scatter plot for the most important features, providing even more
+              information about the explanation over the different iterations of the Feature Permutation
+              Importance algorithm (tabular only).
+            - `heatmap`: Generates a heatmap representing the average feature/word importance over multiple
+              local explanations (aggregates local explanations). Average feature importance is measured by
+              the fraction of local explanations where a given feature was assigned a given importance
+              (text only).
+            - `wordcloud`: Generates a wordcloud from the average feature importance. Features/words with
+              higher importance are larger than features/words with lower importance (text only).
+
+            Default value is "bar" for tabular and "wordcloud" for text.
+        show : str
+            (text only) Secondary visualization mode for configuring the visualization.
+            Can be one of:
+
+            - `absolute`: The absolute value of feature importances are shown (i.e., a feature that is highly
+              important towards or against the target label is considered important).
+            - `posneg`: Shows both the positive and negative global feature attributions. For bar, the features
+              are ordered based on their absolute feature importance (sum of pos/neg) and a dual bar chart shows
+              the fraction of local explanations where the feature contributed both towards and against the
+              corresponding label. For wordcloud, two wordclouds are generated for the positive and negative feature
+              importances. Only valid for mode=bar and mode=wordcloud. `mode=heatmap` defaults to `show=absolute`.
+
+        labels : tuple, list, int, bool, str
+            (text only) Label indices to visualize. If `None`, all of the labels that the explanation was generated for
+            will be visualized. By default None.
+        cscale : str, optional
+            Plotly color scale to use for the heatmap. See the standard Plotly color scales for available
+            options. Default value is "YIGnBu".
+        colormap : list of str, optional
+            List of colormaps to use for the wordclouds. One per label. Defaults to `None`.
+        return_wordcloud : bool, optional
+            If `True`, the generated wordcloud objects are returned instead of visualized. Defaults
+            to `False`.
+        n_features : int, optional
+            (tabular only). Allows the user to visualize a subset of the top-N most important features from the explainer.
+            If `n_features` is `None` or greater than the total number of features, all features are shown. If
+            `n_features` is not an `int` or <= 0, an exception is thrown.
+        kwargs : dict
+            Keyword arguments for configuring the wordclouds.
+
+        Returns
+        -------
+        str, list of wordcloud
+            HTML string for the visualization or list of generated wordcloud objects if `return_wordcloud=True`,
+            two per label (+/-).
+        """
+        if self.type.type == "text":
+            if labels:
+                labels = [
+                    self.class_names.index(label) if isinstance(label, str) else label
+                    for label in labels
+                ]
+            else:
+                labels = list(range(len(self.class_names)))
+            if len(self.class_names) == 2:
+                return self.explanation.show_in_notebook()
+            else:
+                return self.explanation.show_in_notebook(
+                    mode=mode if mode else "wordcloud",
+                    show=show,
+                    labels=labels,
+                    cscale=cscale,
+                    colormap=colormap,
+                    return_wordcloud=return_wordcloud,
+                    **kwargs,
+                )
+        else:
+            if labels:
+                raise ValueError("label is supported only for text explanation.")
+            return self.explanation.show_in_notebook(
+                n_features=n_features, mode=mode if mode else "bar"
+            )
+
+    def get_global_explanation(self):
+        """
+        Returns the raw global explanation data only.
+
+        Returns
+        -------
+        dict
+            Dictionary containing raw explanation data.
+        """
+        return self.explanation.get_global_explanation()
+
+    def get_diagnostics(self):
+        """
+        Extracts the raw explanation and evaluation data from the explanation object
+        (Used to generate the visualizations).
+
+        Returns
+        -------
+        dict
+            Dictionary containing the raw explanation/evaluation data.
+        """
+        return self.explanation.get_diagnostic()
+
+
+class GlobalExplanationsException(TypeError):
+    def __init__(self, msg):
+        super(GlobalExplanationsException, self).__init__(msg)