diff --git a/README.md b/README.md index 914559c..5900e43 100644 --- a/README.md +++ b/README.md @@ -105,7 +105,9 @@ Tutorials demonstrating how to use ONNX in practice for varied scenarios across * [Float16 <-> Float32 converter](https://github.com/onnx/onnx-docker/blob/master/onnx-ecosystem/converter_scripts/float32_float16_onnx.ipynb) * [Version conversion](tutorials/VersionConversion.md) - +## Application of ONNX +* [Explainable AI for ONNX models](tutorials/XAI4ONNX_dianna_overview.ipynb) + ## Contributing We welcome improvements to the convertor tools and contributions of new ONNX bindings. Check out [contributor guide](https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md) to get started. diff --git a/tutorials/XAI4ONNX_dianna_overview.ipynb b/tutorials/XAI4ONNX_dianna_overview.ipynb new file mode 100644 index 0000000..ca79e7f --- /dev/null +++ b/tutorials/XAI4ONNX_dianna_overview.ipynb @@ -0,0 +1,2000 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "\"Logo_ER10\"\n", + "\n", + "# General overview of using dianna\n", + "\n", + "**[DIANNA](https://dianna-ai.github.io/dianna/) is a Python package that brings explainable AI (XAI) to your research project.**\n", + "\n", + "It wraps carefully selected XAI methods (explainers) in a simple, uniform interface. It's built by, with and for (academic) researchers and research software engineers working on machine learning projects.\n", + "\n", + "This overview illustrates the main strengths of DIANNA, namely supporting *many data modalities* and *several explainers*. DIANNA is *future-proof* by supporting and advocating the *[ONNX](https://onnx.ai/) de-facto standard* for Neural Network models. Many modern frameworks alpready support native export to ONNX, for tutorials on conversion from PyTorch, Keras, Scikit-learn and TensorFlow see [conversion_onnx](https://github.com/dianna-ai/dianna/tree/main/tutorials/conversion_onnx) folder. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **General workflow**\n", + "\n", + "1. Provide your *trained model* and *data item* ( *text, image, time series or tabular* )\n", + "\n", + "```python\n", + "model_path = 'your_model.onnx' # model trained on your data modality\n", + "data_item = # data item for which the model's prediction needs to be explained \n", + "```\n", + "\n", + "2. If the task is *classification*: which are the *classes* your model has been trained for?\n", + "\n", + "```python \n", + "labels = [class_a, class_b] # example of binary classification labels\n", + "```\n", + "*Which* of these classes do you want an explanation for?\n", + "```python\n", + "explained_class_index = labels.index() # explained_class can be any of the labels\n", + "```\n", + "\n", + "3. Run dianna with the *explainer* of your choice ( *'LIME', 'RISE' or 'KernalSHAP'*) and visualize the output:\n", + "\n", + "```python\n", + "explanation = dianna.(model_path, data_item, explainer)\n", + "dianna.visualization.(explanation[explained_class_index], data_item)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting up" + ] + }, + { + "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]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-06-19 11:56:05.340972: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import os\n", + "import warnings\n", + "warnings.filterwarnings('ignore') # disable warnings relateds to versions of tf\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# for explanations and visualization\n", + "import dianna\n", + "from dianna import visualization\n", + "from dianna import utils as dianna_utils\n", + "from dianna.utils.tokenizers import SpacyTokenizer\n", + "from dianna.utils.onnx_runner import SimpleModelRunner\n", + "from dianna.utils.downloader import download\n", + "\n", + "# ONNX\n", + "import onnx\n", + "import onnxruntime\n", + "from onnx_tf.backend import prepare\n", + "from dianna.utils.onnx_runner import SimpleModelRunner\n", + "\n", + "# text-related\n", + "import spacy\n", + "from torchtext.vocab import Vectors\n", + "from scipy.special import softmax\n", + "from scipy.special import expit as sigmoid\n", + "\n", + "# keras model and preprocessing tools for Image\n", + "from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input, decode_predictions\n", + "from keras import backend as K\n", + "from keras import utils as keras_utils\n", + "\n", + "# for tabular data \n", + "from sklearn.model_selection import train_test_split\n", + "from numba.core.errors import NumbaDeprecationWarning\n", + "import warnings\n", + "# silence the Numba deprecation warnings in shap\n", + "warnings.simplefilter('ignore', category=NumbaDeprecationWarning)\n", + "\n", + "# visualizations\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "import random\n", + "random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Data modalities**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "DIANNA supports *text, images, time-series* and *tabular data.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Text example*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's illustrate the general workflow above with textual data. The data item of interest is a sentence being (a part of) a movie review and the model has been trained to classify the movie reviews from the [Stanford sentiment treebank](https://nlp.stanford.edu/sentiment/index.html) into 'positive' and 'negative' sentiment classes. We are interested in which words are contributing positively (red) and which - negatively (blue) towards the model's decision to classify the review as positive and we would like to use the LIME explainer:\n", + "\n", + "*For a full example see the [lime_text](https://github.com/dianna-ai/dianna/blob/main/tutorials/explainers/LIME/lime_text.ipynb) tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Provide your *trained model* and *text* of interest." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Download the pre-trained model from Zenodo:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "model_path = download('movie_review_model.onnx', 'model')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# labels\n", + "word_vector_path = download('movie_reviews_word_vectors.txt', 'data')\n", + "labels = (\"negative\", \"positive\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The classifier accepts numerical tokens as input and outputs a score between 0 (the review is negative) and 1 (the review is positive).\n", + "Therefore, we define a model runner class, which accepts a sentence as input instead and returns one of two classes: negative or positive." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tokenizer downloaded.\n" + ] + } + ], + "source": [ + "# ensure the tokenizer for english is available\n", + "from IPython.display import clear_output\n", + "\n", + "spacy.cli.download('en_core_web_sm')\n", + "clear_output()\n", + "print(\"Tokenizer downloaded.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class MovieReviewsModelRunner:\n", + " def __init__(self, model, word_vectors, max_filter_size):\n", + " self.run_model = dianna_utils.get_function(str(model))\n", + " self.vocab = Vectors(word_vectors, cache=os.path.dirname(word_vectors))\n", + " self.max_filter_size = max_filter_size\n", + " \n", + " self.tokenizer = SpacyTokenizer(name='en_core_web_sm')\n", + "\n", + " def __call__(self, sentences):\n", + " # ensure the input has a batch axis\n", + " if isinstance(sentences, str):\n", + " sentences = [sentences]\n", + "\n", + " tokenized_sentences = []\n", + " for sentence in sentences:\n", + " # tokenize and pad to minimum length\n", + " tokens = self.tokenizer.tokenize(sentence.lower())\n", + " if len(tokens) < self.max_filter_size:\n", + " tokens += [''] * (self.max_filter_size - len(tokens))\n", + " \n", + " # numericalize the tokens\n", + " tokens_numerical = [self.vocab.stoi[token] if token in self.vocab.stoi else self.vocab.stoi['']\n", + " for token in tokens]\n", + " tokenized_sentences.append(tokens_numerical)\n", + " \n", + " # run the model, applying a sigmoid because the model outputs logits\n", + " logits = self.run_model(tokenized_sentences)\n", + " pred = np.apply_along_axis(sigmoid, 1, logits)\n", + " \n", + " # output two classes\n", + " positivity = pred[:, 0]\n", + " negativity = 1 - positivity\n", + " return np.transpose([negativity, positivity])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# define model runner. max_filter_size is a property of the model\n", + "model_runner = MovieReviewsModelRunner(model_path, word_vector_path, max_filter_size=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a sentence of interest:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "review = \"A delectable and intriguing thriller filled with surprises\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " 2. Which are the classes your model has been trained for? Which of these classes do you want an explanation for?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels = (\"negative\", \"positive\") # sentiments of the movie reviews\n", + "explained_class_index = labels.index(\"positive\") # we are interested why our sentence is classified as having a positive sentiment\n", + "explained_class_index\n", + "labels.index('positive')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " 3. Run dianna with the explainer of your choice, 'LIME', and visualize the output. For textual data use the ```explain_text``` function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "explanation = dianna.explain_text(model_runner, review, model_runner.tokenizer,'LIME', labels=[explained_class_index])[0]\n", + "explanation\n", + "fig, _ = visualization.highlight_text(explanation, model_runner.tokenizer.tokenize(review))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*The positive words (in red) carry the 'positive' sentiment classification.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image example*\n", + "\n", + "Here we apply the general workflow with image data from Imagenet. The data item of interest is an image of a bee and we use the ResNet 50 model trained on ImageNet to classify 1000 objects. We are interested in which pixels are contributing positively (red) and which - negatively (blue) towards the model's decision to classify the image as a 'bee' and we would like to use the RISE, [Petsiuk et al., \"RISE: Randomized Input Sampling for Explanation of Black-box Models\", BMVC 2018].\n", + " \n", + "\n", + "*For a full example see the [rise_imagenet](https://github.com/dianna-ai/dianna/blob/main/tutorials/explainers/RISE/rise_imagenet.ipynb) tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Provide your *trained model* and *image* of interest." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the pretrained model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class Model():\n", + " def __init__(self):\n", + " K.set_learning_phase(0)\n", + " self.model = ResNet50()\n", + " self.input_size = (224, 224)\n", + " \n", + " def run_on_batch(self, x):\n", + " return self.model.predict(x)\n", + "\n", + "model = Model()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load and preprocess the 'bee' image." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def load_img(path):\n", + " img = keras_utils.load_img(path, target_size=model.input_size)\n", + " x = keras_utils.img_to_array(img)\n", + " preproc_img = preprocess_input(x)\n", + " return img, preproc_img " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "img, preproc_img = load_img(download('bee.jpg', 'data'))\n", + "fig, ax = plt.subplots() \n", + "ax.axis('off')\n", + "plt.imshow(img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " 2. Which are the classes your model has been trained for? Which of these classes do you want an explanation for?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "309\n", + "bee\n" + ] + } + ], + "source": [ + "labels = [range(1000)] # 1000 classes of objects\n", + "# we are interested why our image is classified as a 'bee'\n", + "def class_name(idx):\n", + " return decode_predictions(np.eye(1, 1000, idx))[0][0][1]\n", + "for i in range(1000): \n", + " if class_name(i) == 'bee':\n", + " explained_class_index = i\n", + "print(explained_class_index)\n", + "print(class_name(explained_class_index))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Run dianna with the explainer of your choice, 'RISE', and visualize the output. For image use the ```explain_image``` function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "RISE masks random portions of the input image and passes the masked image through the model — the masked portion that decreases accuracy the most is the most “important” portion.To call the explainer and generate relevance scores map, the user need to specifiy the number of masks being randomly generated (`n_masks`), the resolution of features in masks (`feature_res`) and for each mask and each feature in the image, the probability of being kept unmasked (`p_keep`)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Explaining: 0%| | 0/10 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f'Explanation for `{class_name(explained_class_index)}` ({predictions[0][explained_class_index]})')\n", + "visualization.plot_image(explanation[explained_class_index], keras_utils.img_to_array(img)/255., heatmap_cmap='bwr')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What would make our model think that the image is one of a 'garden_spider'?" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation for `garden_spider` (0.005400071851909161)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "another_class_index = 74 # the fifth prediciton was 'garden_spider'\n", + "print(f'Explanation for `{class_name(another_class_index)}` ({predictions[0][another_class_index]})')\n", + "visualization.plot_image(explanation[another_class_index], keras_utils.img_to_array(img)/255., heatmap_cmap='bwr')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*It is interesting to observe that the wings of the insect support the model's classification of the image as 'bee', while the body would be a strong evidence for 'spider'*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time series example*\n", + "\n", + "Here we apply the general workflow on very simple time series (TS) data representing daily temperatures with hot and cold days. \n", + "We define a simple expert model that classifies the days to 'summer' or 'winter' based on a simple thresholding.\n", + "We use RISE to explain the individual days' contributions to the model's decision. This illustrates that the explainers can work on any ML model and are not limited to neural networks.\n", + "\n", + "*For a full example containing more complicated real temperature data from locations in Europe see the [rise_timeseries_weather](https://github.com/dianna-ai/dianna/blob/main/tutorials/explainers/RISE/rise_timeseries_weather.ipynb) tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Define your *model* and *time-series* of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# make up a weather dataset with extrems\n", + "cold_with_2_hot_days = np.expand_dims(np.array([30, 29] + list(np.zeros(26))) , axis=1)\n", + "data_extreme = cold_with_2_hot_days\n", + "fig = plt.figure()\n", + "plt.plot(data_extreme)\n", + "plt.xlabel(\"Time index\")\n", + "plt.ylabel(\"Celcius\")\n", + "plt.title(\"Temperature\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can define an 'expert' model which decides it's summer if the mean temperature is above a threshold, and winter - otherwise." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# We define a threshold for the model to make decisions\n", + "# The label is [\"summer\", \"winter\"]\n", + "threshold = 14\n", + "\n", + "def run_expert_model(data):\n", + " is_summer = np.mean(np.mean(data, axis=1), axis=1) > threshold\n", + " number_of_classes = 2\n", + " number_of_instances = data.shape[0]\n", + " result = np.zeros((number_of_instances ,number_of_classes))\n", + " result[is_summer] = [1.0, 0.0]\n", + " result[~is_summer] = [0.0, 1.0]\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " 2. Which are the classes your model has been trained for? Which of these classes do you want an explanation for?" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels = ('summer', 'winter') # two seasons\n", + "explained_class_index = labels.index('summer') # we are interested why our time-series is classified as 'summer'\n", + "explained_class_index\n", + "labels.index('summer')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " 3. Run dianna with the explainer of your choice, 'RISE', and visualize the output. For time-series data use the ```explain_timeseries``` function.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "RISE masks random portions of the input time-series based on given segmentations and passes the masked time-series through the model — the masked portion that decreases accuracy the most is the most “important” portion. we need to define the approach for masking (mask_type). Since our data is highly skewed, here we make the masked data cutoff to be the \"threshold\" value instead of the mean." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# we use the threshold to mask the data\n", + "def input_train_mean(_data):\n", + " return threshold" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Explaining: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:00<00:00, 15275.90it/s]\n" + ] + } + ], + "source": [ + "# call the explainer\n", + "explanation = dianna.explain_timeseries(run_expert_model, input_timeseries=data_extreme,\n", + " method='rise', labels=[0,1], p_keep=0.1,\n", + " n_masks=10000, mask_type=input_train_mean)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can visualize the relevance scores overlaid on time-series using the visualization functionality in dianna." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Normalize the explanation scores for the purpose of visualization\n", + "def normalize(data):\n", + " \"\"\"Squash all values into [-1,1] range.\"\"\"\n", + " zero_to_one = (data - np.min(data)) / (np.max(data) - np.min(data))\n", + " return 2*zero_to_one -1\n", + "\n", + "heatmap_channel = normalize(explanation[0])\n", + "segments = []\n", + "for i in range(len(heatmap_channel) - 1):\n", + " segments.append({\n", + " 'index': i,\n", + " 'start': i - 0.5,\n", + " 'stop': i + 0.5,\n", + " 'weight': heatmap_channel[i]})\n", + "fig, _ = visualization.plot_timeseries(range(len(heatmap_channel)), data_extreme,\n", + " segments, x_label=\"Time index\", y_label=\"Temperature\", cmap='bwr')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*The explanation for the classification of 'summer' given by the RISE explainer is consistent with our expectation as it marks all hot days in the timeseries.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tabular data example*\n", + "\n", + "In the examples so far, we have shown how dianna works on **classification** problems. Here we demonstrate the KernelSHAP explainer for a **regression** problem of the next-day temperature prediciton on tabular data. The model is an MLP regressor [trained](https://github.com/dianna-ai/dianna-exploration/blob/main/example_data/model_generation/sunshine_prediction/generate_model.ipynb) on a [weather dataset](https://zenodo.org/records/10580833) of temperatures for several locations in Europe.\n", + "\n", + "*The full example is given in the [kernalshap_tabular_weather](https://github.com/dianna-ai/dianna/blob/main/tutorials/explainers/KernelSHAP/kernelshap_tabular_weather.ipynb) tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Get the *data* and the *model* to explain" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load and prepare the data. 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.\n", + "\n", + "Select an instance to explain. DIANNA requires input in numpy format, so the input data is converted into a numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_csv(download('weather_prediction_dataset_light.csv', 'data'))\n", + "\n", + "X_data = data.drop(columns=['DATE', 'MONTH'])[:-1]\n", + "y_data = data.loc[1:][\"BASEL_sunshine\"]\n", + "\n", + "# training, validation and test split\n", + "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)\n", + "\n", + "# select an instance to explain\n", + "data_instance = X_test.iloc[10].to_numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
BASEL_cloud_coverBASEL_humidityBASEL_pressureBASEL_global_radiationBASEL_precipitationBASEL_sunshineBASEL_temp_meanBASEL_temp_minBASEL_temp_maxDE_BILT_cloud_cover...SONNBLICK_temp_meanSONNBLICK_temp_minSONNBLICK_temp_maxTOURS_humidityTOURS_pressureTOURS_global_radiationTOURS_precipitationTOURS_temp_meanTOURS_temp_minTOURS_temp_max
count548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000...548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000548.000000
mean5.6332120.7450551.0181651.2633760.2677924.26478110.8678836.97281015.2156935.385036...-4.708759-7.042883-2.3487230.7847991.0175911.3520260.16514612.0071177.73521916.278832
std2.2467830.1048960.0076590.9142860.5809994.2943936.9921346.3620118.2813532.230648...6.8745197.1207176.7518900.1160050.0082890.9296260.3720466.2460735.5703697.420308
min0.0000000.4200000.9893000.0600000.0000000.000000-6.100000-11.200000-3.7000000.000000...-25.600000-28.600000-24.7000000.3700000.9852000.0500000.000000-5.000000-9.000000-1.600000
25%4.0000000.6775001.0137000.4700000.0000000.3000005.5750002.0750009.2000004.000000...-9.500000-12.200000-6.9000000.7100001.0130000.5175000.0000007.3750003.67500010.800000
50%6.0000000.7600001.0179001.0000000.0100002.90000010.9500007.10000015.0500006.000000...-4.300000-6.350000-2.2500000.8000001.0176501.2200000.00000011.6000008.20000016.050000
75%7.0000000.8200001.0229501.9225000.2525007.40000016.32500011.82500021.7000007.000000...0.300000-1.5000002.0250000.8725001.0233002.0500000.16000017.00000012.02500022.300000
max8.0000000.9700001.0403003.4700005.36000015.00000027.70000019.60000035.9000008.000000...10.4000006.90000014.1000000.9900001.0388003.4500003.24000027.70000020.60000036.200000
\n", + "

8 rows × 89 columns

\n", + "
" + ], + "text/plain": [ + " BASEL_cloud_cover BASEL_humidity BASEL_pressure \\\n", + "count 548.000000 548.000000 548.000000 \n", + "mean 5.633212 0.745055 1.018165 \n", + "std 2.246783 0.104896 0.007659 \n", + "min 0.000000 0.420000 0.989300 \n", + "25% 4.000000 0.677500 1.013700 \n", + "50% 6.000000 0.760000 1.017900 \n", + "75% 7.000000 0.820000 1.022950 \n", + "max 8.000000 0.970000 1.040300 \n", + "\n", + " BASEL_global_radiation BASEL_precipitation BASEL_sunshine \\\n", + "count 548.000000 548.000000 548.000000 \n", + "mean 1.263376 0.267792 4.264781 \n", + "std 0.914286 0.580999 4.294393 \n", + "min 0.060000 0.000000 0.000000 \n", + "25% 0.470000 0.000000 0.300000 \n", + "50% 1.000000 0.010000 2.900000 \n", + "75% 1.922500 0.252500 7.400000 \n", + "max 3.470000 5.360000 15.000000 \n", + "\n", + " BASEL_temp_mean BASEL_temp_min BASEL_temp_max DE_BILT_cloud_cover \\\n", + "count 548.000000 548.000000 548.000000 548.000000 \n", + "mean 10.867883 6.972810 15.215693 5.385036 \n", + "std 6.992134 6.362011 8.281353 2.230648 \n", + "min -6.100000 -11.200000 -3.700000 0.000000 \n", + "25% 5.575000 2.075000 9.200000 4.000000 \n", + "50% 10.950000 7.100000 15.050000 6.000000 \n", + "75% 16.325000 11.825000 21.700000 7.000000 \n", + "max 27.700000 19.600000 35.900000 8.000000 \n", + "\n", + " ... SONNBLICK_temp_mean SONNBLICK_temp_min SONNBLICK_temp_max \\\n", + "count ... 548.000000 548.000000 548.000000 \n", + "mean ... -4.708759 -7.042883 -2.348723 \n", + "std ... 6.874519 7.120717 6.751890 \n", + "min ... -25.600000 -28.600000 -24.700000 \n", + "25% ... -9.500000 -12.200000 -6.900000 \n", + "50% ... -4.300000 -6.350000 -2.250000 \n", + "75% ... 0.300000 -1.500000 2.025000 \n", + "max ... 10.400000 6.900000 14.100000 \n", + "\n", + " TOURS_humidity TOURS_pressure TOURS_global_radiation \\\n", + "count 548.000000 548.000000 548.000000 \n", + "mean 0.784799 1.017591 1.352026 \n", + "std 0.116005 0.008289 0.929626 \n", + "min 0.370000 0.985200 0.050000 \n", + "25% 0.710000 1.013000 0.517500 \n", + "50% 0.800000 1.017650 1.220000 \n", + "75% 0.872500 1.023300 2.050000 \n", + "max 0.990000 1.038800 3.450000 \n", + "\n", + " TOURS_precipitation TOURS_temp_mean TOURS_temp_min TOURS_temp_max \n", + "count 548.000000 548.000000 548.000000 548.000000 \n", + "mean 0.165146 12.007117 7.735219 16.278832 \n", + "std 0.372046 6.246073 5.570369 7.420308 \n", + "min 0.000000 -5.000000 -9.000000 -1.600000 \n", + "25% 0.000000 7.375000 3.675000 10.800000 \n", + "50% 0.000000 11.600000 8.200000 16.050000 \n", + "75% 0.160000 17.000000 12.025000 22.300000 \n", + "max 3.240000 27.700000 20.600000 36.200000 \n", + "\n", + "[8 rows x 89 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 8. 0.76 1.0003 0.92 0.39 0.2 2. -0.2\n", + " 4.7 4. 0.85 1.0038 1.28 0.2 5.5 3.8\n", + " -1. 8.5 8. 0.87 0.73 0.14 0. 1.5\n", + " -1.1 3.8 4. 0.83 1.0024 0.98 0.12 2.9\n", + " 3.3 -2.7 8.8 5. 0.68 1.0124 0.96 0.04\n", + " 2.5 4.4 1.9 6.9 0.83 0.9996 1.14 0.21\n", + " 3.9 2. -2. 6.8 6. 0.84 1.0034 1.21\n", + " 0.02 4.7 3.3 -1.5 8.3 0.16 3.2 -0.4\n", + " 7.9 8. 0.86 0.997 0.54 0.58 0. 1.2\n", + " -0.2 2.8 8. 0.98 1.45 0.9 0. -16.8\n", + " -17.6 -15.9 0.87 1.0079 0.81 0.14 4. 0.2\n", + " 7.8 ]\n" + ] + } + ], + "source": [ + "print(data_instance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Download the pretrained ONNX model" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3.0719438]], dtype=float32)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# download onnx model and check the prediction with it\n", + "model_path = download('sunshine_hours_regression_model.onnx', 'model')\n", + " \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.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "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", + " \n", + " return pred_onnx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Run dianna with the KernelSHAP explainer and visualize the output:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to run DIANNA on tabular data is with `dianna.explain_tabular`. Note, that the training data is also required since KernelSHAP needs it to generate proper perturbation. The method's mode needs to be spesified as 'regression'." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "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": [ + "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": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from dianna.visualization import plot_tabular\n", + "\n", + "fig, _ = plot_tabular(explanation, X_test.columns, num_features=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*We can see which min or max temperatures of which locations mostly influence (positively or negatively) the predicted by the trained modelnext-day temperature in Basel.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Explainers**\n", + "DIANNA supports **LIME**, [Ribeiro et al., \"Why Should I Trust You?: Explaining the Predictions of Any Classifier\", CoRR, 2016], **RISE**, [Petsiuk et al., \"RISE: Randomized Input Sampling for Explanation of Black-box Models\", BMVC 2018] and **KernalSHAP**, [Lundberg and Lee. ,\"A unified approach to interpreting model predictions.\", NIPS 2017] XAI methods. It allows users to compare the outputs of three different explainers on the same model and data, illustrated best by [dianna's dashboard](https://github.com/dianna-ai/dianna#dashboard). This section briefly demonstrates how to run on the command line the supported explainers for the simple binary classification task of distinguishing the hand-written digits \"0\" and \"1\" on a test example from the Binary MNIST dataset, a subset of the famous MNIST benchmark. It also gives the basics for each of the explainers." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Explaining a Pretrained Binary MNIST Classification Model *" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Load the Binary MNIST data, the pretrained [binary MNIST model](https://zenodo.org/record/5907177) and chose image to be explained." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# load dataset\n", + "data_path = download('binary-mnist.npz', 'data')\n", + "data = np.load(data_path)\n", + "# load testing data and the related labels\n", + "X_test = data['X_test'].astype(np.float32).reshape([-1, 28, 28, 1]) / 256\n", + "y_test = data['y_test']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Download the onnx model\n", + "\n", + "# load the onnx model and check the prediction with it\n", + "model_path = download('mnist_model_tf.onnx', 'model')\n", + "onnx_model = onnx.load(model_path)\n", + "# get the output node\n", + "output_node = prepare(onnx_model, gen_tensor_dict=True).outputs[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Print class and image of a single instance in the test data for preview." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The predicted class for this test image is: digit 0\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# class name\n", + "class_name = ['digit 0', 'digit 1']\n", + "# instance index\n", + "i_instance = 3\n", + "# select instance for testing\n", + "test_sample = X_test[i_instance]\n", + "# model predictions with added batch axis to test sample\n", + "predictions = prepare(onnx_model).run(test_sample[None, ...])[f'{output_node}']\n", + "pred_class = class_name[np.argmax(predictions)]\n", + "other_class = class_name[np.argmin(predictions)]\n", + "# get the index of predictions\n", + "top_preds = np.argsort(-predictions)\n", + "inds = top_preds[0]\n", + "print(\"The predicted class for this test image is:\", pred_class)\n", + "plt.imshow(X_test[i_instance][:,:,0], cmap='gray') # 0 for channel" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### 1. LIME\n", + "\n", + "LIME (Local Interpretable Model-agnostic Explanations) is an explainable-AI method that aims to create an interpretable model that locally represents the classifier.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use dianna with LIME, in the explanation function (for images `explain_image`) we simply specify `method=\"LIME\"` and optionally specify the LIME hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0be6a2afa0e948e7a34ed348c1e27583", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/5000 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f'Explaination for `{pred_class}` with LIME')\n", + "fig, _ = visualization.plot_image(relevances[0], X_test[i_instance][:,:,0], data_cmap='gray')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explaination for `digit 1` with LIME\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f'Explaination for `{other_class}` with LIME')\n", + "fig, _ = visualization.plot_image(relevances[1], X_test[i_instance][:,:,0], data_cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*It is worth noting that the explanation maps for both binary classes are complementary.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### 2. RISE\n", + "\n", + "RISE is short for Randomized Input Sampling for Explanation of Black-box Models. It estimates the relevance empirically by probing the model with randomly masked versions of the input image to obtain the corresponding outputs.
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "RISE masks random portions of the input image and passes the masked image through the model — the portion that decreases the accuracy the most is the most “important” portion.
\n", + "To call the explainer and generate the relevance scores, the user need to specified the number of masks being randomly generated (`n_masks`), the resolution of features in masks (`feature_res`) and for each mask and each feature in the image, the probability of being kept unmasked (`p_keep`)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use dianna with RISE, in the explanation function (for images `explain_image`) we simply specify `method=\"RISE\"` and optionally specify the RISE hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Explaining: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 36.06it/s]\n" + ] + } + ], + "source": [ + "relevances = dianna.explain_image(model_path, test_sample, method=\"RISE\",\n", + " labels=[i for i in range(2)],\n", + " n_masks=5000, feature_res=8, p_keep=.1,\n", + " axis_labels=('height','width','channels'))[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Visualize the relevance scores for the predicted class on top of the image." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explaination for `digit 0` with RISE\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASAAAADnCAYAAAC+GYs4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAY20lEQVR4nO3df4xddZnH8fcz005/UEqHTin0x2KVwuqiq1CL/BAQwW2ySRtDgmTXlWaFJTENBrMmNCasqdl/TPafjd0/uiyKooAxaoa1WpC4IgRiWwV220oZytrOWGxn2tLfnU777B9zZ72MPc9z23vL6T1+XskNc+9zzzn3nnv6cO75Pvf5mrsjIlKGjrJfgIj86VICEpHSKAGJSGmUgESkNEpAIlKaCVFw6tSpPmPGjML4yZPxykdGziwGcOJEHM9MCN7ZxInJsp3JyODx43E8e/FmZxYD6Ej+nxG9ceCkx+uPPtPsbTU7oBptu9l1Z8tn8exjaWbZ/ft3Drr7rDNd/5LLLvPBw4cbeu7GnTvXufuSM91Wq4VH64wZM7jns58tjB8+Gv9j2L27ODY0FL+w/fvjePbvsLu7ODZ7drzsRd1Jgtm5M44fOBDHoyOyqyte9vzz4/jMmWH46EicoKL9fvBgvOlm8/LwcHEs+x9W9j/DaN2NLB99ZNmxOGlSHF+7dtVv42fEBg8fZsO99zb0XPvyl3ua2VarxUejiJz7zJo7RSuREpBIFSgBiUhplIBEpDTZhahzlBKQSLvTNSARKVVlE1DwxrKhzWjYNhtmf+utOJ7t76gcJhvJHp4RFwp1TZ0ar+Do0TgeycaDjx2L48lY+eTzzgvjI1OL3/uRI/Gms/ihQ3E8KmXJ6nSybyDZ8ZLVhnV2nvm63xHnxIs4fToDEqkCJSARKY0SkIiUwqxtR8Ha81WLyNuNjYRlt4ZWZUvM7FUz6zOzBwqec4eZbTazTWb2ndpjHzSzF2qPvWJmn8q2pTMgkSpo0VcwM+sEVgO3Af3AejPrdffNdc9ZCKwErnf3vWZ2US10GPiMu79mZnOAjWa2zt33FW1PCUikClp3DWgx0Ofu20ZXa48Dy4DNdc+5B1jt7nsB3H1X7b9bx57g7r8zs13ALGBf0cb0FUyk3TX69Ws0SfWY2Ya62z+MW9tcYEfd/f7aY/UuBy43s+fN7EUz+6P2Hma2GOgCXo9eengGNDwM23cUZ9aspcbAQHFscDBeNutokdVtROU0kyfHy6YdL5JamrQOKOpLkdUBRQUpjSyf9MTo7Ex2bCBrx5HVAUV1RFkdUNbyIvvMsy4o0fqz679ZvVxLNH4RetDdFzW5tQnAQuBmYB7wrJm9f+yrlpldAnwLuMvdwwNSZ0AiVdC6i9ADwPy6+/Nqj9XrB3rd/bi7vwFsZTQhYWbTgR8BX3L3F7ONKQGJVEHrEtB6YKGZLTCzLuBOoHfcc37I6NkPZtbD6FeybbXn/wD4prt/r5GNKQGJtLvTuwYUcvcRYAWwDtgCfNfdN5nZKjNbWnvaOmDIzDYDPwO+6O5DwB3AjcByM3updvtgtD2NgolUQQsrod19LbB23GMP1v3twBdqt/rnPAo8ejrbUgISqQL9FENEStOmP8VIh+F37CiOZ8Pwu3YVx/bujZfNRrKzYdVopDybwSTtptGdjPlOmRLHm5lzKJl2J40nouM4qwDI3la2X6PSi6wLSXY8NHO8QFyakQ3hN9OdpSFqSCYipVICEpHSKAGJSGmUgESkNEpAIlKKNm5IpgQkUgU6AxKR0lQxAQ0PQ39/cXzfvnjlUV1HNoVLJjvjjOLZslmrj6bqeIA/e/e7C2P9UfEUMHPu+NYsb3fFe98bxhdecUUY//WvXyuMZVMlbdy4PYzv3h3Ho04iWS1Nk11I0mMiqiPKjpeslUjTVAckIqVSAhKR0ugitIiURmdAIlIKXQMSkVIpAYlIaZSARKQ0VUxAJ08216Mlqn/IestkF/WzaViiHi1Zb5ipU5NtJ/PP3P7JT4bxBUEtzkiy8RMT48Y1HR1xc5rsOL311ksLY1ktzoc/HO+XZcvi+KOP/mdh7PnnNxfGoPnarmy/NFPLc9YHqPRTDBEpVRXPgESkTSgBiUhplIBEpDRKQCJSChUiikipNAomIqWp4hlQR0c8H1JWLxOVywwPx8s2058FYNq04lg2bVc2z9NtN308jF+e9NyJdtzE7u5w0b6+3WH8wIFDYfzEiXjHR9OKZcf43LmXh/GurrgY5557lhXG9u6NJ6HbseP3YTzrF5SUdnEo2K3ZurN4S1QxAYlIG9A1IBEplRKQiJSmTS9Ct+erFpG3G/salt0aWpUtMbNXzazPzB4oeM4dZrbZzDaZ2XfqHr/LzF6r3e7KtqUzIJF218JrQGbWCawGbgP6gfVm1uvum+uesxBYCVzv7nvN7KLa4xcC/wQsAhzYWFt2b9H2dAYkUgWtOwNaDPS5+zZ3HwYeB8YPT94DrB5LLO4+NpXLXwFPu/ueWuxpYEm0sfAMaMIEiEaFoyFbiIfaR0biZZudyuS8oGtF1gqku/uiMP6+q66KV5DsmP3BmO/ja74RLrtt254wfuRI3DOjszMeho/KGyYl5Qk333RTGL/m2pvD+MyZxRu/55542W9/uzeMDw3F80AdPhyGQ9mUP+fYMHyPmW2ou7/G3dfU3Z8L7Ki73w9cM24dl49u0p4HOoEvu/tPCpYN55HSVzCRKmg8AQ26+6ImtzYBWAjcDMwDnjWz95/JivQVTKTdjTUka+SWGwDm192fV3usXj/Q6+7H3f0NYCujCamRZd9GCUikClp3DWg9sNDMFphZF3AnMP777Q8ZPfvBzHoY/Uq2DVgHfMLMus2sG/hE7bFC+gomUgUtGgVz9xEzW8Fo4ugEHnb3TWa2Ctjg7r38IdFsBk4AX3T3odGXYV9hNIkBrHL38KKlEpBIFbSwEtrd1wJrxz32YN3fDnyhdhu/7MPAw41uSwlIpAr0UwwRKUVVf4yatePI2lpEdUBZbURWW5G184im7ckHA+KCl6k9PWHck/mKnn3+hcLY1q3/Gy4bTZME+X6N2pRAXMLkSbHMz7773TDeOTgYxq8L6oj++tZ3h8sODMwP47/85dYwPhR3+wjrhLLpqd4RbfpbMJ0BiVRBFc+ARKRNKAGJSCmqeg1IRNqEEpCIlEYXoUWkNDoDEpFSVPUaUEdH3B8mm5Ynm94mkvULOhK3dwlfd3a26h7n5SNH4w/7lVd+E8afeuqXhbGspqSZvjWQT2cU7puDB+OFd+0Kwz/9+tfD+F8ERWfd8+M6nw+/Z3YY3749rgPK6qei/lRZzVqzva0aUsUEJCJtQglIREqjBCQipRhrSNaGlIBEqkBnQCJSGiUgESmNEpCIlKaKCaijI55fa/r0eOVRbUU2p1hWW3E0nv4q7AeUbfvWW28J41ktzssv94fxnTuLY1kdUDClGJC/t2i/pLKdnvT74a23wvDrP/95YWzRxz8eLjsvaU414dihMD5tWnCgE7/1rGbtrF8frmohooi0CY2CiUhpdAYkIqVRAhKRUugakIiUSglIREqji9AiUpoqngF1dMR1IxMnJisP1p7NT9Xs/uw4XlxQ050UMC24OM7Lk6fG9TB79/4+jEf9YbI6oGbmQ4O8viosaskmJUvqfLI6oW2/+lVhbNE118TrzpruHIrrgC6YGdcBRTVtWd+rsz5vmK4BiUiplIBEpDRKQCJSmjZNQO156VxE/mCsIVkjt4ZWZ0vM7FUz6zOzB04RX25mu83spdrt7rrYV81sk5ltMbN/NYszo86ARKqgRWdAZtYJrAZuA/qB9WbW6+6bxz31CXdfMW7Z64DrgQ/UHnoOuAn4r6Lt6QxIpArGRsKyW24x0Ofu29x9GHgcWNbgq3BgMtAFTAImAuGQcHgGZBYPMWZDvtEUMJ1Hkilesp4XWWuIYMj4L2+4IVy0OxlO3tzXF8YHB3eE8eg4yN5WNgzf2RnHs9YRZ7VGIOslEtUINFPzAenXj+zbSfTvIJueKntpLdH4GVCPmW2ou7/G3dfU3Z8L1B/A/cCpaiBuN7Mbga3A/e6+w91fMLOfATsBA77m7luiF6OvYCJV0HgCGnT3RU1u7UngMXc/Zmb3Ao8At5jZZcB7gXm15z1tZh91918UrUhfwUTaXWsvQg8A9bNAzqs99v/cfcjdx06HHwKurv39SeBFdz/o7geBHwPXRhtTAhKpgtZdA1oPLDSzBWbWBdwJ9L59U3ZJ3d2lwNjXrO3ATWY2wcwmMnoBWl/BRCqvRaNg7j5iZiuAdUAn8LC7bzKzVcAGd+8F7jOzpcAIsAdYXlv8e8AtwH8zekH6J+7+ZLQ9JSCRdtfi34K5+1pg7bjHHqz7eyWw8hTLnQDuPZ1tKQGJVEGbVkIrAYlUQRUTUGcnzJhRHJ/SkdSF7AvaN7z5ZrLsvjietFeI6oiuXLIkXPTotm1h/MXnngvjkyfHBVJRfVRWMxK1hYC8NURWJxTW4mQbz0ZZsjcXvfhopzUSb7IYJ9pvTe/zVlBDMhEphfoBiUiplIBEpDRKQCJSGiUgESmNEpCIlGLst2BtSAlIpAqqegYUznaSTYUSNbfJ6nwGBuL4/v1xPOpds3t3uOhgUmO0fUv4+zo6r7gijPf0TCmMZdPmZP18zotnl0mnQwprfaYUv24gLhprxPnnn/m2m6zzyf79RvHsn0EWbwWnoglIRM5970SSOxuUgEQqQAlIRErhnv9K5lylBCRSAToDEpHSKAGJSGmUgESkFO4VTUDuyVRO05OJwaLajKzwIptDKolPDPrDdGTFMFE9CsAFF8TxZA6rScFbb7aUpuk5qqKLmdnKp0+P41mRU7TfjhyJl80mVMvqxpJ+Qu7F8aw1VfbSWqGSCUhE2oNGwUSkNDoDEpFSVPYakIi0ByUgESmNEpCIlEYJSERKUdnfgrnHbXWOHI1reaZEtRVZTUlWq5NMtnTl9dcXxi780IfCZQ9nTXfmzAnDx06ceV7PprfK5qDKlk+P1P3DZ75sk41x/vw97ykOJv2jTmZ1Y3v3xvFkx3VOL45H/0YgrxNqBZ0BiUhplIBEpDRKQCJSinauA2rPVvoi8jYnTzZ2a4SZLTGzV82sz8weOEV8uZntNrOXare762J/ZmZPmdkWM9tsZu+KtqUzIJEKaNUZkJl1AquB24B+YL2Z9br75nFPfcLdV5xiFd8E/tndnzazacQ/b9YZkEgVjH0Ny24NWAz0ufs2dx8GHgeWNbKgmb0PmODuT4++Jj/o7oejZcIzoBMn4MCB4ng28jlnzozCmM2aFS88HAwHNxKPhnQXLmxq3UMH4zYkWdeJqAIha5cxKemAko4JZyUG0fLZB57stzkzZ4bxy+fOLQ7u2RMu+8yPfxzG02H4pAXLhAsvKoxln/fZbsdxmteAesxsQ939Ne6+pu7+XGBH3f1+4JpTrOd2M7sR2Arc7+47gMuBfWb2fWAB8FPgAXcv3EP6CiZSAaeRgAbdfVGTm3sSeMzdj5nZvcAjwC2M5pOPAh8CtgNPAMuB/yhakb6CiVRAC7+CDQDz6+7Pqz1Wty0fcvexU+WHgKtrf/cDL9W+vo0APwSuijamBCRSAS0cBVsPLDSzBWbWBdwJ9NY/wcwuqbu7FNhSt+wMMxu7vnILMP7i9dvoK5hIm2tlHZC7j5jZCmAd0Ak87O6bzGwVsMHde4H7zGwpMALsYfRrFu5+wsz+EXjGzAzYCPx7tD0lIJEKaGUhoruvBdaOe+zBur9XAisLln0a+ECj21ICEqmAdq2EVgISqYBKJqDjx+HNN4vjHckl7GgmlVmz5oXLXnDV7HjlWb3LlVcWht6aVFzTAbC9rz+MR/sE0ll5wnKarM4n6ULCpOxDyYpWoheXFLTMSabluTapv5p8uLhmbfvWreGyfRs3hnGarDuLdmv2jz8rvWqFSiYgETn3VbYhmYi0B50BiUhplIBEpDRKQCJSinZuSKYEJFIBuggtIqWp5BnQyZNw8GBx3OJZecKalqwc5fD0uJimqyuOv/zyvsLYu94V1xBlrWOyaVayqXMi2YGUrXvS1ORDyZrT7N9fGOpIdsx1110Xxq9MpjPav2NHYeypJ58Mlz2ZHVBNio717N9BVrvVCpVMQCJy7tM1IBEplRKQiJRGCUhESqNRMBEpha4BiUiplIBEpDSVTEAnT8ZlI1nrmahlT7bDsviUKXF8aOiNwtjHPhZMdgacf37clKenJ5jYCzhyJJyLrSnpd/2k6GT2JZeE8cUf+Uhh7OKk4GVuVqQUTTIHfP+ZZwpj/dkbv/TSOJ68by6+OAxHL73Z2q1WqGQCEpFzn/oBiUipdAYkIqVRAhKR0igBiUhplIBEpBSVLkSMRl6zK+9Rh4RkFpR06HLatDg+NRgpv+CCeNnZs+MpXD7/+b8L40ND8XBzVL4Qve6G4l3xHDDzkh03Naq72LcvXPbwwEAYfzVotwEwEB0w8+eHyzY7DH9scnxQ7N9dHMs6gWRTLbWCRsFEpDSVPQMSkXOfEpCIlKLS14BE5NzXrgko+TWXiLSDsbOg7NYIM1tiZq+aWZ+ZPXCK+HIz221mL9Vud4+LTzezfjP7WrYtnQGJVECrRsHMrBNYDdwG9APrzazX3TePe+oT7r6iYDVfAZ5tZHs6AxJpc42e/TR4BrQY6HP3be4+DDwOLGv0tZjZ1cBs4KlGnh+eAU2YADNnFsezN9TdXRybGM+qw/TpcfzCC+N45OWXi9s+ANxww41h/LLL4pqSiy+O49F+O++8cNG0DcnkiUlRyltvhWEPilqOxGvmhd/8Joz/4rnn4hVEB1uzB0Sy/PFkqqWoy0n2mWRta1rhNK4B9ZjZhrr7a9x9Td39uUB9wVY/cM0p1nO7md0IbAXud/cdZtYB/AvwaeDWRl6MvoKJVMBpJKBBd1/U5OaeBB5z92Nmdi/wCHAL8Dlgrbv3WzZZWo0SkEgFtHAUbACoLzufV3usbls+VHf3IeCrtb+vBT5qZp8DpgFdZnbQ3f/oQvYYJSCRNtfihmTrgYVmtoDRxHMn8Df1TzCzS9x9Z+3uUmDL6Ovwv617znJgUZR8QAlIpBJadQbk7iNmtgJYB3QCD7v7JjNbBWxw917gPjNbCowAe4DlZ7o9JSCRCmhlIaK7rwXWjnvswbq/VwIrk3V8A/hGti0lIJEKaNdKaCUgkQqoZAKaNAkWLCiOZ286qmnJaiOyepjOo0nhRnBV7vX/+VW46K6B4il9AD716b8P411dF4XxqBdSdjEx66PkHk/Ls/n118P4m6+9Vhhb/2xS3Jq9uNmz43jUBCpp4nRielB0BuzbE2/6+PE4Hh3rWb+fs90PSD9GFZFSqSGZiJRGZ0AiUholIBEpha4BiUiplIBEpDRKQCJSmkqOgk2cCHMuDt5Z9pP7kWCOqmyPHToWxw8fjuPR+idPDhc9EDV/AVav/rcwPjgYhjkUlDBlfZKa7S2T9a6Jym0mRf16IP9MJiT/v4v2e1JMk50BZPs1OSTCl5a9rQmdZ/f0RNeARKRUSkAiUholIBEpjRKQiJSixQ3J3lFKQCIVoDMgESmNEpCIlKaaCejYMXgj6I2TveuoQCKrIcriwfxVqazoI+pLAxxI6nz27o3j0dRc2dvO6oCSEiamTo3j0Ufa3R0X03RljW+OJbVd0caTz3sCQc0ZMH1asuOyXkZR/FDSTKiZY7UBqgMSkVIpAYlIaTQKJiKl0RmQiJRC14BEpFRKQCJSmmomoOFh2L69OJ5d+Yrm1sn6I2TjxclQeTienfRPOHIkXvWBA3F8TzIFTBTPDqRsGD7bLdOmxfHoY8laeXSdl3ymWd+KqH1LJls2i2clAtFBkQ3hZ7UVLVDNBCQi5zz9FkxESqUzIBEpjRKQiJSmXRNQkx2GReRcMFYLlN0aYWZLzOxVM+szswdOEV9uZrvN7KXa7e7a4x80sxfMbJOZvWJmn8q2pTMgkTbXyovQZtYJrAZuA/qB9WbW6+6bxz31CXdfMe6xw8Bn3P01M5sDbDSzde6+r2h7SkAiFdDCr2CLgT533wZgZo8Dy4DxCegUr8G31v39OzPbBcwC9hUtEyegkyfj+oeszUDUnqHZeVKyOqGo9iKqTwIODMWrzmafOXgwjkfT8jRbB5R9JFm7jqgcJi3TyVaefebRZ5a1+sgKoJqpMYJ4x2anH1n9UwucRgLqMbMNdffXuPuauvtzgR119/uBa06xntvN7EZgK3C/u9cvg5ktBrqA16MXozMgkQo4jQQ06O6Lmtzck8Bj7n7MzO4FHgFuGQua2SXAt4C73D3MzroILdLmGr0A3WCSGgDm192fV3usbns+5O5j58oPAVePxcxsOvAj4Evu/mK2MSUgkQpoYQJaDyw0swVm1gXcCfTWP6F2hjNmKbCl9ngX8APgm+7+vUY2pq9gIhXQqlEwdx8xsxXAOqATeNjdN5nZKmCDu/cC95nZUmAE2AMsry1+B3AjMNPMxh5b7u4vFW1PCUikAlpZiOjua4G14x57sO7vlcDKUyz3KPDo6WxLCUikzakhmYiUql0TkHnwys1sN/Dbd+7liPxJutTdZ53pwmb2E6CnwacPuvuSM91Wq4UJSETkbNIwvIiURglIREqjBCQipVECEpHSKAGJSGn+D4jPoH3Xa/0MAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f'Explaination for `{pred_class}` with RISE')\n", + "fig, _ = visualization.plot_image(relevances, X_test[i_instance][:,:,0], data_cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*It is worth noting that the explanation map clearly shows the pixels which contribute positively (in red) to the \"0\" classification on the shape of the hand-written digit and the pixels whcih contributed negatively (in blue) for that decision resemble the complimentary class for \"1\" digits.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### 3. KernelSHAP\n", + "\n", + "SHapley Additive exPlanations, in short, SHAP, is a model-agnostic explainable AI approach which is used to decrypt the black-box models through estimating the [Shapley values](https://en.wikipedia.org/wiki/Shapley_value), which represent the relevancies of each data feature (image pixel, word in text, etc.). [KernelSHAP](https://proceedings.neurips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf) is a variant of SHAP. It is a method that uses the LIME framework to compute Shapley Values, and visualizes the relevance attributions for each pixel/super-pixel by displaying them on an image.
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The user needs to specify the number model re-evaluations when explaining each prediction (`nsamples`). A binary mask need to be applied to the image indicating whihc image regiona are hidden. It requires the background color for the masked image, which can be specified by `background`.
\n", + "\n", + "Performing KernelSHAP for each pixel is inefficient. It is always a good practice to segment the input image to super-pixels and perform computations on them. The user has to specify some keyword arguments related to the segmentation: the (approximate) number of labels in the segmented output image (`n_segments`), and width of Gaussian smoothing kernel for pre-processing for each image dimension (`sigma`)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use dianna with KernelSHAP, in the explanation fucntion ((for images `explain_image`) we simply specify method=\"KernelSHAP\" and optionally specify the method's hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce5a0f663b9e4b9b97f0e96e2497f024", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00