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": [
+ " \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, ?it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 6s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 10%|████████████▌ | 1/10 [00:06<00:58, 6.49s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 20%|█████████████████████████▏ | 2/10 [00:11<00:43, 5.48s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 30%|█████████████████████████████████████▊ | 3/10 [00:16<00:36, 5.17s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 40%|██████████████████████████████████████████████████▍ | 4/10 [00:20<00:29, 5.00s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 50%|███████████████████████████████████████████████████████████████ | 5/10 [00:25<00:24, 4.94s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 60%|███████████████████████████████████████████████████████████████████████████▌ | 6/10 [00:31<00:20, 5.10s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 70%|████████████████████████████████████████████████████████████████████████████████████████▏ | 7/10 [00:36<00:15, 5.18s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 80%|████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 8/10 [00:41<00:10, 5.17s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 90%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 9/10 [00:46<00:05, 5.07s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4/4 [==============================] - 5s 1s/step\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Explaining: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:51<00:00, 5.14s/it]\n"
+ ]
+ }
+ ],
+ "source": [
+ "explanation = dianna.explain_image(model.run_on_batch, preproc_img, method=\"RISE\", labels=[i for i in range(1000)], \n",
+ " n_masks=1000, feature_res=6, p_keep=.1, axis_labels={2: 'channels'})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Make predictions and check the top 5 predictions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1/1 [==============================] - 0s 146ms/step\n",
+ "Top predicted class index: 309\n",
+ "Top 5 predicted class name: bee\n",
+ "Top 5 predicted class indicies: [309 946 308 319 74]\n",
+ "Top 5 predicted class names:\n",
+ "bee\n",
+ "cardoon\n",
+ "fly\n",
+ "dragonfly\n",
+ "garden_spider\n"
+ ]
+ }
+ ],
+ "source": [
+ "predictions = model.model.predict(preproc_img[None, ...])\n",
+ "# print the index and name of the top predicted class, taking care of adding a batch axis to the model input\n",
+ "print(\"Top predicted class index: \", np.argmax(predictions))\n",
+ "print(\"Top 5 predicted class name: \", class_name(np.argmax(predictions)))\n",
+ "\n",
+ "prediction_ids = np.argsort(predictions)[0][-1:-6:-1]\n",
+ "print(\"Top 5 predicted class indicies:\", prediction_ids)\n",
+ "print(\"Top 5 predicted class names:\")\n",
+ "for class_idx in prediction_ids:\n",
+ " print(class_name(class_idx))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Our model has predicted the image class correctly. Visualize the relevance scores for the 'bee' class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Explanation for `bee` (0.922955334186554)\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "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",
+ " BASEL_cloud_cover \n",
+ " BASEL_humidity \n",
+ " BASEL_pressure \n",
+ " BASEL_global_radiation \n",
+ " BASEL_precipitation \n",
+ " BASEL_sunshine \n",
+ " BASEL_temp_mean \n",
+ " BASEL_temp_min \n",
+ " BASEL_temp_max \n",
+ " DE_BILT_cloud_cover \n",
+ " ... \n",
+ " SONNBLICK_temp_mean \n",
+ " SONNBLICK_temp_min \n",
+ " SONNBLICK_temp_max \n",
+ " TOURS_humidity \n",
+ " TOURS_pressure \n",
+ " TOURS_global_radiation \n",
+ " TOURS_precipitation \n",
+ " TOURS_temp_mean \n",
+ " TOURS_temp_min \n",
+ " TOURS_temp_max \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " count \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " ... \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " 548.000000 \n",
+ " \n",
+ " \n",
+ " mean \n",
+ " 5.633212 \n",
+ " 0.745055 \n",
+ " 1.018165 \n",
+ " 1.263376 \n",
+ " 0.267792 \n",
+ " 4.264781 \n",
+ " 10.867883 \n",
+ " 6.972810 \n",
+ " 15.215693 \n",
+ " 5.385036 \n",
+ " ... \n",
+ " -4.708759 \n",
+ " -7.042883 \n",
+ " -2.348723 \n",
+ " 0.784799 \n",
+ " 1.017591 \n",
+ " 1.352026 \n",
+ " 0.165146 \n",
+ " 12.007117 \n",
+ " 7.735219 \n",
+ " 16.278832 \n",
+ " \n",
+ " \n",
+ " std \n",
+ " 2.246783 \n",
+ " 0.104896 \n",
+ " 0.007659 \n",
+ " 0.914286 \n",
+ " 0.580999 \n",
+ " 4.294393 \n",
+ " 6.992134 \n",
+ " 6.362011 \n",
+ " 8.281353 \n",
+ " 2.230648 \n",
+ " ... \n",
+ " 6.874519 \n",
+ " 7.120717 \n",
+ " 6.751890 \n",
+ " 0.116005 \n",
+ " 0.008289 \n",
+ " 0.929626 \n",
+ " 0.372046 \n",
+ " 6.246073 \n",
+ " 5.570369 \n",
+ " 7.420308 \n",
+ " \n",
+ " \n",
+ " min \n",
+ " 0.000000 \n",
+ " 0.420000 \n",
+ " 0.989300 \n",
+ " 0.060000 \n",
+ " 0.000000 \n",
+ " 0.000000 \n",
+ " -6.100000 \n",
+ " -11.200000 \n",
+ " -3.700000 \n",
+ " 0.000000 \n",
+ " ... \n",
+ " -25.600000 \n",
+ " -28.600000 \n",
+ " -24.700000 \n",
+ " 0.370000 \n",
+ " 0.985200 \n",
+ " 0.050000 \n",
+ " 0.000000 \n",
+ " -5.000000 \n",
+ " -9.000000 \n",
+ " -1.600000 \n",
+ " \n",
+ " \n",
+ " 25% \n",
+ " 4.000000 \n",
+ " 0.677500 \n",
+ " 1.013700 \n",
+ " 0.470000 \n",
+ " 0.000000 \n",
+ " 0.300000 \n",
+ " 5.575000 \n",
+ " 2.075000 \n",
+ " 9.200000 \n",
+ " 4.000000 \n",
+ " ... \n",
+ " -9.500000 \n",
+ " -12.200000 \n",
+ " -6.900000 \n",
+ " 0.710000 \n",
+ " 1.013000 \n",
+ " 0.517500 \n",
+ " 0.000000 \n",
+ " 7.375000 \n",
+ " 3.675000 \n",
+ " 10.800000 \n",
+ " \n",
+ " \n",
+ " 50% \n",
+ " 6.000000 \n",
+ " 0.760000 \n",
+ " 1.017900 \n",
+ " 1.000000 \n",
+ " 0.010000 \n",
+ " 2.900000 \n",
+ " 10.950000 \n",
+ " 7.100000 \n",
+ " 15.050000 \n",
+ " 6.000000 \n",
+ " ... \n",
+ " -4.300000 \n",
+ " -6.350000 \n",
+ " -2.250000 \n",
+ " 0.800000 \n",
+ " 1.017650 \n",
+ " 1.220000 \n",
+ " 0.000000 \n",
+ " 11.600000 \n",
+ " 8.200000 \n",
+ " 16.050000 \n",
+ " \n",
+ " \n",
+ " 75% \n",
+ " 7.000000 \n",
+ " 0.820000 \n",
+ " 1.022950 \n",
+ " 1.922500 \n",
+ " 0.252500 \n",
+ " 7.400000 \n",
+ " 16.325000 \n",
+ " 11.825000 \n",
+ " 21.700000 \n",
+ " 7.000000 \n",
+ " ... \n",
+ " 0.300000 \n",
+ " -1.500000 \n",
+ " 2.025000 \n",
+ " 0.872500 \n",
+ " 1.023300 \n",
+ " 2.050000 \n",
+ " 0.160000 \n",
+ " 17.000000 \n",
+ " 12.025000 \n",
+ " 22.300000 \n",
+ " \n",
+ " \n",
+ " max \n",
+ " 8.000000 \n",
+ " 0.970000 \n",
+ " 1.040300 \n",
+ " 3.470000 \n",
+ " 5.360000 \n",
+ " 15.000000 \n",
+ " 27.700000 \n",
+ " 19.600000 \n",
+ " 35.900000 \n",
+ " 8.000000 \n",
+ " ... \n",
+ " 10.400000 \n",
+ " 6.900000 \n",
+ " 14.100000 \n",
+ " 0.990000 \n",
+ " 1.038800 \n",
+ " 3.450000 \n",
+ " 3.240000 \n",
+ " 27.700000 \n",
+ " 20.600000 \n",
+ " 36.200000 \n",
+ " \n",
+ " \n",
+ "
\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, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# need to preprocess, because we divided the input data by 256 for the models and LIME needs RGB values\n",
+ "def preprocess_function(image):\n",
+ " return (image / 256).astype(np.float32)\n",
+ "\n",
+ "# An explanation is returned for each label, but we ask for just one label so the output is a list of length one.\n",
+ "relevances = dianna.explain_image(model_path, test_sample * 256, method=\"LIME\",\n",
+ " axis_labels=('height','width','channels'),\n",
+ " random_state=2,\n",
+ " labels=[i for i in range(2)], preprocess_function=preprocess_function)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Explaination for `digit 0` 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 `{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": "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\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, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# use KernelSHAP to explain the network's predictions\n",
+ "relevances = dianna.explain_image(model_path, test_sample,\n",
+ " method=\"KernelSHAP\", labels=[0], nsamples=1000,\n",
+ " background=0, n_segments=200, sigma=0,\n",
+ " axis_labels=('height','width','channels'))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " ***For full examples of many [combinations](https://github.com/dianna-ai/dianna/tree/main#tutorials) of explainers and data modalities for both simple benchmarking datasets or for more serious scientific use cases, please, refer to [dianna's tutorials](https://github.com/dianna-ai/dianna/tree/main/tutorials#tutorials).**"
+ ]
+ }
+ ],
+ "metadata": {
+ "interpreter": {
+ "hash": "e7604e8ec5f09e490e10161e37a4725039efd3ab703d81b1b8a1e00d6741866c"
+ },
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}