notebooks/all-in-one-no-output.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aXO_E5rLlg8D"
      },
      "source": [
        "# README"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOC_CAzRlk93"
      },
      "source": [
        "This notebook is organised as follows:\n",
        "\n",
        "1.   **Recover** section contains recovery setup with an example of saving and loading data to google drive. This was used for longer experiments where the instance could timeout, such as LIME evaluation on Imagenet.\n",
        "2.   **Setup** section contains commands for installing dependencies and defines functions to initialise datasets and models.\n",
        "3.   **Metrics** section contains the implementations of the five metrics that we used to evaluate the explainability techniques.\n",
        "4.   **Explainers** section contains wrappers/adapters for the different explainers to provide a unified interface to execute the experiments.\n",
        "5.   **Experiments** section contains executions of all the experiments we conducted. Sections 2-4 should be expecuted prior to running anything in this section, and, optionally Section 1, as well as the Utils subsection, containing helper functions for visualization.\n",
        "The comparative evaluation of the XAI techniques itself is organised by dataset, by model, then by method. Prior to running an experiment for a particular technique, initialisation for the dataset and model have to be executed.\n",
        "Finally, this section also contains the code used to generate images included in the paper.\n",
        "\n",
        "Known issues:\n",
        "\n",
        "1.   GradCAM and GradCAM++ explainers seem to have a memory leak. This is not really perceptible in small-scale experiments, but running fidelity evaluation for 1000 Imagenet images using GradCAM or GradCAM++ explainers crashes the instance. A workaround for this is to re-initialise the model before running fidelity calculation.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5Jc3HZgXqV0"
      },
      "source": [
        "# Recover"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lYDbTYYwXtXR",
        "outputId": "fd021cd9-5c3f-4a19-f49d-3e1c2417da04"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EgAIzk2aXvCl"
      },
      "outputs": [],
      "source": [
        "# np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_shap.npy\", exps)\n",
        "# exps = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_shap.npy\", exps)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkS_CYChdlku"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jehpyfydgPJT"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "%pip install shap grad-cam captum detectors tqdm\n",
        "%pip install git+https://github.com/marcotcr/lime"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FhIFlSJeVNzR",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "import os, json\n",
        "import itertools\n",
        "import sklearn\n",
        "import sklearn.cluster\n",
        "from functools import partial\n",
        "import random\n",
        "from statistics import mean\n",
        "import time\n",
        "from tqdm import tqdm\n",
        "from functools import partial\n",
        "\n",
        "import torch\n",
        "from torchvision import models, transforms\n",
        "from torch.autograd import Variable\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import detectors\n",
        "import timm\n",
        "\n",
        "from skimage.segmentation import slic, mark_boundaries, quickshift\n",
        "from skimage.util import img_as_float32 as img_as_float\n",
        "from skimage.util import random_noise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m__2njBjFnhj"
      },
      "outputs": [],
      "source": [
        "SEED = 42\n",
        "np.random.seed(SEED)\n",
        "random.seed(SEED)\n",
        "torch.manual_seed(SEED)\n",
        "torch.cuda.manual_seed(SEED)\n",
        "# When running on the CuDNN backend, two further options must be set\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = False\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "tqdm = partial(tqdm, position=0, leave=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cqE5UEb3YAFy"
      },
      "source": [
        "## Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b4Uf4hGjX_Wn"
      },
      "outputs": [],
      "source": [
        "def clean_axis(ax):\n",
        "    ax.xaxis.set_ticklabels([])\n",
        "    ax.yaxis.set_ticklabels([])\n",
        "    ax.xaxis.set_ticks([])\n",
        "    ax.yaxis.set_ticks([])\n",
        "    ax.spines['bottom'].set_color(None)\n",
        "    ax.spines['top'].set_color(None)\n",
        "    ax.spines['right'].set_color(None)\n",
        "    ax.spines['left'].set_color(None)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19k1g_w7VNzS"
      },
      "source": [
        "## Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z2CtRkDTcuIx"
      },
      "outputs": [],
      "source": [
        "N_IMAGES_PER_CLASS = 10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qlhbtFxxHrPA"
      },
      "outputs": [],
      "source": [
        "imagenet_idx_to_imagenette = {\n",
        "    0: 0,    # tench\n",
        "    217: 1,  # English springer\n",
        "    482: 2,  # cassette player\n",
        "    491: 3,  # chain saw\n",
        "    497: 4,  # church\n",
        "    566: 5,  # French horn\n",
        "    569: 6,  # garbage truck\n",
        "    571: 7,  # gas pump\n",
        "    574: 8,  # golf ball\n",
        "    701: 9,  # parachute\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AKRregCtZXPL"
      },
      "outputs": [],
      "source": [
        "def get_sample_images(dataset, classes, n_images_per_class=N_IMAGES_PER_CLASS):\n",
        "    images_by_class = [[] for c in classes]\n",
        "\n",
        "    for image, cls in dataset:\n",
        "        if len(images_by_class[cls]) == n_images_per_class:\n",
        "            continue\n",
        "        images_by_class[cls].append(image)\n",
        "        if all(len(v) == n_images_per_class for v in images_by_class):\n",
        "            break\n",
        "\n",
        "    images = [j for i in images_by_class for j in i]\n",
        "    labels = [c for c, i in enumerate(images_by_class) for j in i]\n",
        "    return images, labels, images_by_class\n",
        "\n",
        "\n",
        "def show_images_by_class(images_by_class):\n",
        "    plt.figure()\n",
        "    nrow = len(images_by_class)\n",
        "    ncol = min(max([len(x) for x in images_by_class]), 10)\n",
        "    _, axarr = plt.subplots(nrow, ncol, figsize=(ncol, nrow))\n",
        "    for i, cls_images in enumerate(images_by_class):\n",
        "        for j, img in enumerate(cls_images[:10]):\n",
        "            axarr[i,j].imshow(img.convert('RGB'))\n",
        "            axarr[i,j].axis(\"off\")\n",
        "\n",
        "\n",
        "def get_random_images_of_each_class(images_by_class, n_img=1):\n",
        "    res = []\n",
        "    for cls_images in images_by_class:\n",
        "        res.extend(random.sample(cls_images, n_img))\n",
        "    return res\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wWRi6LCeBGUB"
      },
      "outputs": [],
      "source": [
        "from torchvision.datasets import CIFAR100, CIFAR10, Imagenette, SVHN\n",
        "\n",
        "\n",
        "def init_dataset(dataset_name):\n",
        "    if dataset_name == \"cifar100\":\n",
        "        dataset = CIFAR100(root=\"./data\", download=True, train=False)\n",
        "        classes = dataset.classes\n",
        "        size, high_width, channels = 32, 32 * 32, 3\n",
        "    elif dataset_name == \"cifar10\":\n",
        "        dataset = CIFAR10(root=\"./data\", download=True, train=False)\n",
        "        classes = dataset.classes\n",
        "        size, high_width, channels = 32, 32 * 32, 3\n",
        "    elif dataset_name == \"imagenet\":\n",
        "        dataset = Imagenette(\n",
        "            root=\"./data\",\n",
        "            # download=True,\n",
        "            split=\"val\",\n",
        "            transform=transforms.Compose(\n",
        "                [\n",
        "                    transforms.Resize((256, 256)),\n",
        "                    transforms.CenterCrop(224)\n",
        "                ]\n",
        "            )\n",
        "        )\n",
        "        classes = dataset.classes\n",
        "        size, high_width, channels = 224, 224 * 224, 3\n",
        "    elif dataset_name == \"svhn\":\n",
        "        dataset = SVHN(root=\"./data\", download=True, split=\"test\")\n",
        "        classes = list(range(10))\n",
        "        size, high_width, channels = 32, 32 * 32, 3\n",
        "    else:\n",
        "        raise Exception(\"Unsupported dataset\")\n",
        "\n",
        "    return dataset, classes, size, high_width, channels\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J57thLxzYF09"
      },
      "source": [
        "## Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qXvJlZyB9ZYp"
      },
      "outputs": [],
      "source": [
        "from detectors.data import CIFAR100_DEFAULT_MEAN, CIFAR100_DEFAULT_STD\n",
        "from detectors.data import CIFAR10_DEFAULT_MEAN, CIFAR10_DEFAULT_STD\n",
        "from detectors.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD\n",
        "from detectors.data import SVHN_DEFAULT_MEAN, SVHN_DEFAULT_STD\n",
        "\n",
        "\n",
        "def get_preprocess_transform(dataset_name):\n",
        "    if dataset_name == \"cifar100\":\n",
        "        mean, std = CIFAR100_DEFAULT_MEAN, CIFAR100_DEFAULT_STD\n",
        "    elif dataset_name == \"cifar10\":\n",
        "        mean, std = CIFAR10_DEFAULT_MEAN, CIFAR10_DEFAULT_STD\n",
        "    elif dataset_name == \"imagenet\":\n",
        "        mean, std = IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD\n",
        "    elif dataset_name == \"svhn\":\n",
        "        mean, std = SVHN_DEFAULT_MEAN, SVHN_DEFAULT_STD\n",
        "    else:\n",
        "        raise Exception(\"Unsupported dataset\")\n",
        "\n",
        "    return transforms.Compose(\n",
        "        [\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean=mean, std=std)\n",
        "        ]\n",
        "    )\n",
        "\n",
        "\n",
        "def get_model(architecture_name, dataset_name):\n",
        "    if architecture_name not in (\"vgg16_bn\", \"resnet50\", \"densenet121\"):\n",
        "        raise Exception(\"Unsupported architecture\")\n",
        "    if dataset_name not in (\"cifar100\", \"cifar10\", \"imagenet\", \"svhn\"):\n",
        "        raise Exception(\"Unsupported dataset\")\n",
        "\n",
        "    if dataset_name == \"imagenet\":\n",
        "        weights = {\n",
        "            \"vgg16_bn\": models.VGG16_BN_Weights,\n",
        "            \"resnet50\": models.ResNet50_Weights,\n",
        "            \"densenet121\": models.DenseNet121_Weights,\n",
        "        }[architecture_name]\n",
        "        model = getattr(models, architecture_name)(weights=weights)\n",
        "    else:\n",
        "        model = timm.create_model(f\"{architecture_name}_{dataset_name}\", pretrained=True)\n",
        "\n",
        "    if architecture_name == \"resnet50\":\n",
        "        target_layers = [model.layer4[-1]]\n",
        "    elif architecture_name == \"vgg16_bn\":\n",
        "        target_layers = [model.features[-2]]\n",
        "    elif architecture_name == \"densenet121\":\n",
        "        target_layers = [model.features[-1]]\n",
        "    return model, target_layers\n",
        "\n",
        "\n",
        "def get_batch_predict(model, preprocess_transform):\n",
        "\n",
        "    def batch_predict(images):\n",
        "        model.eval()\n",
        "        batch = torch.stack(tuple(preprocess_transform(i) for i in images), dim=0)\n",
        "\n",
        "        model.to(device)\n",
        "        batch = batch.to(device)\n",
        "\n",
        "        logits = model(batch)\n",
        "        probs = F.softmax(logits, dim=1)\n",
        "        return probs.detach().cpu().numpy()\n",
        "\n",
        "    return batch_predict"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9FpPR2U2TeT1"
      },
      "source": [
        "# **Metrics**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BV3Lfif7fN7I"
      },
      "outputs": [],
      "source": [
        "# UTILS\n",
        "\n",
        "def dist(img1, img2):\n",
        "    return np.sqrt(np.sum((img2 - img1)**2))\n",
        "\n",
        "\n",
        "def auc(arr):\n",
        "    \"\"\"Returns normalized Area Under Curve of the array.\"\"\"\n",
        "    return (arr.sum() - arr[0] / 2 - arr[-1] / 2) / (arr.shape[0] - 1)\n",
        "\n",
        "\n",
        "def minmax_scale(img):\n",
        "    if np.min(img) == np.max(img):\n",
        "        return img\n",
        "    return (img - np.min(img)) / (np.max(img) - np.min(img))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tiQPlUNRTc-U"
      },
      "outputs": [],
      "source": [
        "def calculate_identity(exps1, exps2):\n",
        "    dis = np.array([np.array_equal(exps1[i],exps2[i]) for i in range(len(exps1))])\n",
        "    total = dis.shape[0]\n",
        "    true = np.sum(dis)\n",
        "    score = (total-true)/total\n",
        "    print('true:', true, 'wrong:', total-true, 'total:', total)\n",
        "    return score*100, true, total\n",
        "\n",
        "\n",
        "def calculate_separability(exps):\n",
        "    wrong = 0\n",
        "    for i in range(exps.shape[0]):\n",
        "        for j in range(exps.shape[0]):\n",
        "            if i == j:\n",
        "                continue\n",
        "            eq = np.array_equal(exps[i],exps[j])\n",
        "            if eq:\n",
        "                wrong += 1\n",
        "    total = exps.shape[0]\n",
        "    score = 100*abs(wrong)/(total**2-total)\n",
        "    print('true:', total**2-total-wrong, 'wrong:', wrong, 'total:', total**2-total)\n",
        "    return wrong, total, total**2-total, score\n",
        "\n",
        "\n",
        "def calculate_fidelity(images, explanations, model, step, print_every=1, get_class=None):\n",
        "    n_steps = (HW + step - 1) // step\n",
        "\n",
        "    print_steps = [int((n_steps+1) * p) for p in (0, 0.25, 0.5, 0.75)]\n",
        "    print_img_size = 4  #inches\n",
        "    print_img_count = len(print_steps) + 2\n",
        "    print_inds = list(range(0, len(images), print_every)) if print_every else []\n",
        "\n",
        "    scores = []\n",
        "\n",
        "    for pind, (image, explanation) in tqdm(enumerate(zip(images, explanations))):\n",
        "        img = img_as_float(image)\n",
        "        img_scores = np.empty(n_steps + 1)\n",
        "        salient_order = np.flip(np.argsort(explanation.reshape(-1, HW), axis=1), axis=-1)\n",
        "        pred = torch.tensor(model(img))\n",
        "        _, c = torch.max(pred, 1)\n",
        "        c = c[0]\n",
        "\n",
        "\n",
        "        if pind in print_inds:\n",
        "            plt.figure(figsize=(print_img_size * print_img_count, print_img_size))\n",
        "\n",
        "            plt.subplot(1, print_img_count, 1)\n",
        "            plt.title(\"Explanation\", fontsize=14)\n",
        "            plt.imshow(explanation)\n",
        "            if not get_class:\n",
        "                plt.axis('off')\n",
        "            else:\n",
        "                ax = plt.gca()\n",
        "                clean_axis(ax)\n",
        "                ax.set_ylabel(get_class(c), fontsize=14)\n",
        "\n",
        "        for i in range(n_steps+1):\n",
        "            pred = torch.tensor(model(img))\n",
        "            # pr, cl = torch.topk(pred, 2)\n",
        "            img_scores[i] = pred[0, c]\n",
        "\n",
        "            if pind in print_inds and i in print_steps:\n",
        "                plt.subplot(1, print_img_count, print_steps.index(i) + 2)\n",
        "                plt.title('Pixels deleted {:.1f}%, P={:.4f}'.format(100 * i / n_steps, img_scores[i]), fontsize=14)\n",
        "                plt.axis('off')\n",
        "                plt.imshow(img)\n",
        "\n",
        "            if i < n_steps:\n",
        "                # img = img.reshape(1, HW, CH)\n",
        "                # coords = salient_order[:, step * i:step * (i + 1)]\n",
        "                # img[:,coords,:] = 0\n",
        "                # img = img.reshape(SIZE, SIZE, CH)\n",
        "                coords = salient_order[:, step * i:step * (i + 1)]\n",
        "                img.reshape(1, HW, CH)[:,coords,:] = 0\n",
        "\n",
        "        score = auc(img_scores)\n",
        "\n",
        "        if pind in print_inds:\n",
        "            plt.subplot(1, print_img_count, print_img_count)\n",
        "            plt.xlim(-0.1, 1.1)\n",
        "            plt.ylim(0, 1.05)\n",
        "            plt.fill_between(np.arange(n_steps+1) / n_steps, 0, img_scores, alpha=0.4)\n",
        "            plt.title(f\"Score: {round(score, 4)}\", fontsize=14)\n",
        "            plt.xlabel(\"Pixels deleted\", fontsize=14)\n",
        "            plt.ylabel(\"Prediction score\", fontsize=14)\n",
        "\n",
        "        scores.append(score)\n",
        "\n",
        "    return scores\n",
        "\n",
        "\n",
        "def calculate_stability(images, explanations, n=5, print_every=1):\n",
        "    num_images = len(images)\n",
        "    images_as_float = [img_as_float(img) for img in images]\n",
        "    distances = np.zeros((num_images, num_images))\n",
        "    for i in range(num_images):\n",
        "        for j in range(i, num_images):\n",
        "            distances[i,j] = dist(images_as_float[i], images_as_float[j])\n",
        "            distances[j,i] = distances[i,j]\n",
        "\n",
        "    print_img_size = 2  #inches\n",
        "    print_img_count = n * 2 + 2\n",
        "    print_inds = list(range(0, len(images), print_every)) if print_every else []\n",
        "\n",
        "    score = []\n",
        "    for i, (image, image_float, explanation) in tqdm(enumerate(zip(images, images_as_float, explanations))):\n",
        "        top_n_similar_images_idx = np.argsort(distances[i])[1:n+1]\n",
        "        top_n_similar_images = [images[ix] for ix in top_n_similar_images_idx]\n",
        "        top_n_similar_images_float = [images_as_float[ix] for ix in top_n_similar_images_idx]\n",
        "        top_n_similar_explanations = [explanations[ix] for ix in top_n_similar_images_idx]\n",
        "\n",
        "        if i in print_inds:\n",
        "            print(i)\n",
        "            plt.figure(figsize=(print_img_size * print_img_count, print_img_size))\n",
        "\n",
        "            plt.subplot(1, print_img_count, 1)\n",
        "            plt.axis('off')\n",
        "            # plt.title('Original image')\n",
        "            plt.imshow(image)\n",
        "            plt.subplot(1, print_img_count, 2)\n",
        "            # plt.title('Original explanation')\n",
        "            plt.axis('off')\n",
        "            plt.imshow(explanation)\n",
        "\n",
        "        l_score = []\n",
        "        for j, (s_i, s_i_f, s_e) in enumerate(zip(top_n_similar_images, top_n_similar_images_float, top_n_similar_explanations)):\n",
        "            if i in print_inds:\n",
        "                plt.subplot(1, print_img_count, 3+j*2)\n",
        "                plt.axis('off')\n",
        "                plt.imshow(s_i)\n",
        "                plt.subplot(1, print_img_count, 4+j*2)\n",
        "                plt.axis('off')\n",
        "                plt.imshow(s_e)\n",
        "\n",
        "            exp_diff = explanation - s_e\n",
        "            exp_diff_norm = np.linalg.norm(exp_diff)\n",
        "            im_diff = image_float - s_i_f\n",
        "            im_diff_norm = np.linalg.norm(im_diff)\n",
        "            s = exp_diff_norm / im_diff_norm\n",
        "            l_score.append(s)\n",
        "\n",
        "        score.append(max(l_score))\n",
        "\n",
        "    return score\n",
        "\n",
        "\n",
        "def calculate_stability_v2(images, explanations, explain_func):\n",
        "    noise_technique = (\"gaussian\", \"poisson\", \"speckle\", \"s&p\")\n",
        "    noise_technique = (\"gaussian\", \"gaussian\", \"gaussian\", \"gaussian\", \"gaussian\")\n",
        "    n = len(noise_technique)\n",
        "    score = []\n",
        "    for image, explanation in zip(images, explanations):\n",
        "        image = img_as_float(image)\n",
        "        noisy_images = [random_noise(image, nt).astype(np.float32) for nt in noise_technique]\n",
        "        noisy_explanations = [explain_func(ni) for ni in noisy_images]\n",
        "\n",
        "        plt.figure(figsize=(15, 15))\n",
        "\n",
        "        plt.subplot(1, 2 + 2*n, 1)\n",
        "        plt.axis('off')\n",
        "        plt.imshow(image)\n",
        "        plt.subplot(1, 2 + 2*n, 2)\n",
        "        plt.axis('off')\n",
        "        plt.imshow(explanation)\n",
        "\n",
        "        l_score = []\n",
        "        for j, (s_i, s_e) in enumerate(zip(noisy_images, noisy_explanations)):\n",
        "            plt.subplot(1, 2 + 2*n, 3+j*2)\n",
        "            plt.axis('off')\n",
        "            plt.imshow(s_i)\n",
        "            plt.subplot(1, 2 + 2*n, 4+j*2)\n",
        "            plt.axis('off')\n",
        "            plt.imshow(s_e)\n",
        "\n",
        "            exp_diff = explanation - s_e\n",
        "            exp_diff_norm = np.linalg.norm(exp_diff)\n",
        "            im_diff = img_as_float(image) - img_as_float(s_i)\n",
        "            im_diff_norm = np.linalg.norm(im_diff)\n",
        "            s = exp_diff_norm / im_diff_norm\n",
        "            l_score.append(s)\n",
        "\n",
        "        score.append(max(l_score))\n",
        "\n",
        "    return score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9SEV4h_0bwy0"
      },
      "source": [
        "# Explainers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1roGYewQhMCl"
      },
      "outputs": [],
      "source": [
        "class ExplainerAdapter(object):\n",
        "    def __init__(self, model, target_layers, preprocess_transform, img_size, img_channels):\n",
        "        self.model = model\n",
        "        self.target_layers = target_layers\n",
        "        self.preprocess_transform = preprocess_transform\n",
        "        self.batch_predict = get_batch_predict(model, preprocess_transform)\n",
        "\n",
        "        self.img_size = img_size\n",
        "        self.img_channels = img_channels\n",
        "\n",
        "        self.explainer = self.init_explainer()\n",
        "\n",
        "    def init_explainer(self):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def pre_explain(self):\n",
        "        pass\n",
        "\n",
        "    def get_extra_from_image(self, image):\n",
        "        return {}\n",
        "\n",
        "    def get_input_from_image(self, image):\n",
        "        return image\n",
        "\n",
        "    def explain(self, input, **kwargs):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def postprocess_explanation(self, explanation):\n",
        "        raise NotImplementedError\n",
        "\n",
        "    def timed_single_explain(self, image):\n",
        "        self.pre_explain()\n",
        "\n",
        "        input = self.get_input_from_image(image)\n",
        "        extra = self.get_extra_from_image(image)\n",
        "\n",
        "        t = time.time()\n",
        "        exp = self.explain(input, **extra)\n",
        "        t = time.time() - t\n",
        "\n",
        "        return self.postprocess_explanation(exp), t\n",
        "\n",
        "    def timed_batch_explain(self, images):\n",
        "        exps = []\n",
        "        times = []\n",
        "\n",
        "        for image in tqdm(images):\n",
        "            exp, t = self.timed_single_explain(image)\n",
        "            exps.append(exp)\n",
        "            times.append(t)\n",
        "\n",
        "        return np.array(exps), np.mean(times)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SH_X0RhlhrE-"
      },
      "source": [
        "### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CphpZcpkGb18"
      },
      "outputs": [],
      "source": [
        "from lime.lime_image import LimeImageExplainer\n",
        "from lime.wrappers.scikit_image import SegmentationAlgorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Db3pOnzqjDHn"
      },
      "outputs": [],
      "source": [
        "class LimeExplainerAdapter(ExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return LimeImageExplainer()\n",
        "\n",
        "    def get_input_from_image(self, image):\n",
        "        return np.array(image)\n",
        "\n",
        "    def explain(self, input):\n",
        "        return self.explainer.explain_instance(\n",
        "            input,\n",
        "            self.batch_predict, # classification function\n",
        "            top_labels=5,\n",
        "            # hide_color=0,\n",
        "            num_samples=1000,\n",
        "            # segmentation_fn=SegmentationAlgorithm(\n",
        "            #     'quickshift', kernel_size=1, max_dist=16, ratio=0.2, random_seed=1\n",
        "            # )\n",
        "            progress_bar=False,\n",
        "        )\n",
        "\n",
        "    def postprocess_explanation(self, exp):\n",
        "        exp = exp.get_image_and_mask(\n",
        "            exp.top_labels[0],\n",
        "            positive_only=True,\n",
        "            num_features=5,\n",
        "            hide_rest=True\n",
        "        )[1]\n",
        "        exp = minmax_scale(exp)\n",
        "        return exp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WPI3yYNGct7v"
      },
      "source": [
        "#### Old"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qNboypXuhszW"
      },
      "outputs": [],
      "source": [
        "# def bulk_exp(explainer, images):\n",
        "#     return [\n",
        "#         explainer.explain_instance(\n",
        "#           np.array(image),\n",
        "#           batch_predict, # classification function\n",
        "#           top_labels=5,\n",
        "#           hide_color=0,\n",
        "#           num_samples=1000,\n",
        "#           segmentation_fn=SegmentationAlgorithm('quickshift', kernel_size=1, max_dist=16, ratio=0.2, random_seed=1)\n",
        "#         )\n",
        "#         for image in images\n",
        "#     ]\n",
        "\n",
        "\n",
        "# def get_imgs_from_exps(exps):\n",
        "#     return np.array(\n",
        "#         [\n",
        "#             exp.get_image_and_mask(\n",
        "#                 exp.top_labels[0],\n",
        "#                 positive_only=True,\n",
        "#                 num_features=5,\n",
        "#                 hide_rest=True\n",
        "#             )[1]\n",
        "#             for exp in exps\n",
        "#         ]\n",
        "#     )\n",
        "#\n",
        "\n",
        "# explainer = LimeImageExplainer()\n",
        "\n",
        "# exps = get_imgs_from_exps(bulk_exp(explainer, sample_images))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xLYFeQIiKq-T"
      },
      "source": [
        "### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8T2WkYKgMZim"
      },
      "outputs": [],
      "source": [
        "import shap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7HWWpH4bjzmN"
      },
      "outputs": [],
      "source": [
        "class ShapExplainerAdapter(ExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return shap.Explainer(\n",
        "            self.batch_predict,\n",
        "            shap.maskers.Image(\n",
        "                f\"blur({self.img_size},{self.img_size})\",\n",
        "                (self.img_size, self.img_size, self.img_channels)\n",
        "            )\n",
        "        )\n",
        "\n",
        "    def get_input_from_image(self, image):\n",
        "        return np.array([image])\n",
        "\n",
        "    def explain(self, input):\n",
        "        return self.explainer(input, outputs=shap.Explanation.argsort.flip[:1], silent=True)\n",
        "\n",
        "    def postprocess_explanation(self, exp):\n",
        "        exp = exp[0][:,:,:,0].values\n",
        "        exp = np.mean(exp, axis=2)\n",
        "        exp[exp < 0] = 0\n",
        "        exp = minmax_scale(exp)\n",
        "        return exp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gIxPiVL4crMx"
      },
      "source": [
        "#### Old"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "13T7h2vzAjHy"
      },
      "outputs": [],
      "source": [
        "# def bulk_exp(explainer, images):\n",
        "#     return explainer(\n",
        "#         np.array(images),\n",
        "#         outputs=shap.Explanation.argsort.flip[:1],\n",
        "#     )\n",
        "\n",
        "\n",
        "# def get_imgs_from_exps(exps):\n",
        "#     def norm(arr):\n",
        "#         return np.mean((arr - np.min(arr)) / (np.max(arr) - np.min(arr)), axis=2)\n",
        "\n",
        "#     return np.array([norm(x[:,:,:,0].values) for x in exps[:]])\n",
        "\n",
        "# explainer = shap.Explainer(\n",
        "#     batch_predict,\n",
        "#     shap.maskers.Image(f\"blur({SIZE},{SIZE})\", (SIZE, SIZE, CH))\n",
        "# )\n",
        "\n",
        "# exps = get_imgs_from_exps(bulk_exp(explainer, imgs))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SMtU78Zb8ba6"
      },
      "source": [
        "### GradCam/GradCam++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5uVSPEU4LrG0"
      },
      "outputs": [],
      "source": [
        "from pytorch_grad_cam import GradCAMPlusPlus, GradCAM, FullGrad, EigenCAM, EigenGradCAM, AblationCAM, ScoreCAM, HiResCAM\n",
        "from pytorch_grad_cam.utils.image import show_cam_on_image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xYclImMwz8AL"
      },
      "outputs": [],
      "source": [
        "class GradExplainerAdapter(ExplainerAdapter):\n",
        "    def pre_explain(self):\n",
        "        self.model.eval()\n",
        "        self.model.to(device)\n",
        "\n",
        "    def get_input_from_image(self, image):\n",
        "        input = self.preprocess_transform(image).unsqueeze(0).to(device)\n",
        "        input.requires_grad = True\n",
        "        return input\n",
        "\n",
        "    def postprocess_explanation(self, exp):\n",
        "        return exp[0]\n",
        "\n",
        "class CAMExplainerAdapter(GradExplainerAdapter):\n",
        "    def explain(self, input):\n",
        "        return self.explainer(input_tensor=input)\n",
        "\n",
        "\n",
        "class GradCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return GradCAM(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class GradCAMPlusPlusExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return GradCAMPlusPlus(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class AblationCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return AblationCAM(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class ScoreCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return ScoreCAM(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class EigenCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return EigenCAM(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class EigenGradCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return EigenGradCAM(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class FullGradExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return FullGrad(model=self.model, target_layers=self.target_layers)\n",
        "\n",
        "\n",
        "class HiResCAMExplainerAdapter(CAMExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return HiResCAM(model=self.model, target_layers=self.target_layers)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDJXITQbcoqP"
      },
      "source": [
        "#### Old"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b5jTjgbfr16p"
      },
      "outputs": [],
      "source": [
        "# def bulk_exp(explainer, images):\n",
        "#     return explainer(\n",
        "#         input_tensor=torch.stack(\n",
        "#             tuple(preprocess_transform(i) for i in images),\n",
        "#             dim=0,\n",
        "#         ),\n",
        "#     )\n",
        "\n",
        "\n",
        "# def get_imgs_from_exps(exps):\n",
        "#     return exps\n",
        "\n",
        "# explainer = GradCAM(model=self.model, target_layers=self.model.layer4[-1:])\n",
        "\n",
        "# exps = get_imgs_from_exps(bulk_exp(explainer, imgs))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yz8SjU5Txex"
      },
      "source": [
        "### Intgrad, SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lrPnKAUNbiJj"
      },
      "outputs": [],
      "source": [
        "from captum.attr import IntegratedGradients, NoiseTunnel"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T9BTxs2k2QTf"
      },
      "outputs": [],
      "source": [
        "class IntGradExplainerAdapter(GradExplainerAdapter):\n",
        "    def pre_explain(self):\n",
        "        super().pre_explain()\n",
        "        # self.model.zero_grad()\n",
        "\n",
        "    def init_explainer(self):\n",
        "        return IntegratedGradients(self.model)\n",
        "\n",
        "    def get_extra_from_image(self, image):\n",
        "        return {\"target\": int(np.argmax(self.batch_predict([image]), axis=1)[0])}\n",
        "\n",
        "    def postprocess_explanation(self, exp):\n",
        "        exp = exp.squeeze(0).cpu().detach().numpy()\n",
        "        exp = np.transpose(exp, (1, 2, 0))\n",
        "        exp = np.mean(exp, axis=2)\n",
        "        exp[exp < 0] = 0\n",
        "        exp = minmax_scale(exp)\n",
        "        return exp\n",
        "\n",
        "    def explain(self, input, **kwargs):\n",
        "        return self.explainer.attribute(\n",
        "            inputs=input,\n",
        "            baselines=input * 0,\n",
        "            target=kwargs[\"target\"],\n",
        "            return_convergence_delta=False,\n",
        "        )\n",
        "\n",
        "\n",
        "class SmoothGradExplainerAdapter(IntGradExplainerAdapter):\n",
        "    def init_explainer(self):\n",
        "        return NoiseTunnel(super().init_explainer())\n",
        "\n",
        "    def explain(self, input, **kwargs):\n",
        "        return self.explainer.attribute(\n",
        "            inputs=input,\n",
        "            nt_type='smoothgrad',\n",
        "            stdevs=0.2,\n",
        "            nt_samples_batch_size=1,\n",
        "            baselines=input * 0,\n",
        "            target=kwargs[\"target\"],\n",
        "            return_convergence_delta=False,\n",
        "            # internal_batch_size=1,\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "naUi-BqUclbx"
      },
      "source": [
        "#### Old"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jT75weLLGSRc"
      },
      "outputs": [],
      "source": [
        "# def bulk_exp(explainer, images, predictions):\n",
        "#     # process one image at a time to avoid running out of memory\n",
        "#     exps = []\n",
        "#     model.zero_grad()\n",
        "#     for image, prediction in zip(images, predictions):\n",
        "#         input = preprocess_transform(image).unsqueeze(0).to(device)\n",
        "#         input.requires_grad = True\n",
        "#         exps.append(\n",
        "#             explainer.attribute(\n",
        "#                 inputs=input,\n",
        "#                 nt_type='smoothgrad',\n",
        "#                 stdevs=0.2,\n",
        "#                 nt_samples_batch_size=1,\n",
        "#                 baselines=input * 0,\n",
        "#                 target=int(prediction),\n",
        "#                 return_convergence_delta=False,\n",
        "#                 internal_batch_size=1,\n",
        "#             ).squeeze(0).cpu().detach().numpy()\n",
        "#         )\n",
        "#     return np.array(exps)\n",
        "\n",
        "\n",
        "# def get_imgs_from_exps(exps):\n",
        "#     def norm(arr):\n",
        "#         return np.mean((arr - np.min(arr)) / (np.max(arr) - np.min(arr)), axis=2)\n",
        "\n",
        "#     exps = np.transpose(exps, (0, 2, 3, 1))\n",
        "#     return np.array([norm(x) for x in exps])\n",
        "\n",
        "\n",
        "# model.to(device)\n",
        "# model.eval()\n",
        "# explainer = NoiseTunnel(IntegratedGradients(model))\n",
        "\n",
        "\n",
        "# exps = get_imgs_from_exps(bulk_exp(explainer, imgs, preds))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n0eUcARpXzgY"
      },
      "source": [
        "# Experiments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RP5XlUKk9BPB"
      },
      "outputs": [],
      "source": [
        "# def evaluate_explainer(expr_name):\n",
        "#     expr_class = {\n",
        "#         \"LIME\": LimeExplainerAdapter,\n",
        "#         \"SHAP\": ShapExplainerAdapter,\n",
        "#         \"GradCAM\": GradCAMExplainerAdapter,\n",
        "#         \"GradCAM++\": GradCAMPlusPlusExplainerAdapter,\n",
        "#         \"IntGrad\": IntGradExplainerAdapter,\n",
        "#         \"SmoothGrad\": SmoothGradExplainerAdapter,\n",
        "#     }[expr_name]\n",
        "#     print(f\"Starting for {expr_name}, {model.pretrained_cfg['architecture']}\")\n",
        "\n",
        "#     expr = expr_class(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "\n",
        "#     exps, t = expr.timed_batch_explain(imgs)\n",
        "#     exps_, t = expr.timed_batch_explain(imgs)\n",
        "#     print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "\n",
        "#     nrow, ncol = 2, 10\n",
        "#     plt.figure()\n",
        "#     _, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "#     for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "#         axarr[0, ix].imshow(imgs[i])\n",
        "#         axarr[0, ix].axis(False)\n",
        "#         axarr[1, ix].imshow(exps[i])\n",
        "#         axarr[1, ix].axis(False)\n",
        "\n",
        "#     scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "#     print(f\"Fidelity score: {np.mean(scores)}\")\n",
        "\n",
        "#     scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "#     print(f\"Stability score: {np.mean(scores)}\")\n",
        "\n",
        "#     score, _, _ = calculate_identity(exps, exps_)\n",
        "#     print(f\"Identity score: {score}\")\n",
        "\n",
        "#     _, _, _, score = calculate_separability(exps)\n",
        "#     print(f\"Separability score: {score}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CA3S2ItoJPLa"
      },
      "outputs": [],
      "source": [
        "def show_imgs_exps(imgs, exps, print_every_n):\n",
        "    nrow, ncol = 2, 10\n",
        "    plt.figure()\n",
        "    _, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "    for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "        axarr[0, ix].imshow(imgs[i])\n",
        "        axarr[0, ix].axis(False)\n",
        "        axarr[1, ix].imshow(exps[i])\n",
        "        axarr[1, ix].axis(False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qm_g1hBKs0jl"
      },
      "source": [
        "## CIFAR10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YVfEOx27-UZp",
        "outputId": "bf362339-3da8-48cb-8f57-88393b3b9aa1"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(\"cifar10\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tg3ffdWXIumV"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=100)\n",
        "imgs = sample_images\n",
        "print_every_n = int(len(imgs) / 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "37ayn2gPs8Bj"
      },
      "source": [
        "### VGG16_BN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3nC8ad2z-bO3",
        "outputId": "f1816cab-60fc-4ee8-b51d-4297e5faad8e"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"vgg16_bn\", \"cifar10\")\n",
        "preprocess_transform = get_preprocess_transform(\"cifar10\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k55FioNiez0W"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Reh_Cx1_PJRx"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wGUMyZ3XVdNY",
        "outputId": "50effeed-b848-4902-ba96-2749668a009f"
      },
      "outputs": [],
      "source": [
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "38KE1vANAT-r",
        "outputId": "f6af60fd-39c9-4c6e-a977-dded0e2e2c1d"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "7gOUdCyetela",
        "outputId": "213848da-e01b-4c3e-f00c-6a42dbf5871f"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "sTlcBzuOtelg",
        "outputId": "e955532b-bd4c-47ff-a349-5aafc78f2db2"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e30uv9z95jSw",
        "outputId": "b8627d72-7b3b-4ae4-b5d8-6b1514da5902"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "1diPY53CXSn_",
        "outputId": "7896f169-bcf1-48ac-fc2a-6440076a8fc4"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 2, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(100, 110)):\n",
        "    axarr[0, ix].imshow(exps[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps_[i])\n",
        "    axarr[1, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_M7BT_PS5jSw",
        "outputId": "2ca70a7d-cdd0-49a7-a37b-f4f9ce37d459"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aoasIecLN3DV"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F1azSEbis3Bn",
        "outputId": "d6a57cd9-81ec-4d57-b10b-18023eafa4ed"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "3didf__VAWWv",
        "outputId": "e51f4d6c-3621-48eb-bf66-7ba09dc52ef6"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Ln-EAp0yDFed",
        "outputId": "e05d9111-7939-4457-8357-0a851cbed690"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "-Ft30Ecd1soS",
        "outputId": "fff09770-5b82-4d8d-cd41-baa5be7a9ef4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gALr9ejQ5g6V",
        "outputId": "db4b4a54-e25a-4f5d-88cf-8d4e243272df"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7krhr1mu5g6V",
        "outputId": "1c37ec4e-ff0e-4902-943d-d75363888877"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gBx1LUbhN5Ob"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uuQJE2M8O3CH",
        "outputId": "42659ecc-7cc2-494d-9790-e8c49e2815f9"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "z-qUlt-4AYh9",
        "outputId": "f0e8391a-5925-4497-a599-507ce60064b5"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "nK2HrWAZyp-c",
        "outputId": "dba33ff5-8800-4dce-e915-45304c272573"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "nrwwZFr1yp-d",
        "outputId": "22e10122-731f-4085-b91e-2b04bb685da4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S96YjfPQyp-d",
        "outputId": "056c239e-3e04-498e-e2c0-c9b7a3c1cb43"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fB_-69Hoyrte",
        "outputId": "fdfe93cc-a9d1-4b07-80c1-ddecb14e8fcf"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iaEpsIYPN84P"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmYFQgOD4Dvh",
        "outputId": "859813be-7f6a-48c8-8968-ea0949517183"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, [model.features[-2]], preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "IrLYo2Rp4Fb3",
        "outputId": "0428ffa8-6b2e-4aa9-be39-b5ff90016a3d"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "k3DH-jaq5wFx",
        "outputId": "43b98130-5f86-4b34-bdfd-d9c3dd81a3e0"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "bD-HX0pI5wFx",
        "outputId": "4ee3b507-59a5-4f4f-a349-de476a378c1e"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4EayZEPW5wFx",
        "outputId": "929ce135-c633-49a5-b180-dff7e4e33b05"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LVVomNXb5wFx",
        "outputId": "4bf63234-1e46-405a-fd07-4c2863d0cb7e"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cn-mAztCOASM"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RaFjXsZPp_lp",
        "outputId": "857b1a7c-30d6-4cbd-d22e-38cdbf8f8cd9"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "cDNxALU1qSoF",
        "outputId": "d5cd6514-428b-4bc7-9224-9f8e35c46f22"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "52c8A5rO5wpC",
        "outputId": "3973e787-165e-4fc9-b231-60ff3336f2b1"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "ExUcZ97V5wpD",
        "outputId": "fd0c3141-3c06-4ec9-c1da-f0858ad777c4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JkhvsDwg5wpD",
        "outputId": "cb21ee20-5632-464c-fd9b-8b0dc4a14590"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GaZdqd4O5wpD",
        "outputId": "1bc01d9b-d3fb-4d01-a123-b30736eb6fe8"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3lIFUDl9qbCo"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aE8KsMpqqdUK",
        "outputId": "f992541c-3926-4f1a-e490-495a7cf89735"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "p6mI_LXvAddt",
        "outputId": "d2f7b7a1-354f-4d84-bd02-79ff1e89ee98"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "KvLXG_lb5yRr",
        "outputId": "c6893a68-4245-489c-90ad-2d8870b05a17"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "u8xtNN5L5yRw",
        "outputId": "5df610e9-94b8-492c-93ab-84965496c98f"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AZ8J3cyU5yRw",
        "outputId": "be43f258-dd0e-4093-8838-20476a75e618"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4IeXeitb5yRw",
        "outputId": "d5c06a78-5575-487d-901e-26194cb0bc10"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JIe-ln2zi4RC"
      },
      "source": [
        "### Resnet50"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6GZF6r_Ni4RI"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", \"cifar10\")\n",
        "preprocess_transform = get_preprocess_transform(\"cifar10\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3X03Nc4i4RI"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ixcsh1RBi4RI"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LnZrkL4byOcj"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Xr_CsVRyPVf"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fASU3lCi4RI",
        "outputId": "5e864438-8a01-4c75-e03a-decc01f276a3"
      },
      "outputs": [],
      "source": [
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "SB2FoooWi4RI",
        "outputId": "ff241b17-5ac6-4415-fe21-9a5664183448"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "DQnOb2tYi4RI",
        "outputId": "c06eda20-7ce0-4ca5-9bf2-2a3ceaa25b33"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "uAy8wJV_i4RI",
        "outputId": "308524ed-491c-4ffb-ddf6-1c0242cbce47"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H_6CcHjYi4RI",
        "outputId": "f567b72b-907b-4b63-c8cc-b7d7afa6427b"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eG4OvknYi4RI",
        "outputId": "991779da-a3a4-4a13-b01d-264319b1b5a6"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MTPxthNti4RI"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NusleA7Li4RI",
        "outputId": "171d55bd-ee4f-4097-b236-45597caf62fb"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "dVauB2Pni4RI",
        "outputId": "92aa046e-b012-4402-89c6-3cfc8b6c030e"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "np44TJF4i4RI",
        "outputId": "70a7c5eb-83ac-496d-e90e-24b97d49dcf4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "n2_ccyB1i4RI",
        "outputId": "6fdf8264-f901-4ee5-cdd2-9d1da700a5ae"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0wcIYYsni4RI",
        "outputId": "cd7f4074-d53d-4403-85ae-9fed89197566"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8b-ML1uzi4RI",
        "outputId": "46195332-26db-493e-eb60-cf454711f30a"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQa9Nx5ui4RI"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QaF7K1yYi4RJ",
        "outputId": "46f26031-2fa9-4aa7-ed48-31aa5930bc66"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "CR_y94qni4RJ",
        "outputId": "c4f42223-e87a-4f95-d4f2-58a574c09142"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "o0r1m8Uni4RJ",
        "outputId": "e53de1de-01bf-4206-8cec-88f7e21425ba"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "gyxwcnQOi4RJ",
        "outputId": "af33d4be-0f66-4fde-9b30-9b739ded2d23"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HUu0aX-Mi4RJ",
        "outputId": "26c86964-349a-4f94-b33d-cc2c6064173e"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rJ1NwEpui4RJ",
        "outputId": "92d2ccfc-ee04-4ec4-e202-ae3ce586dbc1"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d2uOR-Smi4RJ"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hITITVQ1i4RJ",
        "outputId": "5b4f9f09-e3ae-464f-f2e3-dfa3da1bcb9b"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "wXQSmsFKi4RJ",
        "outputId": "520271f5-8897-4c54-b7d4-9efd9a83980c"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "5ItPrlbyi4RJ",
        "outputId": "4d600e43-335e-4a26-dd87-99ec1d992f7c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "x8jZVsQSi4RJ",
        "outputId": "d009900c-c78b-4a4b-a06f-1ebd7bf4f6e6"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e7c-y165i4RJ",
        "outputId": "37731a56-a8bc-4dcc-c3e0-5da95299249b"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hvsFJzlSi4RJ",
        "outputId": "d765923d-b387-4216-d6b6-c25dcbbdd7e0"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3eqTGUkyi4RJ"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-XKop8iIi4RJ",
        "outputId": "825083d0-8a23-4cc0-ccbf-50ad0d907944"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "KaPqLvhDi4RJ",
        "outputId": "47b9daba-48ce-48e7-f796-40b8c0aaeed9"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "i-ozOKYai4RJ",
        "outputId": "1e5164e4-df15-4786-ce09-b75b6e7b0ec3"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Nc72Bg61i4RJ",
        "outputId": "63198db3-c2cf-4fc5-d283-c7f5b75d4949"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FcTX_KPki4RJ",
        "outputId": "ab3ef728-7d27-45b9-ab51-69f69e79f045"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Jcez9UVi4RJ",
        "outputId": "6ad7097f-3baa-4428-febf-38dfa4d68746"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M3E_yutoi4RJ"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ID5wrUlOi4RK",
        "outputId": "d8bd73d7-812c-45b7-d8fb-de8802e80a83"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "GbL9yhzSi4RK",
        "outputId": "db387ba0-6ae7-4dc5-c231-a7efb38932d8"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "v3Teo0yki4RK",
        "outputId": "22f849b6-d577-4c40-a14d-fb47068f5f76"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "l7ytr5XQi4RK",
        "outputId": "834b2966-008d-474c-89e7-3d9e3148bedb"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lf4g-3GAi4RK",
        "outputId": "516547be-c66c-4bec-aef8-a9fa08c8bb29"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u3hEkkHai4RK",
        "outputId": "368a9676-3f26-4ba5-d734-913a8975a16c"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7Ij6o0_i4oL"
      },
      "source": [
        "### Densenet121"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Utb5oEBCi4oS",
        "outputId": "01003243-db12-462a-ff2f-77706fe72df3"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"densenet121\", \"cifar10\")\n",
        "preprocess_transform = get_preprocess_transform(\"cifar10\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFClswS6i4oS"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oD1oZBepi4oS"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NSXY-p42i4oS"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GQ6hRonfaQzk",
        "outputId": "0aeb2cab-7a43-484e-8a16-2f5db3d975f4"
      },
      "outputs": [],
      "source": [
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iFP4tGo2i4oS"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pZvLJImDi4oS",
        "outputId": "9cef920a-9f96-4184-e3db-0fe7af99403e"
      },
      "outputs": [],
      "source": [
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "kNegOBDYi4oS",
        "outputId": "74c7759a-e719-4034-d040-128d2fb6f3b9"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "FyJR8F3Vi4oS",
        "outputId": "b47e7801-4ac2-405b-bf12-3441a630b0ca"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "4_-lRL5Xi4oS",
        "outputId": "ecb74446-138d-407c-e5ad-c402ebadd822"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pL7IaQBPi4oT",
        "outputId": "ce7c570a-c307-4f82-b50a-a6c2f3a4bc77"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQIAHwtPi4oT",
        "outputId": "53d8c2df-8c78-4f5a-d8ea-d92b9c6f9329"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6T7EGv7Xi4oT"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D4RwAOl1i4oT",
        "outputId": "a4175a7c-43de-4880-db71-40745eb7b4d0"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "uUpRVdNdi4oT",
        "outputId": "6696c2af-0cd7-4fc6-dae7-573fe2fe2aa8"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "cujwIpE4i4oT",
        "outputId": "f31bb8f5-c3ae-46ee-cd00-500b0a664be0"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "uoB5UDxRi4oT",
        "outputId": "adc4d8fb-f843-402b-b46a-ac3d72a2b09b"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4BfCJLIfi4oT",
        "outputId": "35f2cc4c-7aa6-46ba-87ff-33cc39a247ed"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MErruF1vi4oT",
        "outputId": "3f3d3607-2ec3-4d83-fa9f-b875c76d5364"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vP3LT4dFi4oT"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V6GSXBBui4oT",
        "outputId": "218d755d-2f5b-421d-8b69-a8b296ba2593"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "N8U6TpAWi4oT",
        "outputId": "0040731e-cfe0-4d19-a968-e100e276313a"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "MIfQrE8ti4oT",
        "outputId": "e09777e7-d1f6-4d2c-96e3-53238b17a496"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "MOXH3EoGi4oT",
        "outputId": "35ab1d0e-d6a1-43f9-bedc-e7251ef6e995"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i4QIpF9zi4oT",
        "outputId": "248e8551-99e2-4682-df57-65fcfdfcec66"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r9fx8-SEi4oT",
        "outputId": "a89258b6-a201-4d84-f5b1-395a68ded274"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlmDZZQ9i4oT"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0wMjNNtxi4oU",
        "outputId": "97ad78ec-ba0e-493f-eb21-2fdd1b9cb5ad"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "1FxJw0-Vi4oU",
        "outputId": "aa7e3d4f-b030-4aed-bb29-78fd87178d91"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Cwc21ZYyi4oU",
        "outputId": "44742e28-a618-4c4f-fea1-12d639d44325"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "UGEY1zq7i4oU",
        "outputId": "738b3e42-a80a-41b7-df35-36357da081c3"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QRVnDGK-i4oU",
        "outputId": "cc443f13-28aa-48ef-ebde-dafc7096936f"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uHtb3Xsli4oU",
        "outputId": "c1cc9063-013f-4e95-8e01-ed7b05bc9735"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QxRxSVuki4oU"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CG1RP1t4i4oV",
        "outputId": "855dad0c-ffb4-4a7a-85bb-84c2b2b4c70a"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "2JIG1bw6i4oV",
        "outputId": "49bc3c55-3045-4af0-fad0-e09bb1986b9a"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "b1H05nywi4oW",
        "outputId": "65e6c7d0-9eba-4067-855e-c4423472d37d"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "7zMtDpOoi4oW",
        "outputId": "ffa3c775-7706-459a-b629-1aaf0de7e033"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mU6H0_4ti4oW",
        "outputId": "a9c54914-0679-4d5f-a13c-ebca51bf457c"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R1zH4Moui4oW",
        "outputId": "d92eb370-d090-426c-a3c6-f060472e8552"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6GBX9-byi4oW"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WCG19bKui4oW",
        "outputId": "c62078f9-a14a-4420-c55b-90bcf68c0005"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "EYlVvsDhi4oW",
        "outputId": "73948934-007f-4847-9b48-4900b6577811"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "FHhEPfwai4oW",
        "outputId": "e41588d1-04db-4a59-acb6-ea82b0b39459"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "LbFISO7wi4oW",
        "outputId": "b6c668be-fa34-49ad-e860-0135ff02334a"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FiAWQjtSi4oW",
        "outputId": "f770b032-2e98-4919-8602-b6f592179aae"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IaFx4aAXi4oW",
        "outputId": "c997132e-323c-488e-df24-5973c5f40035"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QQ8WXXeXj04U"
      },
      "source": [
        "## SVHN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oj2l0OPCj04a",
        "outputId": "f835d51c-f960-403c-cb3f-f95cec611ac2"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(\"svhn\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wwORkZX7j04a"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=100)\n",
        "imgs = sample_images\n",
        "print_every_n = int(len(imgs) / 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D8yTBAX3j04a"
      },
      "source": [
        "### VGG16_BN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tMS_OIc8j04a",
        "outputId": "da102270-ca8b-466e-e941-77f6627b1175"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"vgg16_bn\", \"svhn\")\n",
        "preprocess_transform = get_preprocess_transform(\"svhn\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NIhmK5wij04a"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "94gHIRzjkgeL"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AHqGuwrzklwK",
        "outputId": "f9744a9b-2c4a-43fe-abe6-283883cde6d8"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gblzK9frj04b",
        "outputId": "3e9a37a4-83c8-429a-bd12-5abbb061e61f"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "umgInTeuj04b",
        "outputId": "9c07ebf4-f1bf-4908-a655-98f0b4c50f3b"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "JNQLzTF4j04b",
        "outputId": "4de8ae2f-e4cf-41c3-e5d1-424bd5267262"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "aIZKHif-j04b",
        "outputId": "0a524f92-d2a5-4f3d-d6a8-ae58e65683dc"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JmV74q0yj04b",
        "outputId": "9d2dee84-d720-4973-bf67-b49c311bada8"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "piXp-yURj04b",
        "outputId": "70c78c0d-e00a-408a-9e1f-e27b5ca51882"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 2, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(100, 110)):\n",
        "    axarr[0, ix].imshow(exps[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps_[i])\n",
        "    axarr[1, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bCFKfiUaj04b",
        "outputId": "81ad0f78-7ff6-4d92-9028-9bf197a3017a"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XIQDtiF4j04b"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AfkyA-8Uj04b",
        "outputId": "a74d3db0-441b-4153-c21b-7f343e133df7"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "m8s9XbPVj04b",
        "outputId": "d2099b4f-0ce3-4e9e-af89-17314ae2afe3"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "kiUevwkmj04c",
        "outputId": "e2e6d20b-b710-4c70-c9de-89462c7447ea"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "m2q5pSPdj04c",
        "outputId": "b6a452f7-7ab6-46d5-a17a-4d23608e0730"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uVr6Q7J5j04c",
        "outputId": "7cb32b50-01e9-49bc-beb2-a1589f46cf47"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0YRiE5qcj04c",
        "outputId": "846a8d47-392d-44f4-c15b-8d1a9ea15c81"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_T2DZZhpj04c"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xzSHOkE7j04c",
        "outputId": "ad3e6cab-ba4d-46ee-b387-6ca6fc2d8cef"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "XiILa9Jnj04c",
        "outputId": "908de8f0-8c68-43e0-9856-7e65b990648f"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "QgMtvNl2j04c",
        "outputId": "42d91bcb-a3bd-4b43-9c59-b63597f32d74"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "xzMDbOX8j04c",
        "outputId": "a605380b-df33-4e2e-81b8-c30eafb64964"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L07ca14-j04d",
        "outputId": "1251d755-953f-4561-f0aa-b4e4bd60f965"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5HGsfBbOj04d",
        "outputId": "c104f69f-7f5e-46d3-ad46-2ae18df1eeff"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKt8hHF7j04d"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QxJMyIk4j04d",
        "outputId": "03b01bd8-62b6-48e6-c9f0-629723648b4f"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, [model.features[-2]], preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "wXIN-3T6j04d",
        "outputId": "2e7ed09c-be4f-4584-c988-648b8a6506ca"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "DDIsScNzj04d",
        "outputId": "e3f807e3-3f51-4593-98a3-50d3dbca52ed"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "TAiRPlfcj04d",
        "outputId": "de7c490f-6155-4a1d-f18e-22d269f727ca"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5tiuoB8Cj04d",
        "outputId": "7ea9ad9a-eda1-4347-db21-fddfe4594ea4"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3KpdgHtLj04d",
        "outputId": "673bbd95-c79e-45fa-a692-f02b7efc5940"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AZ4FEZy6j04d"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Z77mL8bj04d",
        "outputId": "8b2b4810-127c-41e9-d324-d34803e8f80a"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "YbTemPaXj04d",
        "outputId": "92dbd508-0590-4479-e318-238d74d71b8c"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "vkLMrjwNj04d",
        "outputId": "6279a512-dda0-4f43-fa13-67018cf8875c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "xbXXkr7Ij04d",
        "outputId": "eadf908a-d856-4071-fe5e-0d43eab1d4f8"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sSNwb2Pwj04e",
        "outputId": "bc1a3174-b351-42b9-9368-9458089f5601"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vx5dwUEhj04e",
        "outputId": "899eb6e6-6b6d-4d19-fa4b-1996831dcd37"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-lw70_O8j04e"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bOoP5JaKj04e",
        "outputId": "61c0e1b1-fb6b-4bf5-ff1e-85f4763bf0e1"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "oiQep4AJj04e",
        "outputId": "e3cfad68-2007-4f86-bda2-708c151d2289"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "oczztYsUj04e",
        "outputId": "9bce4a2f-16d4-4643-a53b-0ab7aeb4a51a"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "6u1Mm9vtj04e",
        "outputId": "0aa8e37b-f2fb-4617-be4f-5b0508b21ceb"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JNOrphUdj04e",
        "outputId": "7dfc139a-5869-46b7-e75c-1a93f620859d"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZh9CCmVj04e",
        "outputId": "5bdc1791-c66d-492b-c313-ad3a0372a0f6"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLf2X2TMj04e"
      },
      "source": [
        "### Resnet50"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fHLifNpsj04e",
        "outputId": "afde0a87-8b02-404e-ddac-27126032cdb3"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", \"svhn\")\n",
        "preprocess_transform = get_preprocess_transform(\"svhn\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MB47Kq1Pj04e"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wLiZMw_aj04e"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FlnO0TzXk_03",
        "outputId": "41c46e94-3b55-475d-9cb0-4073fe722fec"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_yuzLht_j04f",
        "outputId": "dd8780c6-6ed4-427c-c78f-16e548f0ce73"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "-Y-u0a7Kj04f",
        "outputId": "9560e795-4253-4b8e-def5-516fad105cc8"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "WRp1wg2Rj04f",
        "outputId": "1a4b5871-d391-411c-867e-bb99b9c4d8a6"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "Y-WpXOLkj04f",
        "outputId": "ed3afb79-d073-4230-d136-9634d6df84fe"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ChQOvchFj04f",
        "outputId": "a21282f9-4884-404d-b936-c126d9384307"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SCVloF40j04f",
        "outputId": "65a471bf-66de-4e55-f865-57bf531ace7e"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wd1UsHIj04f"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "snZzzwBhj04f",
        "outputId": "8d5994e5-1dd6-4bc5-ad1c-daec6512e343"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "5dnTk2qKj04f",
        "outputId": "e15ad75e-5cb7-468e-c8c2-91a95bfc7115"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "F5IQLjgvj04f",
        "outputId": "cde7465f-0d05-4269-d980-12b773c9b446"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "p9NoqdsSj04f",
        "outputId": "78e1a2e7-d63a-444f-bbd9-705bc9a0dcf0"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UzhyE4lPj04f",
        "outputId": "661fe194-3523-4e56-8db5-c8492225099a"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m8pS3Slmj04g",
        "outputId": "8fdf55cc-0d6d-43b8-926f-c44e8c981112"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mvekiYStj04g"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bw4i3W10j04g",
        "outputId": "77b7e633-28fe-41da-dae2-db225e918a75"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "k-k0bHVtj04i",
        "outputId": "f831fde9-f8a2-4552-f8f1-974ebbb0850a"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "d3TgZUxwj04i",
        "outputId": "33c153c0-9781-44ec-cf3a-6d19d392b477"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "FZj2-uRWj04j",
        "outputId": "2fe096ad-6acf-4470-e114-2da387f5a2b7"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zyZC6TSNj04j",
        "outputId": "96f6a301-747e-4345-9e81-d1b06efa0b16"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l-fZONzhj04j",
        "outputId": "9ff6dcc3-9081-47d4-8dc7-b022368797f6"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3o7J_Tzsj04j"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bmk_LqPij04l",
        "outputId": "50734d5b-92f9-479b-ba2f-073e55729a57"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "vh3QobT4j04l",
        "outputId": "988ffcd4-b6e8-49c2-b50c-b5d966b4da10"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "fMxFeXsSj04m",
        "outputId": "2713f93f-8cb5-428b-c4e9-5e6f0325e872"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "BH7woXfHj04m",
        "outputId": "cd8808b0-0d81-4ffe-d46b-c17c002653f9"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OqlvIjZbj04m",
        "outputId": "846437b5-701f-4f67-c481-149a3e0bf6cb"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9pbS3MrOj04m",
        "outputId": "bce42060-aa74-4b18-ed0a-1123a216839a"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXg8XKOVj04m"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cULlXC-8j04m",
        "outputId": "92ab0f1c-fe32-4943-bb21-deed38bd3137"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "yk2B2IOpj04m",
        "outputId": "c78e2082-60cc-4596-f6d1-8eba7146c6bc"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "vz76Namvj04m",
        "outputId": "344d920e-f8d3-4caa-a23c-b860e85b146c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "FT9YaCdGj04m",
        "outputId": "773409bf-055b-4f74-d418-9f37f21b4b82"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U8xd7q3mj04m",
        "outputId": "31eaa9e0-f0d0-4596-8108-fb7e9a3e7ab1"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QsYPusqHj04m",
        "outputId": "59164680-7130-48d8-b5f3-5f1086159b02"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wgBOr4ZKj04m"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vQgc7RJ-j04m",
        "outputId": "3f2db7cc-cfdd-4ad4-d4f7-e20058cd66b1"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "Y34pzIlLj04m",
        "outputId": "f0610e67-3e38-422c-cf31-75d9e3c8fbf7"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "wL311xg7j04n",
        "outputId": "b1c7d8f0-c78f-4ee5-9360-ae5833f96a2c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 845
        },
        "id": "RJ1S17Qsj04n",
        "outputId": "306f323b-8027-4166-a9b6-86a1736f4b00"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8VGXgOSzj04n",
        "outputId": "c15d88b6-b514-4458-ecbf-7860576e5441"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zPnigeH-j04n",
        "outputId": "e5c4899e-9f86-4ede-d598-e4eec941d0d1"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8SNwCtNj04n"
      },
      "source": [
        "### Densenet121"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6qz1UaOpj04n",
        "outputId": "870f664d-e040-453e-d3b4-a2b261f4889a"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"densenet121\", \"svhn\")\n",
        "preprocess_transform = get_preprocess_transform(\"svhn\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FOlCiXPpj04n"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "59J6WLqDj04n"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I5gC_MK3j04n",
        "outputId": "69ebd327-a9eb-437d-d190-9757448bf4d2"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DjXurJ7Ij04n",
        "outputId": "313fecdd-136d-4ad9-968a-ea4eb4dbdbb6"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "6nuPVuaUj04n",
        "outputId": "bc1e123c-d4b1-4930-d80c-27ada665b580"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "uX632aIDj04o",
        "outputId": "882f5565-79fb-4a86-b867-dd3c3344b5b2"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "STaS1qdOTQrr",
        "outputId": "fd598a43-7a4d-43fd-9866-9fcc5231d564"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NMGq8WzeTMTM",
        "outputId": "276e0fdd-cfeb-40cf-be6a-da0fd29f82b0"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kY9wZ2clj04o",
        "outputId": "938de274-02aa-450b-930c-ddfe3f5bd610"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEBubOWij04o"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vBrEYA3Rj04o"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bi0H4UMD9WEr",
        "outputId": "3e0eadd3-8135-4b50-a3ee-189a2c967407"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lpJBbu2i9X0Y",
        "outputId": "79eadf57-4c37-4a7b-eded-29f2d448847b"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "aMrzJ4aKj04o",
        "outputId": "e16a3005-03ff-401c-ff41-fedc171b05fc"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "NRaileQDj04o",
        "outputId": "98af68de-1b39-4c67-9154-1b5a923eb754"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "086tTOcgj04o",
        "outputId": "0585e1c8-d506-482c-8c8f-e0336c5abd5e"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2PHh4h-Tj04o",
        "outputId": "7fc32424-15f5-49bf-e049-2b26e5ae809e"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k4hVLYkDj04o",
        "outputId": "2e715159-271b-41fa-8033-19de0153bd7c"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ozz1EO7uj04o"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ii7lBCvij04o",
        "outputId": "ee3c06df-7b67-4be1-f551-42b742345bbb"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "YbJhJ2HUj04o",
        "outputId": "8dd2476f-e002-46f6-d6c2-1d82f8a3e524"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "BxEYLBIKj04p",
        "outputId": "bea978dd-9d66-42a5-9d72-d4c53555fead"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "0FIYgRHgj04p",
        "outputId": "cde7905d-f121-4636-9410-de8958c59110"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OnPffWGvj04p",
        "outputId": "9458cf40-2fce-44ef-e903-03d6213d4f38"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5aD87VAUj04p",
        "outputId": "c48a5774-a5c6-4189-a9df-eef16ddc87eb"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPMW1w50j04p"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZeG1pz9Zj04p",
        "outputId": "6606746d-df2b-415f-884a-211fda127081"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "QbwKc2R8j04p",
        "outputId": "4b152bee-e8f7-4d3b-d35f-8d22ef319381"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "qCbUswHOj04p",
        "outputId": "2740ef76-305e-44be-abe4-4d40acb4caa4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "_Wr9OGgtj04p",
        "outputId": "7a391b2a-ec87-482d-b786-042ab7055a75"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "afdblLpVj04p",
        "outputId": "c8968545-e827-45d8-8db6-8cea7461a86d"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gvw-iqvOj04p",
        "outputId": "5f39446a-df72-448c-b5e4-c7889f320820"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQoja-_Lj04p"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IMMjLN-yj04p",
        "outputId": "04e0f31a-56ec-4ec9-a600-296a0f991914"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "wtqpGKQ3j04q",
        "outputId": "ae5f07ca-50cc-4751-9a34-3dcaed20b14f"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "3U2VThEUj04q",
        "outputId": "34310cbe-996b-4672-810e-624de8473b03"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "rl7s4uBYj04q",
        "outputId": "b8382d11-2a8f-48d6-8a0f-3c5597abfd2d"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9LGcUIF0j04q",
        "outputId": "3adc20bb-9a56-409d-fba8-805cf3c5ba8e"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6AN8enKjj04q",
        "outputId": "d96919ea-8c5f-4193-9c46-ffe386ae1bac"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "krRr7Yymj04q"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wsjQEM2Hj04q",
        "outputId": "fce11165-dc88-4460-aa8c-7aa3d791e68f"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "hMxb0oVqj04q",
        "outputId": "fb3a2382-f3ce-4281-db3b-895c0a21cd4a"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "IJvCOlF-j04q",
        "outputId": "40488e85-f867-44bd-eee9-14339a84ff50"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "QHhjimqdj04q",
        "outputId": "6719de9e-5f23-4f6d-acdb-26f70e942028"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZM4EVRgvj04q",
        "outputId": "37e301ea-4c4e-4eaf-ac7e-0c2c9de9eeae"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WNBllWLJj04q",
        "outputId": "fdf8103e-2dfe-4aae-a3f2-aba0103ab156"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lf7YtGPJNgWL"
      },
      "source": [
        "## Imagenet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_8erVJ9yNgWR",
        "outputId": "ebd15a8b-6195-4951-a039-2e23424dc377"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(\"imagenet\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5ztSI698NgWR"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=100)\n",
        "imgs = sample_images\n",
        "print_every_n = int(len(imgs) / 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpDODe1gNgWR"
      },
      "source": [
        "### VGG16_BN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V54swc-iNgWR",
        "outputId": "aa59d605-9ea4-4f94-8282-a2abb2f258d0"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"vgg16_bn\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5CftHXONgWR"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LtjMcjXtNgWR"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S2BlaNKICeZQ",
        "outputId": "73c1ac50-e14c-444d-8bb5-b8f70b057b02"
      },
      "outputs": [],
      "source": [
        "exps1, t = expr.timed_batch_explain(imgs[:250])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s-nXLF-fCeZQ"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime1.npy\", exps1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kkdn4kxi5_aL"
      },
      "outputs": [],
      "source": [
        "exps1 = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime1.npy\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HepVmILNCeZQ",
        "outputId": "c3c5f9d4-8d8b-47f3-8963-84999f7647a1"
      },
      "outputs": [],
      "source": [
        "exps2, t = expr.timed_batch_explain(imgs[250:500])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pjO7Jd8MCeZQ"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime2.npy\", exps2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MzjxCkMG6JQB"
      },
      "outputs": [],
      "source": [
        "exps2 = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime2.npy\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NyvmLT3pECgg",
        "outputId": "0760188e-9c30-4bdd-9728-e41c653b2dbe"
      },
      "outputs": [],
      "source": [
        "exps3, t = expr.timed_batch_explain(imgs[500:750])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NArQGomNECgg"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime3.npy\", exps3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rYx96pxA6KoU"
      },
      "outputs": [],
      "source": [
        "exps3 = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime3.npy\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TLHXxjqUEC-4",
        "outputId": "7cf4d025-8b33-49d8-84f8-ffd8c60a92a8"
      },
      "outputs": [],
      "source": [
        "exps4, t = expr.timed_batch_explain(imgs[750:])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VLg8b4DuEC-4"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime4.npy\", exps4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RBn7o36h6L9M"
      },
      "outputs": [],
      "source": [
        "exps4 = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime4.npy\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Pfs8QoeLCeZQ"
      },
      "outputs": [],
      "source": [
        "exps = np.concatenate((exps1, exps2, exps3, exps4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ncDA4RhH7KQb",
        "outputId": "ccce2b43-54d8-40e6-9d83-f242470a2391"
      },
      "outputs": [],
      "source": [
        "exps.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B7KLZqMoEVNR",
        "outputId": "54ad96ef-3403-451d-b166-2b94bc7c0cb1"
      },
      "outputs": [],
      "source": [
        "exps1_, t = expr.timed_batch_explain(imgs[:250])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dBXVWGFqEVNR"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime1x.npy\", exps1_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3-Lmi1S86OkT"
      },
      "outputs": [],
      "source": [
        "exps1_ = np.load(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime1x.npy\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_fpG3GuuEVNR",
        "outputId": "ffb32b13-7c07-4bd3-d624-0fa3ae764a07"
      },
      "outputs": [],
      "source": [
        "exps2_, t = expr.timed_batch_explain(imgs[250:500])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vvonOL4NEVNR"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime2x.npy\", exps2_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SGhB-y3sEVNR",
        "outputId": "8129584a-7b20-4ac0-a834-c1d87c1f9c00"
      },
      "outputs": [],
      "source": [
        "exps3_, t = expr.timed_batch_explain(imgs[500:750])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B4Uoxzh3EVNR"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime3x.npy\", exps3_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KGfAbKreEVNR",
        "outputId": "31af070c-70c5-4e9c-93a1-896c0f35c7cf"
      },
      "outputs": [],
      "source": [
        "exps4_, t = expr.timed_batch_explain(imgs[750:])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9qzKrX7hEVNS"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_vgg16bn_lime4x.npy\", exps4_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iOtnbYXTCeZR"
      },
      "outputs": [],
      "source": [
        "exps_ = np.concatenate((exps1_, exps2_, exps3_, exps4_))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CPdLqfYrCeZR",
        "outputId": "155efe59-f6a4-4a73-d137-604f7c5f1d44"
      },
      "outputs": [],
      "source": [
        "exps.shape, exps_.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 237
        },
        "id": "ZYg-AKSRNgWR",
        "outputId": "4e96815a-c38c-4b29-8c45-a3fd39c74b0c"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "-lL8XAlKNgWR",
        "outputId": "73c3a492-d015-459a-8d58-779a83d44c32"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "m4SLBkZfNgWR",
        "outputId": "953f40c7-3b22-4c42-e276-effd8fad2d85"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEaqYx_YNgWS",
        "outputId": "148aa860-ef82-45ef-e494-23a220654612"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 353
        },
        "id": "Rx0Epywp7qeY",
        "outputId": "2487212f-8919-4373-a4df-b76a3e698e09"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix in range(ncol-1):\n",
        "    for i in range(ix * print_every_n, (ix+1) * print_every_n):\n",
        "        if not np.array_equal(exps[i], exps_[i]):\n",
        "            axarr[0, ix].imshow(imgs[i])\n",
        "            axarr[0, ix].axis(False)\n",
        "            axarr[1, ix].imshow(exps[i])\n",
        "            axarr[1, ix].axis(False)\n",
        "            axarr[2, ix].imshow(exps_[i])\n",
        "            axarr[2, ix].axis(False)\n",
        "            break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9G2Gg46z7qee",
        "outputId": "c525ff1f-2244-41e5-a640-bf5c2cc563ad"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2FS8PaNNgWS",
        "outputId": "f0494e66-4445-4484-cae0-f8bf456785ea"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GL0UTbjVNgWS"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wrtlL_RRNgWS"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9cjJxE9jifxQ",
        "outputId": "74499466-e6dc-404b-e2cd-81f30ee495b9"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ExbojeDjiiU7",
        "outputId": "f9cfa25f-27c9-4b9c-dbab-425be7bba6ed"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "KUPbc84uNgWS",
        "outputId": "e00ed663-8811-4522-efeb-94a251206dcb"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "3jRXVJ1iNgWS",
        "outputId": "552d94a3-e339-48e3-feea-725af739bd84"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "iQa7e-gHNgWS",
        "outputId": "998e9a1b-35a3-47d7-b735-ab66b76641a2"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WMhSw0SnNgWS"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EYTVQVMtNgWS"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EfGc4C6sNgWS"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yICMjYLMNgWS"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1xIOOKDionO6",
        "outputId": "b3b5a210-c44f-4967-e11c-d3f5cff33253"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qp37pHZ_os5j",
        "outputId": "2eaa0b87-005d-4e1f-9561-59c0cf4cc1b0"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "nrqOda3tNgWS",
        "outputId": "e421a21b-5231-4f35-e34d-4df8a6c12f2b"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "vEVddYYbNgWS",
        "outputId": "6abab4f2-0cd0-4fbd-e062-7d2e987fed0c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 852
        },
        "id": "4hf1XWwHputR",
        "outputId": "1c1990d0-a199-4e0a-d682-976a6b4450c9"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4hvvJDqNgWS",
        "outputId": "5d76a908-657c-4e94-bf14-c4baaf811228"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OL-X4f0cNgWS",
        "outputId": "af2226b1-1535-41f9-823b-b75e274bda2c"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNlGZ4KjNgWS"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EDibm4t5NgWT",
        "outputId": "dbab0338-1120-4387-bab7-7f573cc24673"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "FFyLuvKSNgWT",
        "outputId": "1f164884-d135-4d43-c599-fa4af923e398"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "NrnzyTfUNgWV",
        "outputId": "010af8f8-9354-4060-fe65-e6489ce472be"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 852
        },
        "id": "kTOA8CVFNgWV",
        "outputId": "2d0d571c-515d-4608-821d-53141594bd35"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AhSv9O4YNgWV",
        "outputId": "ac654c74-c664-4ada-bccb-0c40ecc94430"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vdpMo9cGNgWV",
        "outputId": "a10781ed-102a-4020-9591-ad0f4078d9f5"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8S3o7XwzNgWV"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UV1vBfhdNgWV"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZgqlMzMyTKz",
        "outputId": "5bfd8c6a-d8c1-461d-e8c1-fff248ee1847"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0OVVwhoKyVb3",
        "outputId": "fd6a3de4-b62c-4fea-aa87-d11ca5c28683"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 524
        },
        "id": "96QUVW8ZNgWV",
        "outputId": "d090a111-09ad-404d-f516-6cbb9128d6c1"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XdijZaQsNgWV",
        "outputId": "a2fb5c96-2337-4ae9-a1a8-aed1f2efa062"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "GMA8Ct3_NgWV",
        "outputId": "3f80b4f6-c44c-4be8-bba2-f6050055aac3"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2KFyMmAzNgWV",
        "outputId": "5ff18ec5-031e-4bc0-cc77-e7bb52da967f"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EOaQMdZYNgWV",
        "outputId": "a41a99ec-a76a-47c2-ab86-93fcd1cdb56c"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFHXx560NgWW"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mQC2mUTUIz60"
      },
      "outputs": [],
      "source": [
        "torch.cuda.empty_cache()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tjqznlh9NgWW"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DMqqKm81yZSw",
        "outputId": "968d1f51-6fee-4673-aac9-e165d32f1a30"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OJJwxCgQEX0V"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 524
        },
        "id": "TJN6xFvoNgWW",
        "outputId": "b6301e6b-f05c-4121-c10b-ccb92f435e21"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "I9PFwWIbNgWW",
        "outputId": "fa4f0d62-68ed-4fc5-83d2-ae414a10ce96"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "vj_EESxdNgWW",
        "outputId": "8961184e-f9e5-4e28-c959-411c563f993a"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j50Wb7k4NgWW",
        "outputId": "7001ecec-34f0-4dd5-f2a1-e02d3e31c5b3"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7UDlJGLYEq15"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "    axarr[0, ix].imshow(imgs[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps[i])\n",
        "    axarr[1, ix].axis(False)\n",
        "    axarr[2, ix].imshow(exps_[i])\n",
        "    axarr[2, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gGx7PfJqEq15"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v7OwtxqlNgWW",
        "outputId": "0c35f3b2-0b13-497b-c579-771c7db07fae"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uf3kxE4jNgWW"
      },
      "source": [
        "### Resnet50"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4qSTvs7nNgWW",
        "outputId": "66cbb91d-185c-4fe9-c0d9-ab7a11018fb1"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlDOQWILNgWW"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yrdvM0I5NgWW"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zkflIdx_NgWW",
        "outputId": "cb90a573-292c-42c5-aa4b-699a35966721"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C8pnf4RuNgWW",
        "outputId": "5c49dd07-303a-4180-87c3-8ae3eeac912b"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "-H22NZsWNgWW",
        "outputId": "00a9fad1-5566-4ff6-bf8c-67ed3883dc06"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "D2fqo8vnNgWW",
        "outputId": "d32e43a9-cbdf-41ae-d012-ba6a6d59ea22"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "0KvGDtMnNgWW",
        "outputId": "55701878-ebed-4512-a338-40df4ba0d8ca"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iw537pKxNgWW",
        "outputId": "6f8f3fb8-fffc-456d-8520-d0f38c81fa70"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        },
        "id": "XY2XN_IiM-jL",
        "outputId": "45ec5f18-258d-44d9-ea2b-715a46361026"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix in range(ncol-1):\n",
        "    for i in range(ix * print_every_n, (ix+1) * print_every_n):\n",
        "        if not np.array_equal(exps[i], exps_[i]):\n",
        "            axarr[0, ix].imshow(imgs[i])\n",
        "            axarr[0, ix].axis(False)\n",
        "            axarr[1, ix].imshow(exps[i])\n",
        "            axarr[1, ix].axis(False)\n",
        "            axarr[2, ix].imshow(exps_[i])\n",
        "            axarr[2, ix].axis(False)\n",
        "            break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A8uVPdS7PsTd",
        "outputId": "a5f0700e-a169-4806-9547-709a803b68df"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "81_JH3CGNgWX",
        "outputId": "0d01f895-1605-48c7-9ba5-b29a3c9cf9a8"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SoHnHGpINgWX"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MIy0NtLQNgWX"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MZmlbbIKRXhe",
        "outputId": "fc4dad1e-187b-45eb-83ac-1f7b2686fa40"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lex247c3RWCc",
        "outputId": "5e75211c-2969-459f-b001-74a55e0ee3a0"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "nZ3WRuIwNgWX",
        "outputId": "a40fb560-6e75-48a2-d910-7afcc26f75c5"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "X7pMIXHhNgWX",
        "outputId": "ccf019bf-2042-46e7-81f9-b62de9d8bb42"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XrWQUIVuNgWX",
        "outputId": "e193882d-1355-484c-86e2-53022dbd3075"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4-gsjrDFNgWX",
        "outputId": "e9835e85-af80-4074-fe5e-f0735448d1ec"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HtT7ZUm7NgWX",
        "outputId": "d1bbe3d6-d492-4b1c-ca4f-a9c38547a1af"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7c5uVUfNgWX"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "svtTYQ3eNgWX",
        "outputId": "db814152-af55-4096-9757-eb534d1cf5f8"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "Z_i6R84mNgWX",
        "outputId": "6d60fb46-5882-4bdb-8fe4-19c4cc8beb3b"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XALX_Z62NgWX",
        "outputId": "a7250fdd-b73e-4fe5-b266-3b4372f33233"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "LIzbT0dTNgWX",
        "outputId": "0649163a-e48e-4d82-e409-15b8391406b0"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "56_kjqSCNgWX",
        "outputId": "eee7f3b9-e542-4751-faaa-b3c0e44164b7"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "62uNJK2CNgWX",
        "outputId": "57bd1aae-3296-43c1-c340-19a0a7fde159"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8z5w5cHtNgWX"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y-hjmeylNgWX",
        "outputId": "97cb69a7-63e7-460b-839a-0c8fd4794bb2"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "zxp0FjkuNgWX",
        "outputId": "70022c29-b7bc-450c-ceb6-e56be747ef46"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "EbDxNttUNgWX",
        "outputId": "106e6e31-077b-4c41-c732-5443f425a385"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "Pccxrfd2NgWY",
        "outputId": "6ca40e54-07d6-4bf5-8b96-73834b3273e4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_c7kmBULNgWY",
        "outputId": "57364c05-4504-4ae5-d632-77c2702ac803"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ur6dzHzNgWY",
        "outputId": "ab427dcb-6432-4480-d56b-b12b1827e5a1"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tqKxMkKlNgWY"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MGZ12hVtNgWY"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "og3QBOMcn28P",
        "outputId": "8d6b40b3-4c50-49fe-9bd3-b58f2f7ba662"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0BazZCxrn4nt",
        "outputId": "ba277888-c466-4808-e10b-e3dfd0652d13"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "TtfWF7-MNgWY",
        "outputId": "1a8ba86a-367d-4f85-f666-daa864a770d0"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "7wrGaYUfNgWY",
        "outputId": "b995731e-4f41-46b2-c61b-94bbd8f086f7"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "oVyHlLsGNgWY",
        "outputId": "6fb246ab-43ad-45e3-b4b8-3bee9e1839f8"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tqzEbz7iNgWY",
        "outputId": "1a30afa9-f647-47d1-d377-07468677da36"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yCyHDxd6NgWY",
        "outputId": "33ca8dae-4332-49da-8d26-7a4b064f4aec"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-PjCr0m6NgWY"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lLCi1qTK2yz0"
      },
      "outputs": [],
      "source": [
        "torch.cuda.empty_cache()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qm_524P0NgWY"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zvkg1b15sZgQ",
        "outputId": "9c77a76b-dad8-4d0e-a655-90e1106ac7fb"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h23nlA95saXS",
        "outputId": "31a953da-c6ed-4c9c-8532-95c0ba0f75ba"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "YlFq62NDNgWY",
        "outputId": "00527016-f87a-4910-8b8a-7fcee2e3bd23"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "e8tY-JifNgWY",
        "outputId": "ea903918-ca99-4b5f-ec36-3b36b6beb600"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 732
        },
        "id": "F84tbBGeNgWY",
        "outputId": "c8cb2ae8-1b34-44b0-dd57-56f2ffaa7071"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zDHzOLL5NgWY",
        "outputId": "b3ab743b-b069-411f-e2cf-0cb623650eab"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 224
        },
        "id": "DaKccw1PRBrT",
        "outputId": "6c11215e-1ca9-4d61-a5f5-6fa66663a18d"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "    axarr[0, ix].imshow(imgs[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps[i])\n",
        "    axarr[1, ix].axis(False)\n",
        "    axarr[2, ix].imshow(exps_[i])\n",
        "    axarr[2, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YFMFz0VnPUef",
        "outputId": "23d056de-071e-4f3c-a3cf-0e683182e42e"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4i9HgieNgWY",
        "outputId": "466cc066-eef6-41d7-f12c-d1b21069f431"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iqhNE3GbNgWY"
      },
      "source": [
        "### Densenet121"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eKYtz96iNgWY"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"densenet121\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Qro-HjFNgWY"
      },
      "source": [
        "#### LIME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9Y1bOJS8NgWY"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9dZYWt5JNgWZ",
        "outputId": "c214cdb4-08f2-4114-e6db-c47a46a1a069"
      },
      "outputs": [],
      "source": [
        "exps1, t = expr.timed_batch_explain(imgs[:500])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BKvu55MNInv2"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_lime1.npy\", exps1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "INf0J6y0IkIN",
        "outputId": "71e72a60-a00e-4298-de12-03d3e3465d8c"
      },
      "outputs": [],
      "source": [
        "exps2, t = expr.timed_batch_explain(imgs[500:])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uME6gEfQH51d"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_lime2.npy\", exps2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N_KP9goSJyPP"
      },
      "outputs": [],
      "source": [
        "exps = np.concatenate((exps1, exps2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aSvUrfQhKVM0",
        "outputId": "b71385ad-27e8-4255-ca22-8279d962385c"
      },
      "outputs": [],
      "source": [
        "exps1_, t = expr.timed_batch_explain(imgs[:500])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BmEWqf8sKVM0"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_lime1x.npy\", exps1_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_WVOo_uEKVM1",
        "outputId": "fa732272-284d-488f-f1f5-d3b0ce140476"
      },
      "outputs": [],
      "source": [
        "exps2_, t = expr.timed_batch_explain(imgs[500:])\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2U3AZQOOKVM1"
      },
      "outputs": [],
      "source": [
        "np.save(\"/content/drive/MyDrive/Uni/thesis/imagenet_densenet121_lime2x.npy\", exps2_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "52mF9zW1KVM1"
      },
      "outputs": [],
      "source": [
        "exps_ = np.concatenate((exps1_, exps2_))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kdz-rIEt_LHG",
        "outputId": "aa4c6974-3122-4049-bb86-80e2da0104bb"
      },
      "outputs": [],
      "source": [
        "exps.shape, exps_.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "ughoyAqQNgWZ",
        "outputId": "9750e7d1-9856-4bed-e89b-bf099e9369b3"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "TI_VxHKj_Tgy",
        "outputId": "822dac3c-5bf9-46c3-e8ac-e6d3012dd97b"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps_, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "U1CCtAKbNgWZ",
        "outputId": "906d4065-957e-45b1-99aa-1cf488a94012"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "JjDu7b3zNgWZ",
        "outputId": "4a6b8db4-8aa4-4c54-cdae-d18e5444661a"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VX1NTeMQNgWZ",
        "outputId": "f32e3aa8-1428-4e7b-9fcc-f9311a570cf3"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 341
        },
        "id": "Cz9_iya1NY48",
        "outputId": "0434a3ab-c4e4-4d54-ce08-4a104a0f4a99"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "    axarr[0, ix].imshow(imgs[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps[i])\n",
        "    axarr[1, ix].axis(False)\n",
        "    axarr[2, ix].imshow(exps_[i])\n",
        "    axarr[2, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m0BZFtf_NY49",
        "outputId": "968133c9-c5db-40d7-c3e3-a0a8f650f5f9"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bSSIiRO5NgWZ",
        "outputId": "60977f32-ae41-46a2-dc4c-f5f03e3ef89e"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DSG2AfkpNgWZ"
      },
      "source": [
        "#### SHAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SpQMP7xwNgWZ"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YyFud9YmNgWZ",
        "outputId": "5be5f6d2-c1ff-4b73-977d-74478ac1c163"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PZP9cxydNgWZ",
        "outputId": "2955010b-2e0d-4dff-cba4-3b54fb060a22"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "EzjFdvTkNgWZ",
        "outputId": "c006a123-02fd-420b-dc10-98a1472f0bb3"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2S7hFEj_NgWZ",
        "outputId": "00ec5a50-4184-44cc-b4dc-017d82ab6507"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "AFW4XPomNgWZ",
        "outputId": "9e2a5664-358f-450b-ea23-b432e3d471ab"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AFY8MzhtNgWZ",
        "outputId": "0383b9a6-edbe-48fe-86f9-68d8838ed928"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VH6n1x5YNgWa",
        "outputId": "b8f80ff9-791c-4a81-a36d-575913881a12"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llc_LgDaNgWa"
      },
      "source": [
        "#### GradCAM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hYy3atQlNgWa"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LNKhRJEXJTel",
        "outputId": "ae3e19ec-c2ed-4c7f-df7e-f8b01eeef96b"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nKjoM0pgJU3H",
        "outputId": "4680fd7c-f736-4257-e769-625f33fe1688"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "id": "MphN48bCNgWa",
        "outputId": "ec41c447-cabb-4fff-b98b-bcd181dc6a71"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "dHjx12UVNgWa",
        "outputId": "0e1cb567-4a21-4a3e-d5ff-b249c8d6b0c5"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "dHQHe3TNNgWa",
        "outputId": "d7a936d6-fd82-4336-8aa5-797bc3ca1711"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ew91KjfsNgWa",
        "outputId": "a5e14670-e06d-4e70-9df2-2d6ad6229fd3"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RTqm2DZCNgWa",
        "outputId": "051d287d-9fa1-4686-a8a5-781ed09ea90c"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ggd-yKgNgWa"
      },
      "source": [
        "#### GradCAM++"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0AoIO3EeNgWa"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMPlusPlusExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mAghAcXmJdCB",
        "outputId": "5dbe9871-7d95-423a-a444-ce0bba4bef93"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jR4GTZCLJdCB",
        "outputId": "716d51e3-dee3-4d28-a276-ba37e8744406"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "id": "jLU8xir0NgWb",
        "outputId": "e378007c-bcc3-4e15-961d-1fcc094d4818"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "KiAWwrRgNgWb",
        "outputId": "349f7577-4142-46fe-c62b-c753ebc01eb4"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "36RPD1dSNgWb",
        "outputId": "2b829d27-ef91-4b6b-f3ce-6031b9a80b40"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1TMSxan6NgWb",
        "outputId": "a8eb6ef0-c727-4a2b-f350-cb36032cb8e5"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xZjmswWKNgWb",
        "outputId": "1754029d-ab5c-488b-fcde-c8776940dc4f"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZvSfLTZNgWb"
      },
      "source": [
        "#### IntGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j80cvoxJNgWb"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hpwXH4GCi1LV",
        "outputId": "09293960-284c-43b0-b777-ccaac59f52cb"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YpAWGXg-Jee3",
        "outputId": "a4a30464-c55c-4a6a-ae74-e9f161adb8b7"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 524
        },
        "id": "JRUFbLm-NgWb",
        "outputId": "38751e69-7233-4f6a-e0d7-702678bdd6a8"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "gqRamBPgNgWb",
        "outputId": "67a65a3a-e62b-4153-94b5-486dcd6f8f47"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "oQla9BCYNgWb",
        "outputId": "a6ad2953-e58f-4004-c41e-3263e6995cad"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6s6zRrTYNgWb",
        "outputId": "e6512fc8-a845-4f44-f5ee-d6998dcd6b4a"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fD9cWasBNgWb",
        "outputId": "478b3b5c-c95b-429e-f6d9-fe9162f1aa70"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ba2Nyd-YNgWb"
      },
      "source": [
        "#### SmoothGrad"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T4epSOYW2HET"
      },
      "outputs": [],
      "source": [
        "torch.cuda.empty_cache()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "88GgOyP4NgWb"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4HycYk31Jfks",
        "outputId": "bc795e63-9f5d-4fb6-dab9-f22921321765"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bqGF5-WmJfkt",
        "outputId": "341a8cdc-2f24-47de-9f09-fd3a732e762c"
      },
      "outputs": [],
      "source": [
        "exps_, t_ = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 524
        },
        "id": "d5iW1k93NgWb",
        "outputId": "140892ad-18c6-4316-a48d-268aa70b7983"
      },
      "outputs": [],
      "source": [
        "show_imgs_exps(imgs, exps, print_every_n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "AxmyHd3VNgWb",
        "outputId": "b955f1e6-ca07-4a21-bd8a-ec34250aeae9"
      },
      "outputs": [],
      "source": [
        "scores = calculate_fidelity(imgs, exps, lambda x: expr.batch_predict([x]), step=SIZE, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "ea_--33sNgWb",
        "outputId": "ad259b57-77c9-4241-9618-1546a00c26a6"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability(imgs, exps, n=5, print_every=print_every_n)\n",
        "np.mean(scores), np.std(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vP3e7It3NgWc",
        "outputId": "f06e9772-cd5f-4b54-f82b-1e12f8a39007"
      },
      "outputs": [],
      "source": [
        "score, true, total = calculate_identity(exps, exps_)\n",
        "score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 341
        },
        "id": "5JLoQN8QEyNV",
        "outputId": "6189fd0b-fb85-44d8-9b83-6b3e1dbba962"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 3, 10\n",
        "plt.figure()\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(3*ncol, 3*nrow))\n",
        "for ix, i in enumerate(range(0, len(imgs), print_every_n)):\n",
        "    axarr[0, ix].imshow(imgs[i])\n",
        "    axarr[0, ix].axis(False)\n",
        "    axarr[1, ix].imshow(exps[i])\n",
        "    axarr[1, ix].axis(False)\n",
        "    axarr[2, ix].imshow(exps_[i])\n",
        "    axarr[2, ix].axis(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ygsyrpKpEyNV",
        "outputId": "582f86f3-1d2f-4e77-9846-6fdd8b748b7d"
      },
      "outputs": [],
      "source": [
        "distances = [dist(e, e_) for e, e_ in zip(exps, exps_)]\n",
        "np.mean(distances), np.std(distances)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t-GrHVUnNgWc",
        "outputId": "34e6d127-d53b-4733-e5da-a643b3a3b8dc"
      },
      "outputs": [],
      "source": [
        "wrong, total, evaluated, score = calculate_separability(exps)\n",
        "score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gguapWc6f78S"
      },
      "source": [
        "## Explanations Example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oh3Xw5J5r09S",
        "outputId": "1e644604-d774-4e7b-e593-1578c9bb0ea4"
      },
      "outputs": [],
      "source": [
        "ds_names = [\"cifar10\", \"svhn\", \"imagenet\"]\n",
        "imgs_by_ds = {}\n",
        "classes_by_ds = {}\n",
        "models_by_ds = {}\n",
        "settings_by_ds = {}\n",
        "ixs = (3,5,8)\n",
        "n_imgs_per_ds = len(ixs)\n",
        "\n",
        "for ds_name in ds_names:\n",
        "    print(ds_name)\n",
        "    dataset, classes, SIZE, HW, CH = init_dataset(ds_name)\n",
        "    sample_images, _, _ = get_sample_images(dataset, classes, n_images_per_class=1)\n",
        "\n",
        "    imgs_by_ds[ds_name] = [sample_images[ix] for ix in ixs]\n",
        "    classes_by_ds[ds_name] = classes\n",
        "\n",
        "    settings_by_ds[ds_name] = (SIZE, HW, CH)\n",
        "\n",
        "    model, target_layers = get_model(\"resnet50\", ds_name)\n",
        "    preprocess_transform = get_preprocess_transform(ds_name)\n",
        "    batch_predict = get_batch_predict(model, preprocess_transform)\n",
        "    models_by_ds[ds_name] = (model, target_layers, preprocess_transform, batch_predict)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xJjxmRre4yRj",
        "outputId": "1872e757-4d25-4d8e-9f11-26051bb2fc64"
      },
      "outputs": [],
      "source": [
        "for ds_name in ds_names:\n",
        "    model, target_layers = get_model(\"resnet50\", ds_name)\n",
        "    preprocess_transform = get_preprocess_transform(ds_name)\n",
        "    batch_predict = get_batch_predict(model, preprocess_transform)\n",
        "    models_by_ds[ds_name] = (model, target_layers, preprocess_transform, batch_predict)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iHEAPWEHw1aI"
      },
      "outputs": [],
      "source": [
        "explainers = {\n",
        "    \"LIME\": LimeExplainerAdapter,\n",
        "    \"SHAP\": ShapExplainerAdapter,\n",
        "    \"GradCAM\": GradCAMExplainerAdapter,\n",
        "    \"GradCAM++\": GradCAMPlusPlusExplainerAdapter,\n",
        "    \"IntGrad\": IntGradExplainerAdapter,\n",
        "    \"SmoothGrad\": SmoothGradExplainerAdapter,\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "tyWtAveJgI09",
        "outputId": "fb7da495-5b89-438d-d2b4-9b22b8dc9e2c"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = len(ixs) * len(imgs_by_ds), 1 + len(explainers)\n",
        "plt.figure()\n",
        "imsize = 2\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(imsize*ncol, imsize*nrow))\n",
        "\n",
        "for i, (ds_name, imgs) in enumerate(imgs_by_ds.items()):\n",
        "    model, target_layers, preprocess_transform, batch_predict = models_by_ds[ds_name]\n",
        "    SIZE, HW, CH = settings_by_ds[ds_name]\n",
        "\n",
        "    preds = [np.argmax(p) for p in batch_predict(imgs)]\n",
        "    preds = [\n",
        "        classes_by_ds[ds_name][p]\n",
        "        if ds_name != \"imagenet\"\n",
        "        else classes_by_ds[ds_name][imagenet_idx_to_imagenette[p]][0]\n",
        "        for p in preds\n",
        "    ]\n",
        "    print(preds)\n",
        "    for k, (img, pred) in enumerate(zip(imgs, preds)):\n",
        "        ax = axarr[i * n_imgs_per_ds + k, 0]\n",
        "        ax.imshow(img)\n",
        "        if i * n_imgs_per_ds + k == 0:\n",
        "            ax.set_title(\"Image\")\n",
        "\n",
        "        ax.xaxis.set_ticklabels([])\n",
        "        ax.yaxis.set_ticklabels([])\n",
        "        ax.xaxis.set_ticks([])\n",
        "        ax.yaxis.set_ticks([])\n",
        "        ax.spines['bottom'].set_color(None)\n",
        "        ax.spines['top'].set_color(None)\n",
        "        ax.spines['right'].set_color(None)\n",
        "        ax.spines['left'].set_color(None)\n",
        "        ax.set_ylabel(pred, fontsize=14)\n",
        "\n",
        "\n",
        "    for j, (expr_name, expr_class) in enumerate(explainers.items(), start=1):\n",
        "        expr = expr_class(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "\n",
        "        exps, _ = expr.timed_batch_explain(imgs)\n",
        "        for k, (img, exp) in enumerate(zip(imgs, exps)):\n",
        "            axarr[i * n_imgs_per_ds + k, j].imshow(exp)\n",
        "            axarr[i * n_imgs_per_ds + k, j].axis(\"off\")\n",
        "            if (i * n_imgs_per_ds + k) == 0:\n",
        "                axarr[ i * n_imgs_per_ds + k, j].set_title(expr_name, fontsize=14)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EAMBmNbZ6D5U"
      },
      "source": [
        "## Stability example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4NXhUAOO6EN_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JzGZyS-QAMpN"
      },
      "source": [
        "## Fidelity example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m9P6-xRpWyId"
      },
      "outputs": [],
      "source": [
        "ds_name = \"imagenet\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_ASRql4SWyId"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(ds_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TixAq0egWyId"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Axtv9gMpWyId",
        "outputId": "8bfd8e89-dcfd-467f-8a23-e279f92d1d7d"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", ds_name)\n",
        "preprocess_transform = get_preprocess_transform(ds_name)\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vt4z62wJcNgG"
      },
      "outputs": [],
      "source": [
        "import json\n",
        "with open(\"/content/imagenet_class_index.json\", \"r\") as f:\n",
        "    imagenet_classes = json.load(f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k0hBZBh2ZwVp"
      },
      "outputs": [],
      "source": [
        "imgs = [sample_images[3]]\n",
        "pfunc = lambda x: expr.batch_predict([x])\n",
        "get_class = lambda x: imagenet_classes[int(x)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P8sdGQIeZyzi",
        "outputId": "c18ce2e8-d710-4588-d55c-2d83bf67c47f"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "fNSnAqjVZ5AG",
        "outputId": "9ee5ba72-9059-48f7-9945-bd5ea2972741"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "auEaedMeZycp",
        "outputId": "768f943f-00bf-4e03-e9f5-b26929dc7023"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "DewGCT4LZ5dZ",
        "outputId": "e0f5569d-9665-4959-d37a-6e3202f2f560"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mD0WkQ1HZD6j",
        "outputId": "64682396-041a-4ab2-9303-bda362b388d3"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "P4sgWCdIXgwQ",
        "outputId": "f98c1ea4-2801-4806-e8ef-706d92c0c58c"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0yWSICzhZFrV",
        "outputId": "bcbc73f4-ad2c-49bb-f7c5-d4a76ca29b3b"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "XEeuAFDJaSo-",
        "outputId": "fb6cb651-cedf-4074-ee9e-ebf807fcc3b6"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KgMRmDdJgukf"
      },
      "outputs": [],
      "source": [
        "ds_name = \"svhn\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I3W0c0EWgukl",
        "outputId": "ac2b52be-0329-45f6-e946-1880a56ba4d5"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(ds_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WAgSEP9Ugukl"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yYnyvOM-gukl",
        "outputId": "41f9da11-1e09-49e1-8bf3-abc6090db6a5"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", ds_name)\n",
        "preprocess_transform = get_preprocess_transform(ds_name)\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49
        },
        "id": "jfWsTu23gywE",
        "outputId": "fda801e3-23e5-484d-ab9e-776d450969dc"
      },
      "outputs": [],
      "source": [
        "sample_images[52]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mj1dYur6gukl"
      },
      "outputs": [],
      "source": [
        "imgs = [sample_images[51], sample_images[52]]\n",
        "pfunc = lambda x: expr.batch_predict([x])\n",
        "get_class = lambda x: classes[int(x)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XEB-qeS7gukl",
        "outputId": "4e6c036f-374a-411e-8abb-e10abcecc034"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 476
        },
        "id": "kKULsSwBgukl",
        "outputId": "fe6f57b4-dc0a-42ff-d590-c439ee19c33f"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9iVZ8DOahzT_",
        "outputId": "d7df8946-10ca-491a-e24a-a5b9c1fb8744"
      },
      "outputs": [],
      "source": [
        "expr = SmoothGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "exps, t = expr.timed_batch_explain(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 476
        },
        "id": "Bd5ChEpOhzUA",
        "outputId": "7ebc4c61-d20c-456b-d8eb-e123b117dc9f"
      },
      "outputs": [],
      "source": [
        "calculate_fidelity(imgs, exps, pfunc, step=SIZE, print_every=1, get_class=get_class)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dlv0m3SwEaUp"
      },
      "source": [
        "## Identity example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TYZ0MWLkGpY3"
      },
      "outputs": [],
      "source": [
        "ds_name = \"imagenet\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "msdiE8KnEaUv"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(ds_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W8gjiqQbF3Bl"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "id": "xbGB2X6uQoa4",
        "outputId": "d30f56f7-9061-4d0e-f2a7-0d9cf3c22f60"
      },
      "outputs": [],
      "source": [
        "sample_images[66]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jIEzSZEXGd6U"
      },
      "outputs": [],
      "source": [
        "imgs = [sample_images[11], sample_images[42], sample_images[66]]\n",
        "n_imgs = len(imgs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "apbRT08DE1kr",
        "outputId": "8fcd0271-aa2a-472b-c232-515627bdb044"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", ds_name)\n",
        "preprocess_transform = get_preprocess_transform(ds_name)\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xVwP2dpDE23w"
      },
      "outputs": [],
      "source": [
        "explainers = {\n",
        "    \"LIME\": LimeExplainerAdapter,\n",
        "    \"SmoothGrad\": SmoothGradExplainerAdapter,\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Og29TSGyGH6q",
        "outputId": "cab2f534-b898-4636-9562-031f83509686"
      },
      "outputs": [],
      "source": [
        "preds = [np.argmax(p) for p in batch_predict(imgs)]\n",
        "preds = [\n",
        "    classes[p]\n",
        "    if ds_name != \"imagenet\"\n",
        "    else classes[imagenet_idx_to_imagenette[p]][0]\n",
        "    for p in preds\n",
        "]\n",
        "print(preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "LGbFTNh4FF31",
        "outputId": "ec80f4c4-cae0-4641-9663-508c6d6a3d8d"
      },
      "outputs": [],
      "source": [
        "nrow, ncol = 1 + len(explainers), n_imgs * 2\n",
        "plt.figure()\n",
        "imsize = 2\n",
        "_, axarr = plt.subplots(nrow, ncol, figsize=(imsize*ncol, imsize*nrow))\n",
        "\n",
        "for k, (img, pred) in enumerate(zip(imgs, preds)):\n",
        "    for i in range(2):\n",
        "        ax = axarr[0, k * 2 + i]\n",
        "        ax.imshow(img)\n",
        "        # ax.axis(\"off\")\n",
        "        if k * 2 + i == 0:\n",
        "            ax.set_ylabel(\"Image\", fontsize=14)\n",
        "\n",
        "        ax.set_title(pred)\n",
        "        ax.xaxis.set_ticklabels([])\n",
        "        ax.yaxis.set_ticklabels([])\n",
        "        ax.xaxis.set_ticks([])\n",
        "        ax.yaxis.set_ticks([])\n",
        "        ax.spines['bottom'].set_color(None)\n",
        "        ax.spines['top'].set_color(None)\n",
        "        ax.spines['right'].set_color(None)\n",
        "        ax.spines['left'].set_color(None)\n",
        "\n",
        "for j, (expr_name, expr_class) in enumerate(explainers.items(), start=1):\n",
        "    expr = expr_class(model, target_layers, preprocess_transform, SIZE, CH)\n",
        "    for k, img in enumerate(imgs):\n",
        "        exp1, _ = expr.timed_single_explain(img)\n",
        "        exp2 = exp1\n",
        "        while np.array_equal(exp1, exp2):\n",
        "            exp2, _ = expr.timed_single_explain(img)\n",
        "        for i, exp in enumerate((exp1, exp2)):\n",
        "            ax = axarr[j, k * 2 + i]\n",
        "            ax.imshow(exp)\n",
        "            if (k * 2 + i) == 0:\n",
        "                ax.set_ylabel(expr_name, fontsize=14)\n",
        "\n",
        "            ax.xaxis.set_ticklabels([])\n",
        "            ax.yaxis.set_ticklabels([])\n",
        "            ax.xaxis.set_ticks([])\n",
        "            ax.yaxis.set_ticks([])\n",
        "            ax.spines['bottom'].set_color(None)\n",
        "            ax.spines['top'].set_color(None)\n",
        "            ax.spines['right'].set_color(None)\n",
        "            ax.spines['left'].set_color(None)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2OC_SZm7-5Wi"
      },
      "source": [
        "## Imagenette accuracy calculation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1ZpmyUxN-9tF"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(\"imagenet\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I7uoylzG_DJ7"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"vgg16_bn\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GWUgRN7HB7AD",
        "outputId": "b459d04e-19a6-4562-b4a0-59ee099b9957"
      },
      "outputs": [],
      "source": [
        "res = []\n",
        "for img, cls in tqdm(dataset):\n",
        "    res.append(imagenet_idx_to_imagenette.get(np.argmax(batch_predict([img])[0])) == cls)\n",
        "np.mean(res)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YJQBnTSM_EFF",
        "outputId": "f14c60ee-46a8-43fb-f33b-ab1f105027b3"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_LRWNLYV_Mgf",
        "outputId": "e0ba5080-4479-438b-e02f-210e97ec619c"
      },
      "outputs": [],
      "source": [
        "res = []\n",
        "for img, cls in tqdm(dataset):\n",
        "    res.append(imagenet_idx_to_imagenette.get(np.argmax(batch_predict([img])[0])) == cls)\n",
        "np.mean(res)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gu104quO_EPR",
        "outputId": "8fad9d34-222c-4aa6-f6b0-e230fe1cb508"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"densenet121\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fSRGMf_A_M2v",
        "outputId": "bd382066-9f92-4119-d752-fd117a111d33"
      },
      "outputs": [],
      "source": [
        "res = []\n",
        "for img, cls in tqdm(dataset):\n",
        "    res.append(imagenet_idx_to_imagenette.get(np.argmax(batch_predict([img])[0])) == cls)\n",
        "np.mean(res)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O8Jq5Hqq6KaH"
      },
      "source": [
        "## Stability v2 comparison (using noisy images)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pbQgWNuD25Uc",
        "outputId": "a2e6c3c4-d66c-454e-9965-d568e1bf675c"
      },
      "outputs": [],
      "source": [
        "dataset, classes, SIZE, HW, CH = init_dataset(\"imagenet\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9HidvnPn25Ui"
      },
      "outputs": [],
      "source": [
        "sample_images, sample_labels, sample_images_by_class = get_sample_images(dataset, classes, n_images_per_class=1)\n",
        "imgs = sample_images\n",
        "print_every_n = int(len(imgs) / 10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r9H_Q1mo6WRU",
        "outputId": "37218bb9-10e2-4d91-9d6a-22e07070f413"
      },
      "outputs": [],
      "source": [
        "model, target_layers = get_model(\"resnet50\", \"imagenet\")\n",
        "preprocess_transform = get_preprocess_transform(\"imagenet\")\n",
        "batch_predict = get_batch_predict(model, preprocess_transform)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h-jwwedW5Jyr"
      },
      "outputs": [],
      "source": [
        "expr = LimeExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Peexuep5Jy6",
        "outputId": "3c296257-0375-44b1-b155-55b6547f5683"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 899
        },
        "id": "oFPyK3ij5LmM",
        "outputId": "59007207-e241-41f6-f027-c76162045aef"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability_v2(imgs, exps, lambda x: expr.timed_single_explain(x)[0])\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lzj_PjSJ8b8_"
      },
      "outputs": [],
      "source": [
        "expr = ShapExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x0T-O5bf8b8_",
        "outputId": "50a41a45-95d4-42be-90c2-ea134cb142cf"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 899
        },
        "id": "KsJ8G2n18d5h",
        "outputId": "1bb011ef-4fc6-47d1-ffdf-59ae2ed98c24"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability_v2(imgs, exps, lambda x: expr.timed_single_explain(x)[0])\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1CY4Xbvd3MFO"
      },
      "outputs": [],
      "source": [
        "expr = GradCAMExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ursDX3qK3MFP",
        "outputId": "90344d45-6714-4b0c-a50d-2501c69a538c"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 899
        },
        "id": "5f1a9tVp3RPs",
        "outputId": "419dad62-c766-4366-ca37-da4a9c322ebc"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability_v2(imgs, exps, lambda x: expr.timed_single_explain(x)[0])\n",
        "np.mean(scores)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KFG8htnX3OOy"
      },
      "outputs": [],
      "source": [
        "expr = IntGradExplainerAdapter(model, target_layers, preprocess_transform, SIZE, CH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J1ZFQ0KS3OOy",
        "outputId": "23d90245-516c-4499-eae6-14455447bde9"
      },
      "outputs": [],
      "source": [
        "exps, t = expr.timed_batch_explain(imgs)\n",
        "print(f\"Mean time for {len(imgs)} explanations: {t}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 899
        },
        "id": "u4q2kbfT2wWc",
        "outputId": "ce1ae3e5-ae40-4d8b-b836-50752bc8809c"
      },
      "outputs": [],
      "source": [
        "scores = calculate_stability_v2(imgs, exps, lambda x: expr.timed_single_explain(x)[0])\n",
        "np.mean(scores)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "WkS_CYChdlku",
        "19k1g_w7VNzS",
        "6AwWNfnaY7-y",
        "9FpPR2U2TeT1",
        "9SEV4h_0bwy0",
        "k55FioNiez0W",
        "aoasIecLN3DV",
        "iaEpsIYPN84P",
        "Cn-mAztCOASM",
        "3lIFUDl9qbCo",
        "MTPxthNti4RI",
        "d2uOR-Smi4RJ",
        "3eqTGUkyi4RJ",
        "M3E_yutoi4RJ",
        "vP3LT4dFi4oT",
        "AlmDZZQ9i4oT",
        "QxRxSVuki4oU",
        "6GBX9-byi4oW",
        "OKt8hHF7j04d",
        "AZ4FEZy6j04d",
        "-lw70_O8j04e",
        "JQoja-_Lj04p",
        "SoHnHGpINgWX"
      ],
      "gpuType": "T4",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.6.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}