From 443f18835734818dee5704065028b7240d981b49 Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Fri, 8 Dec 2023 18:00:43 +0100
Subject: [PATCH 1/8] implement kernelshap for tabular

---
 dianna/methods/kernelshap_tabular.py | 77 ++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 dianna/methods/kernelshap_tabular.py

diff --git a/dianna/methods/kernelshap_tabular.py b/dianna/methods/kernelshap_tabular.py
new file mode 100644
index 00000000..da7ace9a
--- /dev/null
+++ b/dianna/methods/kernelshap_tabular.py
@@ -0,0 +1,77 @@
+from typing import List
+from typing import Optional
+from typing import Union
+import numpy as np
+import shap
+from shap import KernelExplainer
+from dianna import utils
+
+
+class KERNELSHAPTabular:
+    """Wrapper around the SHAP Kernel explainer for tabular data."""
+
+    def __init__(
+        self,
+        training_data: np.array,
+        feature_names: List[int] = None,
+        training_data_kmeans: Optional[int] = None,
+    ) -> None:
+        """Initializer of KERNELSHAPTabular.
+
+        Training data must be provided for the explainer to estimate the expected
+        values.
+
+        More information can be found in the API guide:
+        https://github.com/shap/shap/blob/master/shap/explainers/_kernel.py
+
+        Arguments:
+            training_data (np.array): training data, which should be numpy 2d array
+            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
+                                                 weighted kmeans
+        """
+        if training_data_kmeans:
+            self.training_data = shap.kmeans(training_data, training_data_kmeans)
+        else:
+            self.training_data = training_data
+        self.feature_names = feature_names
+
+        self.explainer: KernelExplainer
+
+    def explain(
+        self,
+        model_or_function: Union[str, callable],
+        input_tabular: np.array,
+        **kwargs,
+    ) -> np.array:
+        """Run the KernelSHAP explainer.
+
+        Args:
+            model_or_function (callable or str): The function that runs the model to be explained
+                                                 or the path to a ONNX model on disk.
+            input_tabular (np.ndarray): Data to be explained.
+
+            kwargs: These parameters are passed on
+
+        Other keyword arguments: see the documentation for KernelExplainer:
+        https://github.com/shap/shap/blob/master/shap/explainers/_kernel.py
+
+        Returns:
+            explanation: An Explanation object containing the KernelExplainer explanations
+                         for each class.
+        """
+        init_instance_kwargs = utils.get_kwargs_applicable_to_function(
+            KernelExplainer, kwargs
+        )
+        self.explainer = KernelExplainer(
+            model_or_function, self.training_data, init_instance_kwargs
+        )
+
+        explain_instance_kwargs = utils.get_kwargs_applicable_to_function(
+            self.explainer.shap_values, kwargs
+        )
+
+        saliency = self.explainer.shap_values(input_tabular, explain_instance_kwargs)
+
+        return saliency

From 2d83bddec6c42ec761f3c8e8d4c93625d6733fe3 Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Mon, 11 Dec 2023 17:16:09 +0100
Subject: [PATCH 2/8] add tutorial notebook for classification task

---
 dianna/methods/kernelshap_tabular.py       |  10 +-
 tutorials/kernelshap_tabular_penguin.ipynb | 458 +++++++++++++++++++++
 2 files changed, 464 insertions(+), 4 deletions(-)
 create mode 100644 tutorials/kernelshap_tabular_penguin.ipynb

diff --git a/dianna/methods/kernelshap_tabular.py b/dianna/methods/kernelshap_tabular.py
index da7ace9a..55d28743 100644
--- a/dianna/methods/kernelshap_tabular.py
+++ b/dianna/methods/kernelshap_tabular.py
@@ -27,7 +27,7 @@ def __init__(
         Arguments:
             training_data (np.array): training data, which should be numpy 2d array
             feature_names (list(str), optional): list of names corresponding to the columns
-                           in the training data.
+                                                 in the training data.
             training_data_kmeans(int, optional): summarize the whole training set with
                                                  weighted kmeans
         """
@@ -43,6 +43,7 @@ def explain(
         self,
         model_or_function: Union[str, callable],
         input_tabular: np.array,
+        link: str = "identity",
         **kwargs,
     ) -> np.array:
         """Run the KernelSHAP explainer.
@@ -51,7 +52,8 @@ def explain(
             model_or_function (callable or str): The function that runs the model to be explained
                                                  or the path to a ONNX model on disk.
             input_tabular (np.ndarray): Data to be explained.
-
+            link (str): A generalized linear model link to connect the feature importance values
+                        to the model. Must be either "identity" or "logit".
             kwargs: These parameters are passed on
 
         Other keyword arguments: see the documentation for KernelExplainer:
@@ -65,13 +67,13 @@ def explain(
             KernelExplainer, kwargs
         )
         self.explainer = KernelExplainer(
-            model_or_function, self.training_data, init_instance_kwargs
+            model_or_function, self.training_data, link, **init_instance_kwargs
         )
 
         explain_instance_kwargs = utils.get_kwargs_applicable_to_function(
             self.explainer.shap_values, kwargs
         )
 
-        saliency = self.explainer.shap_values(input_tabular, explain_instance_kwargs)
+        saliency = self.explainer.shap_values(input_tabular, **explain_instance_kwargs)
 
         return saliency
diff --git a/tutorials/kernelshap_tabular_penguin.ipynb b/tutorials/kernelshap_tabular_penguin.ipynb
new file mode 100644
index 00000000..04b8b41f
--- /dev/null
+++ b/tutorials/kernelshap_tabular_penguin.ipynb
@@ -0,0 +1,458 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\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"
+   ]
+  },
+  {
+   "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://raw.githubusercontent.com/dianna-ai/dianna/main/tutorials/'\n",
+    "  paths_to_download = ['models/penguin_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",
+    "import seaborn as sns\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 penguins dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "penguins = sns.load_dataset('penguins')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Prepare the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>bill_length_mm</th>\n",
+       "      <th>bill_depth_mm</th>\n",
+       "      <th>flipper_length_mm</th>\n",
+       "      <th>body_mass_g</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>39.1</td>\n",
+       "      <td>18.7</td>\n",
+       "      <td>181.0</td>\n",
+       "      <td>3750.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>39.5</td>\n",
+       "      <td>17.4</td>\n",
+       "      <td>186.0</td>\n",
+       "      <td>3800.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>40.3</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>195.0</td>\n",
+       "      <td>3250.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>36.7</td>\n",
+       "      <td>19.3</td>\n",
+       "      <td>193.0</td>\n",
+       "      <td>3450.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>39.3</td>\n",
+       "      <td>20.6</td>\n",
+       "      <td>190.0</td>\n",
+       "      <td>3650.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>338</th>\n",
+       "      <td>47.2</td>\n",
+       "      <td>13.7</td>\n",
+       "      <td>214.0</td>\n",
+       "      <td>4925.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>340</th>\n",
+       "      <td>46.8</td>\n",
+       "      <td>14.3</td>\n",
+       "      <td>215.0</td>\n",
+       "      <td>4850.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>341</th>\n",
+       "      <td>50.4</td>\n",
+       "      <td>15.7</td>\n",
+       "      <td>222.0</td>\n",
+       "      <td>5750.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>342</th>\n",
+       "      <td>45.2</td>\n",
+       "      <td>14.8</td>\n",
+       "      <td>212.0</td>\n",
+       "      <td>5200.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>343</th>\n",
+       "      <td>49.9</td>\n",
+       "      <td>16.1</td>\n",
+       "      <td>213.0</td>\n",
+       "      <td>5400.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>342 rows × 4 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     bill_length_mm  bill_depth_mm  flipper_length_mm  body_mass_g\n",
+       "0              39.1           18.7              181.0       3750.0\n",
+       "1              39.5           17.4              186.0       3800.0\n",
+       "2              40.3           18.0              195.0       3250.0\n",
+       "4              36.7           19.3              193.0       3450.0\n",
+       "5              39.3           20.6              190.0       3650.0\n",
+       "..              ...            ...                ...          ...\n",
+       "338            47.2           13.7              214.0       4925.0\n",
+       "340            46.8           14.3              215.0       4850.0\n",
+       "341            50.4           15.7              222.0       5750.0\n",
+       "342            45.2           14.8              212.0       5200.0\n",
+       "343            49.9           16.1              213.0       5400.0\n",
+       "\n",
+       "[342 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Remove categorial columns and NaN values\n",
+    "penguins_filtered = penguins.drop(columns=['island', 'sex']).dropna()\n",
+    "\n",
+    "# Get the species\n",
+    "species = penguins['species'].unique()\n",
+    "\n",
+    "# Extract inputs and target\n",
+    "input_features = penguins_filtered.drop(columns=['species'])\n",
+    "target = pd.get_dummies(penguins_filtered['species'])\n",
+    "\n",
+    "# Let's explore the features of the dataset\n",
+    "input_features"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data-set currently has four features that were used to train the model: bill length, bill depth, flipper length, and body mass. These features were used to classify the different species."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training, validation, and test data split."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(input_features, target, test_size=0.2,\n",
+    "                                                    random_state=0, shuffle=True, stratify=target)"
+   ]
+  },
+  {
+   "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 classifier for the penguins dataset. <br>\n",
+    "\n",
+    "The model is trained following this notebook: <br>\n",
+    "https://github.com/dianna-ai/dianna-exploration/blob/main/example_data/model_generation/penguin_species/generate_model.ipynb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Gentoo'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# load onnx model and check the prediction with it\n",
+    "model_path = './models/penguin_model.onnx'\n",
+    "loaded_model = SimpleModelRunner(model_path)\n",
+    "predictions = loaded_model(data_instance.reshape(1,-1).astype(np.float32))\n",
+    "species[np.argmax(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 LIME 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. But here we can summarize the whole training set with weighted Kmeans to reduce the computational cost. This has been implemented in `shap` and here we just need to set the number of clusters, for instance `training_data_kmeans = 5`."
+   ]
+  },
+  {
+   "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",
+    "                                     training_data = X_train, training_data_kmeans = 5,\n",
+    "                                     feature_names=input_features.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 importance of each feature contributing to the prediction.\n",
+    "\n",
+    "The prediction is \"Gentoo\", so let's visualize the feature importance scores for \"Gentoo\".\n",
+    "\n",
+    "It can be noticed that the body mass feature has the biggest weight in the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get the scores for the target class\n",
+    "explanation = explanation[np.argmax(predictions)]\n",
+    "\n",
+    "# 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": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "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(\"Features\")\n",
+    "plt.ylabel(\"Importance scores\")\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
+}

From 765dd67247e67685db477765a5419f04b7199542 Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Tue, 12 Dec 2023 12:29:31 +0100
Subject: [PATCH 3/8] 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 @@
     "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\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": [
+    "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\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://raw.githubusercontent.com/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. <br>\n",
+    "\n",
+    "The model is trained following this notebook: <br>\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": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "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
+}

From ebefbe8d6a2dad4fb37db21555304e157e901c54 Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Tue, 12 Dec 2023 12:52:05 +0100
Subject: [PATCH 4/8] add tests for the shap tabular api

---
 tests/methods/test_shap_tabular.py | 35 ++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 tests/methods/test_shap_tabular.py

diff --git a/tests/methods/test_shap_tabular.py b/tests/methods/test_shap_tabular.py
new file mode 100644
index 00000000..b93fe17d
--- /dev/null
+++ b/tests/methods/test_shap_tabular.py
@@ -0,0 +1,35 @@
+"""Test LIME tabular method."""
+from unittest import TestCase
+import numpy as np
+import dianna
+from dianna.methods.kernelshap_tabular import KERNELSHAPTabular
+from tests.utils import run_model
+
+
+class LIMEOnTabular(TestCase):
+    """Suite of LIME tests for the tabular case."""
+
+    def test_shap_tabular_classification_correct_output_shape(self):
+        """Test the output of explainer."""
+        training_data = np.random.random((10, 2))
+        input_data = np.random.random(2)
+        feature_names = ["feature_1", "feature_2"]
+        explainer = KERNELSHAPTabular(training_data,
+                                      mode ='classification',
+                                      feature_names=feature_names,)
+        exp = explainer.explain(
+            run_model,
+            input_data,
+        )
+        assert len(exp[0]) == len(feature_names)
+
+    def test_shap_tabular_regression_correct_output_shape(self):
+        """Test the output of explainer."""
+        training_data = np.random.random((10, 2))
+        input_data = np.random.random(2)
+        feature_names = ["feature_1", "feature_2"]
+        exp = dianna.explain_tabular(run_model, input_tabular=input_data, method='kernelshap',
+                                     mode ='regression', training_data = training_data,
+                                     training_data_kmeans = 2, feature_names=feature_names)
+
+        assert len(exp) == len(feature_names)

From 1ef3eaaf734cd3d164f83afd4f2bf057f00612e2 Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Wed, 13 Dec 2023 15:13:21 +0100
Subject: [PATCH 5/8] fix axis labels in the notebook

---
 tutorials/kernelshap_tabular_penguin.ipynb |  6 ++---
 tutorials/lime_tabular_penguin.ipynb       |  8 +++----
 tutorials/lime_tabular_weather.ipynb       | 26 +++++++++++-----------
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/tutorials/kernelshap_tabular_penguin.ipynb b/tutorials/kernelshap_tabular_penguin.ipynb
index dc54060b..c7e281d2 100644
--- a/tutorials/kernelshap_tabular_penguin.ipynb
+++ b/tutorials/kernelshap_tabular_penguin.ipynb
@@ -411,7 +411,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -426,8 +426,8 @@
     "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(\"Features\")\n",
-    "plt.ylabel(\"Importance scores\")\n",
+    "plt.xlabel(\"Importance scores\")\n",
+    "plt.ylabel(\"Features\")\n",
     "plt.show()"
    ]
   }
diff --git a/tutorials/lime_tabular_penguin.ipynb b/tutorials/lime_tabular_penguin.ipynb
index 6c1049c2..f5f88d2f 100644
--- a/tutorials/lime_tabular_penguin.ipynb
+++ b/tutorials/lime_tabular_penguin.ipynb
@@ -268,7 +268,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -399,7 +399,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -414,8 +414,8 @@
     "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(\"Features\")\n",
-    "plt.ylabel(\"Importance scores\")\n",
+    "plt.xlabel(\"Importance scores\")\n",
+    "plt.ylabel(\"Features\")\n",
     "plt.show()"
    ]
   }
diff --git a/tutorials/lime_tabular_weather.ipynb b/tutorials/lime_tabular_weather.ipynb
index b597f25f..7c9fa589 100644
--- a/tutorials/lime_tabular_weather.ipynb
+++ b/tutorials/lime_tabular_weather.ipynb
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,7 +47,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -68,7 +68,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -85,7 +85,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -102,7 +102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -119,7 +119,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -140,7 +140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -149,7 +149,7 @@
        "array([[3.0719438]], dtype=float32)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -171,7 +171,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -204,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -237,12 +237,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]

From 8fac7815c82318e45603751b7e299a83cf86c74c Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Thu, 4 Jan 2024 11:34:12 +0100
Subject: [PATCH 6/8] Apply suggestions from code review

Co-authored-by: Christiaan Meijer <c.meijer@esciencecenter.nl>
---
 tests/methods/test_shap_tabular.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/methods/test_shap_tabular.py b/tests/methods/test_shap_tabular.py
index b93fe17d..f2ecc7fe 100644
--- a/tests/methods/test_shap_tabular.py
+++ b/tests/methods/test_shap_tabular.py
@@ -10,7 +10,7 @@ class LIMEOnTabular(TestCase):
     """Suite of LIME tests for the tabular case."""
 
     def test_shap_tabular_classification_correct_output_shape(self):
-        """Test the output of explainer."""
+        """Test whether the output of explainer has the correct shape."""
         training_data = np.random.random((10, 2))
         input_data = np.random.random(2)
         feature_names = ["feature_1", "feature_2"]
@@ -24,7 +24,7 @@ def test_shap_tabular_classification_correct_output_shape(self):
         assert len(exp[0]) == len(feature_names)
 
     def test_shap_tabular_regression_correct_output_shape(self):
-        """Test the output of explainer."""
+        """Test whether the output of explainer has the correct length."""
         training_data = np.random.random((10, 2))
         input_data = np.random.random(2)
         feature_names = ["feature_1", "feature_2"]

From 041897f78937ece9d0822bbecd61ca6e2ee054af Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Thu, 11 Jan 2024 09:58:11 +0100
Subject: [PATCH 7/8] use dianna visual module for shap tutorials

---
 tutorials/kernelshap_tabular_penguin.ipynb | 29 ++++------------------
 tutorials/kernelshap_tabular_weather.ipynb | 25 +++----------------
 2 files changed, 8 insertions(+), 46 deletions(-)

diff --git a/tutorials/kernelshap_tabular_penguin.ipynb b/tutorials/kernelshap_tabular_penguin.ipynb
index c7e281d2..24b93ceb 100644
--- a/tutorials/kernelshap_tabular_penguin.ipynb
+++ b/tutorials/kernelshap_tabular_penguin.ipynb
@@ -387,23 +387,6 @@
     "It can be noticed that the body mass feature has the biggest weight in the prediction."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# get the scores for the target class\n",
-    "explanation = explanation[np.argmax(predictions)]\n",
-    "\n",
-    "# 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,
@@ -411,7 +394,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -421,14 +404,12 @@
     }
    ],
    "source": [
-    "from matplotlib import pyplot as plt\n",
+    "from dianna.visualization import plot_tabular\n",
     "\n",
-    "colors = ['b' if x >= 0 else 'r' for x in top_values]\n",
+    "# get the scores for the target class\n",
+    "explanation = explanation[np.argmax(predictions)]\n",
     "\n",
-    "plt.barh(top_features, top_values, color=colors)\n",
-    "plt.xlabel(\"Importance scores\")\n",
-    "plt.ylabel(\"Features\")\n",
-    "plt.show()"
+    "_ = plot_tabular(explanation, X_test.columns, num_features=10)"
    ]
   }
  ],
diff --git a/tutorials/kernelshap_tabular_weather.ipynb b/tutorials/kernelshap_tabular_weather.ipynb
index 284ce90e..9920703b 100644
--- a/tutorials/kernelshap_tabular_weather.ipynb
+++ b/tutorials/kernelshap_tabular_weather.ipynb
@@ -240,24 +240,10 @@
    "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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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -267,14 +253,9 @@
     }
    ],
    "source": [
-    "from matplotlib import pyplot as plt\n",
-    "\n",
-    "colors = ['b' if x >= 0 else 'r' for x in top_values]\n",
+    "from dianna.visualization import plot_tabular\n",
     "\n",
-    "plt.barh(top_features, top_values, color=colors)\n",
-    "plt.xlabel(\"Importance scores\")\n",
-    "plt.ylabel(\"Features\")\n",
-    "plt.show()"
+    "_ = plot_tabular(explanation, X_test.columns, num_features=10)"
    ]
   }
  ],

From 080d33b17c2d91e1494c8cccb6140f8e9d99798d Mon Sep 17 00:00:00 2001
From: Yang <y.liu@esciencecenter.nl>
Date: Thu, 11 Jan 2024 12:51:14 +0100
Subject: [PATCH 8/8] revise notebooks based on review

---
 tutorials/kernelshap_tabular_penguin.ipynb | 11 ++++-------
 tutorials/kernelshap_tabular_weather.ipynb | 11 ++++-------
 tutorials/lime_tabular_penguin.ipynb       |  1 -
 tutorials/lime_tabular_weather.ipynb       |  1 -
 4 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/tutorials/kernelshap_tabular_penguin.ipynb b/tutorials/kernelshap_tabular_penguin.ipynb
index 24b93ceb..ffcc5ab7 100644
--- a/tutorials/kernelshap_tabular_penguin.ipynb
+++ b/tutorials/kernelshap_tabular_penguin.ipynb
@@ -7,14 +7,14 @@
     "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\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."
+    "This notebook demonstrates the use of DIANNA with the SHAP Kernel explainer method for tabular data on the penguins dataset."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Colab setup"
+    "### Colab setup"
    ]
   },
   {
@@ -337,7 +337,6 @@
     "\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"
    ]
@@ -363,8 +362,6 @@
      "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"
      ]
     }
@@ -380,7 +377,7 @@
    "metadata": {},
    "source": [
     "#### 4. Visualization\n",
-    "(TODO:) The output can be visualized with the DIANNA built-in visualization function. It shows the importance of each feature contributing to the prediction.\n",
+    "The output can be visualized with the DIANNA built-in visualization function. It shows the importance of each feature contributing to the prediction.\n",
     "\n",
     "The prediction is \"Gentoo\", so let's visualize the feature importance scores for \"Gentoo\".\n",
     "\n",
@@ -389,7 +386,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
diff --git a/tutorials/kernelshap_tabular_weather.ipynb b/tutorials/kernelshap_tabular_weather.ipynb
index 9920703b..a239ee38 100644
--- a/tutorials/kernelshap_tabular_weather.ipynb
+++ b/tutorials/kernelshap_tabular_weather.ipynb
@@ -7,7 +7,7 @@
     "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\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",
+    "This notebook demonstrates the use of DIANNA with the SHAP Kernel explainer method for tabular data on the weather dataset.\n",
     "\n",
     "https://shap.readthedocs.io/en/latest/example_notebooks/tabular_examples/model_agnostic/Diabetes%20regression.html"
    ]
@@ -16,7 +16,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Colab setup"
+    "### Colab setup"
    ]
   },
   {
@@ -190,7 +190,6 @@
     "\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"
    ]
@@ -216,8 +215,6 @@
      "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"
      ]
     }
@@ -233,7 +230,7 @@
    "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."
+    "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."
    ]
   },
   {
@@ -243,7 +240,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/tutorials/lime_tabular_penguin.ipynb b/tutorials/lime_tabular_penguin.ipynb
index f95730d6..09d4af1d 100644
--- a/tutorials/lime_tabular_penguin.ipynb
+++ b/tutorials/lime_tabular_penguin.ipynb
@@ -334,7 +334,6 @@
     "\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"
    ]
diff --git a/tutorials/lime_tabular_weather.ipynb b/tutorials/lime_tabular_weather.ipynb
index b7da342f..57f2a320 100644
--- a/tutorials/lime_tabular_weather.ipynb
+++ b/tutorials/lime_tabular_weather.ipynb
@@ -185,7 +185,6 @@
     "\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"
    ]