notebooks/Interpretability - Image Explainers.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "source": [
                "## Interpretability - Image Explainers\n",
                "\n",
                "In this example, we use LIME and Kernel SHAP explainers to explain the ResNet50 model's multi-class output of an image.\n",
                "\n",
                "First we import the packages and define some UDFs and a plotting function we will need later."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "from mmlspark.explainers import *\r\n",
                "from mmlspark.onnx import ONNXModel\r\n",
                "from mmlspark.opencv import ImageTransformer\r\n",
                "from mmlspark.io import *\r\n",
                "from pyspark.ml import Pipeline\r\n",
                "from pyspark.ml.classification import LogisticRegression\r\n",
                "from pyspark.ml.feature import StringIndexer\r\n",
                "from pyspark.sql.functions import *\r\n",
                "from pyspark.sql.types import *\r\n",
                "import numpy as np\r\n",
                "import pyspark\r\n",
                "import urllib.request\r\n",
                "import matplotlib.pyplot as plt\r\n",
                "import PIL, io\r\n",
                "from PIL import Image\r\n",
                "\r\n",
                "vec_slice = udf(lambda vec, indices: (vec.toArray())[indices].tolist(), ArrayType(FloatType()))\r\n",
                "arg_top_k = udf(lambda vec, k: (-vec.toArray()).argsort()[:k].tolist(), ArrayType(IntegerType()))\r\n",
                "\r\n",
                "def downloadBytes(url: str):\r\n",
                "  with urllib.request.urlopen(url) as url:\r\n",
                "    barr = url.read()\r\n",
                "    return barr\r\n",
                "\r\n",
                "def rotate_color_channel(bgr_image_array, height, width, nChannels):\r\n",
                "  B, G, R, *_ = np.asarray(bgr_image_array).reshape(height, width, nChannels).T\r\n",
                "  rgb_image_array = np.array((R, G, B)).T\r\n",
                "  return rgb_image_array\r\n",
                "    \r\n",
                "def plot_superpixels(image_rgb_array, sp_clusters, weights, green_threshold=99):\r\n",
                "    superpixels = sp_clusters\r\n",
                "    green_value = np.percentile(weights, green_threshold)\r\n",
                "    img = Image.fromarray(image_rgb_array, mode='RGB').convert(\"RGBA\")\r\n",
                "    image_array = np.asarray(img).copy()\r\n",
                "    for (sp, v) in zip(superpixels, weights):\r\n",
                "        if v > green_value:\r\n",
                "            for (x, y) in sp:\r\n",
                "                image_array[y, x, 1] = 255\r\n",
                "                image_array[y, x, 3] = 200\r\n",
                "    plt.clf()\r\n",
                "    plt.imshow(image_array)\r\n",
                "    display()"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Create a dataframe for a testing image, and use the ResNet50 ONNX model to infer the image.\n",
                "\n",
                "The result shows 39.6% probability of \"violin\" (889), and 38.4% probability of \"upright piano\" (881)."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "from mmlspark.io import *\r\n",
                "\r\n",
                "image_df = spark.read.image().load(\"wasbs://publicwasb@mmlspark.blob.core.windows.net/explainers/images/david-lusvardi-dWcUncxocQY-unsplash.jpg\")\r\n",
                "display(image_df)\r\n",
                "\r\n",
                "# Rotate the image array from BGR into RGB channels for visualization later.\r\n",
                "row = image_df.select(\"image.height\", \"image.width\", \"image.nChannels\", \"image.data\").head()\r\n",
                "locals().update(row.asDict())\r\n",
                "rgb_image_array = rotate_color_channel(data, height, width, nChannels)\r\n",
                "\r\n",
                "# Download the ONNX model\r\n",
                "modelPayload = downloadBytes(\"https://mmlspark.blob.core.windows.net/publicwasb/ONNXModels/resnet50-v2-7.onnx\")\r\n",
                "\r\n",
                "featurizer = (\r\n",
                "  ImageTransformer(inputCol=\"image\", outputCol=\"features\")\r\n",
                "      .resize(224, True)\r\n",
                "      .centerCrop(224, 224)\r\n",
                "      .normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], color_scale_factor = 1/255)\r\n",
                "      .setTensorElementType(FloatType())\r\n",
                ")\r\n",
                "\r\n",
                "onnx = (\r\n",
                "  ONNXModel()\r\n",
                "      .setModelPayload(modelPayload)\r\n",
                "      .setFeedDict({\"data\": \"features\"})\r\n",
                "      .setFetchDict({\"rawPrediction\": \"resnetv24_dense0_fwd\"})\r\n",
                "      .setSoftMaxDict({\"rawPrediction\": \"probability\"})\r\n",
                "      .setMiniBatchSize(1)\r\n",
                ")\r\n",
                "\r\n",
                "model = Pipeline(stages=[featurizer, onnx]).fit(image_df)"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "predicted = (\r\n",
                "    model.transform(image_df)\r\n",
                "      .withColumn(\"top2pred\", arg_top_k(col(\"probability\"), lit(2)))\r\n",
                "      .withColumn(\"top2prob\", vec_slice(col(\"probability\"), col(\"top2pred\")))\r\n",
                ")\r\n",
                "\r\n",
                "display(predicted.select(\"top2pred\", \"top2prob\"))"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "First we use the LIME image explainer to explain the model's top 2 classes' probabilities."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "lime = (\r\n",
                "    ImageLIME()\r\n",
                "    .setModel(model)\r\n",
                "    .setOutputCol(\"weights\")\r\n",
                "    .setInputCol(\"image\")\r\n",
                "    .setCellSize(150.0)\r\n",
                "    .setModifier(50.0)\r\n",
                "    .setNumSamples(500)\r\n",
                "    .setTargetCol(\"probability\")\r\n",
                "    .setTargetClassesCol(\"top2pred\")\r\n",
                "    .setSamplingFraction(0.7)\r\n",
                ")\r\n",
                "\r\n",
                "lime_result = (\r\n",
                "    lime.transform(predicted)\r\n",
                "    .withColumn(\"weights_violin\", col(\"weights\").getItem(0))\r\n",
                "    .withColumn(\"weights_piano\", col(\"weights\").getItem(1))\r\n",
                "    .cache()\r\n",
                ")\r\n",
                "\r\n",
                "display(lime_result.select(col(\"weights_violin\"), col(\"weights_piano\")))\r\n",
                "lime_row = lime_result.head()"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "We plot the LIME weights for \"violin\" output and \"upright piano\" output.\n",
                "\n",
                "Green area are superpixels with LIME weights above 95 percentile."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "plot_superpixels(rgb_image_array, lime_row[\"superpixels\"][\"clusters\"], list(lime_row[\"weights_violin\"]), 95)\r\n",
                "plot_superpixels(rgb_image_array, lime_row[\"superpixels\"][\"clusters\"], list(lime_row[\"weights_piano\"]), 95)"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Your results will look like:\r\n",
                "\r\n",
                "<img src=\"https://mmlspark.blob.core.windows.net/graphics/explainers/image-lime-20210811.png\"/>"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Then we use the Kernel SHAP image explainer to explain the model's top 2 classes' probabilities."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "shap = (\r\n",
                "    ImageSHAP()\r\n",
                "    .setModel(model)\r\n",
                "    .setOutputCol(\"shaps\")\r\n",
                "    .setSuperpixelCol(\"superpixels\")\r\n",
                "    .setInputCol(\"image\")\r\n",
                "    .setCellSize(150.0)\r\n",
                "    .setModifier(50.0)\r\n",
                "    .setNumSamples(500)\r\n",
                "    .setTargetCol(\"probability\")\r\n",
                "    .setTargetClassesCol(\"top2pred\")\r\n",
                ")\r\n",
                "\r\n",
                "shap_result = (\r\n",
                "    shap.transform(predicted)\r\n",
                "    .withColumn(\"shaps_violin\", col(\"shaps\").getItem(0))\r\n",
                "    .withColumn(\"shaps_piano\", col(\"shaps\").getItem(1))\r\n",
                "    .cache()\r\n",
                ")\r\n",
                "\r\n",
                "display(shap_result.select(col(\"shaps_violin\"), col(\"shaps_piano\")))\r\n",
                "shap_row = shap_result.head()"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "We plot the SHAP values for \"piano\" output and \"cell\" output.\n",
                "\n",
                "Green area are superpixels with SHAP values above 95 percentile.\n",
                "\n",
                "> Notice that we drop the base value from the SHAP output before rendering the superpixels. The base value is the model output for the background (all black) image."
            ],
            "metadata": {}
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "plot_superpixels(rgb_image_array, shap_row[\"superpixels\"][\"clusters\"], list(shap_row[\"shaps_violin\"][1:]), 95)\r\n",
                "plot_superpixels(rgb_image_array, shap_row[\"superpixels\"][\"clusters\"], list(shap_row[\"shaps_piano\"][1:]), 95)"
            ],
            "outputs": [],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Your results will look like:\r\n",
                "\r\n",
                "<img src=\"https://mmlspark.blob.core.windows.net/graphics/explainers/image-shap-20210811.png\"/>"
            ],
            "metadata": {}
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.8.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}