{ "cells": [ { "cell_type": "markdown", "id": "084f4fd3", "metadata": {}, "source": [ "# Exploring the Effects of Perturbations on Saliency Map Generation\n", "\n", "The link between saliency maps and model natural robustness is currently unclear. This is a simple notebook exploring how perturbations might affect saliency maps, using tools provided by the `nrtk-jatic` and `xaitk-saliency` packages.\n", "\n", "## Table Of Contents\n", "* [Environment Setup](#environment-setup)\n", "* [Example Images](#example-images)\n", "* [Defining the \"Application\"](#defining-the-application)\n", "* [Running the \"Application\"](#running-the-application)\n", " * [Classifier](#classifier)\n", " * [Saliency Generator](#saliency-generator)\n", " * [Results](#results)" ] }, { "cell_type": "markdown", "id": "d9e7b4e6", "metadata": {}, "source": [ "## Environment Setup " ] }, { "cell_type": "code", "execution_count": 1, "id": "a44b964e", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Installing xaitk-jatic...\n", "Installing nrtk[pybsm,headless]...\n", "Installing Hugging Face datasets...\n", "Installing Hugging Face transformers...\n", "Installing tabulate...\n", "Installing torch...\n", "Done!\n" ] } ], "source": [ "import sys # noqa: F401\n", "\n", "!{sys.executable} -m pip install -qU pip\n", "print(\"Installing xaitk-jatic...\")\n", "!{sys.executable} -m pip install -q xaitk-jatic\n", "print(\"Installing nrtk[pybsm,headless]...\")\n", "!{sys.executable} -m pip install -q -e ../..[pybsm,headless]\n", "print(\"Installing Hugging Face datasets...\")\n", "!{sys.executable} -m pip install -q datasets\n", "print(\"Installing Hugging Face transformers...\")\n", "!{sys.executable} -m pip install -q transformers\n", "print(\"Installing tabulate...\")\n", "!{sys.executable} -m pip install -q tabulate\n", "print(\"Installing torch...\")\n", "!{sys.executable} -m pip install -q torch\n", "\n", "print(\"Done!\")" ] }, { "cell_type": "code", "execution_count": 1, "id": "a14d93f4", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/data/barry.ravichandran/envs/nrtk/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "source": [ "from collections.abc import Hashable\n", "from dataclasses import dataclass, field\n", "from typing import TYPE_CHECKING, Any, Optional, Union\n", "\n", "import maite.protocols.image_classification as ic\n", "import numpy as np\n", "import torch\n", "from datasets import Dataset, load_dataset\n", "from matplotlib import pyplot as plt\n", "from scipy.stats import entropy\n", "from smqtk_classifier.interfaces.classify_image import ClassifyImage\n", "from tabulate import tabulate\n", "from transformers import (\n", " AutoImageProcessor,\n", " AutoModelForImageClassification,\n", ")\n", "from xaitk_jatic.interop.image_classification.model import JATICImageClassifier\n", "from xaitk_saliency.impls.gen_image_classifier_blackbox_sal.slidingwindow import SlidingWindowStack\n", "from xaitk_saliency.interfaces.gen_image_classifier_blackbox_sal import (\n", " GenerateImageClassifierBlackboxSaliency,\n", ")\n", "\n", "from nrtk.impls.perturb_image.pybsm.jitter_otf_perturber import JitterOTFPerturber\n", "\n", "%matplotlib inline\n", "%config InlineBackend.figure_format = \"jpeg\" # Use JPEG format for inline visualizations" ] }, { "cell_type": "markdown", "id": "c7eb6ba6", "metadata": {}, "source": [ "## Example Images \n", "\n", "We'll use example images from the CIFAR-10 test dataset, but this could be expanded to many images -- even across a dataset." ] }, { "cell_type": "code", "execution_count": 2, "id": "a07790a3", "metadata": {}, "outputs": [], "source": [ "data = load_dataset(\"cifar10\", split=\"test\")\n", "\n", "if TYPE_CHECKING:\n", " assert isinstance(data, Dataset)\n", "\n", "labels = data.features[\"label\"].names\n", "data.set_transform(lambda x: {\"image\": x[\"img\"], \"label\": x[\"label\"]})" ] }, { "cell_type": "code", "execution_count": 3, "id": "e68e410e", "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "num_samples = 2\n", "if TYPE_CHECKING:\n", " assert isinstance(data, Dataset)\n", "imgs = np.asarray([np.asarray(data[idx][\"image\"]) for idx in range(num_samples)])\n", "ground_truth: list[int] = [data[idx][\"label\"] for idx in range(num_samples)]\n", "\n", "for img, gt in zip(imgs, ground_truth):\n", " plt.figure(figsize=(2, 2))\n", " plt.xticks(())\n", " plt.yticks(())\n", " plt.xlabel(f\"GT: {labels[gt]}\")\n", " _ = plt.imshow(img)" ] }, { "cell_type": "markdown", "id": "d5f51856", "metadata": {}, "source": [ "## Defining the \"Application\" \n", "\n", "First we'll define a couple of dataclasses to keep track of results more easily:" ] }, { "cell_type": "code", "execution_count": 4, "id": "7b6e713e", "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PerturbationResult:\n", " \"\"\"Dataclass for storing perturbed image and associated results\"\"\"\n", "\n", " descriptor: str\n", " img: np.ndarray\n", " sal_maps: np.ndarray\n", " pred_class: int\n", " pred_prob: float\n", "\n", "\n", "@dataclass\n", "class SaliencyResults:\n", " \"\"\"Dataclass for storing saliency map and associated results\"\"\"\n", "\n", " ref_img: np.ndarray\n", " ref_sal_maps: np.ndarray\n", " gt: int\n", " pred_class: int\n", " pred_prob: float\n", " perturbations: list[PerturbationResult] = field(default_factory=list)" ] }, { "cell_type": "markdown", "id": "204325aa", "metadata": {}, "source": [ "Next, we'll define a function to compute specified metrics upon our saliency map results. These metrics include measures such as the entropy of the resulting saliency map, as well as various measures of correlation between the saliency map computed on the original image and the saliency maps computed on perturbed images." ] }, { "cell_type": "code", "execution_count": 5, "id": "38449894", "metadata": {}, "outputs": [], "source": [ "def _compute_entropy(\n", " sal_map: np.ndarray,\n", " clip_min: Optional[int] = None,\n", " clip_max: Optional[int] = None,\n", ") -> Union[np.number, np.ndarray]:\n", " if clip_min is not None or clip_max is not None:\n", " s = np.clip(sal_map, clip_min, clip_max)\n", " else:\n", " s = (sal_map - sal_map.min()) / (sal_map.max() - sal_map.min())\n", " return entropy(s.ravel(), base=2)\n", "\n", "\n", "def _compute_ssd(sal_map: np.ndarray, ref_sal_map: np.ndarray) -> float:\n", " sum_sq_diff = np.sum(np.power(np.subtract(sal_map, ref_sal_map), 2))\n", " norm = np.sqrt(np.sum(np.power(sal_map, 2)) * np.sum(np.power(ref_sal_map, 2)))\n", " if not norm:\n", " return np.inf\n", " return sum_sq_diff / norm\n", "\n", "\n", "def _compute_xcorr(sal_map: np.ndarray, ref_sal_map: np.ndarray) -> float:\n", " def _normalize(s: np.ndarray) -> tuple[np.ndarray, bool]:\n", " s -= s.mean()\n", " std = s.std()\n", "\n", " if std:\n", " s /= std\n", "\n", " return s, std == 0\n", "\n", " s1, c1 = _normalize(sal_map.copy())\n", " s2, c2 = _normalize(ref_sal_map.copy())\n", "\n", " if c1 and not c2:\n", " return 0.0\n", " return np.corrcoef(s1.flatten(), s2.flatten())[0, 1]\n", "\n", "\n", "def _compute_metric(sal_map: np.ndarray, ref_sal_map: np.ndarray, m: str) -> float:\n", " if \"entropy\" in m:\n", " _compute_entropy_setup(sal_map, m)\n", " if m == \"ssd\":\n", " return _compute_ssd(sal_map, ref_sal_map)\n", " if m == \"xcorr\":\n", " return _compute_xcorr(sal_map, ref_sal_map)\n", " return np.nan\n", "\n", "\n", "def _compute_entropy_setup(sal_map: np.ndarray, m: str) -> Union[float, np.number, np.ndarray]:\n", " if m == \"entropy\":\n", " return _compute_entropy(sal_map)\n", " if m == \"pos saliency entropy\":\n", " return _compute_entropy(sal_map, 0, 1)\n", " if m == \"neg saliency entropy\":\n", " return _compute_entropy(sal_map, -1, 0)\n", " return np.nan\n", "\n", "\n", "def _generate_row(\n", " sal_map: np.ndarray,\n", " ref_sal_map: np.ndarray,\n", " row_label: str,\n", " metrics: tuple[str, ...],\n", ") -> list[Hashable]:\n", " r: list[Hashable] = [row_label]\n", "\n", " r.extend([_compute_metric(sal_map, ref_sal_map, metric.lower().strip()) for metric in metrics])\n", "\n", " return r\n", "\n", "\n", "def compute_metrics(results: list[SaliencyResults], metrics: tuple[str, ...]) -> None:\n", " \"\"\"Compute metrics for saliency mpas\"\"\"\n", " headers = [\"Perturbation\"]\n", " headers.extend(list(metrics))\n", " for res in results:\n", " rows = []\n", "\n", " rows.append(_generate_row(res.ref_sal_maps[res.gt], res.ref_sal_maps[res.gt], \"Ref Image\", metrics))\n", " rows.extend(\n", " [\n", " _generate_row(pert.sal_maps[res.gt], res.ref_sal_maps[res.gt], f\"{pert.descriptor}\", metrics)\n", " for pert in res.perturbations\n", " ],\n", " )\n", "\n", " print(tabulate(rows, headers=headers, tablefmt=\"fancy_grid\"))" ] }, { "cell_type": "markdown", "id": "f7602444", "metadata": {}, "source": [ "We'll also define a function to display all generated saliency maps." ] }, { "cell_type": "code", "execution_count": 6, "id": "a79d0639", "metadata": {}, "outputs": [], "source": [ "def _plot_img(img: np.ndarray, num_cols: int, descriptor: str = \"\") -> None:\n", " plt.subplot(2, num_cols, 1)\n", " plt.imshow(img, cmap=\"gray\")\n", " plt.xticks(())\n", " plt.yticks(())\n", " plt.xlabel(descriptor)\n", "\n", "\n", "def _plot_rows(sal_maps: np.ndarray, num_cols: int, plot_idxes: Optional[list[int]] = None) -> None:\n", " plot_idxes = list(range(len(sal_maps))) if plot_idxes is None else [*set(plot_idxes)]\n", " n_cols = min(num_cols - 1, len(plot_idxes))\n", " n_rows = 2\n", "\n", " num_imgs = 0\n", " for r in range(n_rows):\n", " col_offset = 2\n", " if r > 0:\n", " col_offset = 3\n", " for c in range(r * n_cols, min(r * n_cols + n_cols, len(plot_idxes))):\n", " plt.subplot(n_rows, num_cols, c + col_offset)\n", " im = plt.imshow(sal_maps[plot_idxes[c]], cmap=plt.get_cmap(\"RdBu\"), vmin=-1, vmax=1)\n", " plt.xticks(())\n", " plt.yticks(())\n", " plt.xlabel(f\"{labels[plot_idxes[c]]}\")\n", " num_imgs += 1\n", "\n", " if num_imgs == len(plot_idxes):\n", " fig = plt.gcf()\n", " cax = fig.add_axes((0.38, 0.60, 0.01, 0.21)) # tweaked for this particular example\n", " plt.colorbar(im, cax=cax)\n", "\n", "\n", "def display_results(results: list[SaliencyResults], labels: dict[int, str]) -> None:\n", " \"\"\"Displays saliency results with plots and a table\"\"\"\n", " num_classes = len(labels)\n", "\n", " for res in results:\n", " plt.figure(figsize=(10, 5))\n", " num_cols = np.ceil(num_classes / 2).astype(int) + 1\n", " pred = f\"{labels[res.pred_class]} ({res.pred_prob:.2f})\"\n", " _plot_img(res.ref_img, num_cols, f\"Ref Img\\nGT: {labels[res.gt]}\\nPred: {pred}\")\n", " _plot_rows(res.ref_sal_maps, num_cols, [res.gt])\n", "\n", " for pert in res.perturbations:\n", " plt.figure(figsize=(10, 5))\n", " pred = f\"{pert.pred_class} ({pert.pred_prob:.2f})\"\n", " _plot_img(pert.img, num_cols, f\"{pert.descriptor}\\nPred: {pred}\")\n", " _plot_rows(pert.sal_maps, num_cols, [res.gt])\n", "\n", " plt.show()" ] }, { "cell_type": "markdown", "id": "1ebdf216", "metadata": {}, "source": [ "Finally, we'll define the \"application\" which perturbs the given input image(s) to varying degrees and generates saliency maps. In this case, we'll perturb the images using a pyBSM based perturber. To easily apply this perturbation, we'll use the `JitterOTFPerturber` provided by `nrtk-jatic`, which simulates varying amounts of sensor jitter on image collection." ] }, { "cell_type": "code", "execution_count": 7, "id": "21514b2a", "metadata": {}, "outputs": [], "source": [ "def _max_class(probs: dict) -> str:\n", " v = list(probs.values())\n", " k = list(probs.keys())\n", " return k[v.index(max(v))]\n", "\n", "\n", "def _generate_augmented_maps(\n", " idx: int,\n", " additional_params: list[dict[str, Any]],\n", " res: SaliencyResults,\n", " img: np.ndarray,\n", " num_images: int,\n", " image_classifier: ClassifyImage,\n", " saliency_generator: GenerateImageClassifierBlackboxSaliency,\n", ") -> None:\n", " for k in additional_params:\n", " print(f\"Generating saliency maps for s_y={k['s_y']} (ref image {idx+1} of {num_images})\")\n", " xform = JitterOTFPerturber(**k)\n", " img_out, _ = xform(np.copy(img))\n", " sal_maps = saliency_generator(img_out, image_classifier)\n", " probs = next(image_classifier.classify_images(np.expand_dims(img_out, axis=0)))\n", " pred_class = _max_class(probs)\n", "\n", " pert = PerturbationResult(\n", " descriptor=f\"ksize={k}\",\n", " img=img_out,\n", " sal_maps=sal_maps,\n", " pred_class=labels[pred_class],\n", " pred_prob=probs[pred_class],\n", " )\n", "\n", " res.perturbations.append(pert)\n", "\n", "\n", "def generate_perturbed_sal_maps(\n", " images: np.ndarray,\n", " ground_truth: list[int],\n", " image_classifier: ClassifyImage,\n", " saliency_generator: GenerateImageClassifierBlackboxSaliency,\n", " additional_params: list[dict[str, Any]],\n", " display_labels: dict[int, str],\n", " display_maps: bool = True,\n", " metrics: tuple[str, ...] = (\"Pos Saliency Entropy\", \"Neg Saliency Entropy\", \"Entropy\", \"SSD\", \"XCorr\"),\n", ") -> list[SaliencyResults]:\n", " \"\"\"Generate saliency maps for image\"\"\"\n", " # Get class labels\n", " labels = image_classifier.get_labels()\n", "\n", " # Generate saliency maps\n", " results = list()\n", " for idx, img in enumerate(images):\n", " print(f\"Generating saliency maps for reference image (image {idx+1} of {len(images)})\")\n", " sal_maps = saliency_generator(img, image_classifier)\n", " probs = next(image_classifier.classify_images(np.expand_dims(img, axis=0)))\n", " pred_class = _max_class(probs)\n", " res = SaliencyResults(\n", " ref_img=np.copy(img),\n", " ref_sal_maps=sal_maps,\n", " gt=ground_truth[idx],\n", " pred_class=labels.index(pred_class),\n", " pred_prob=probs[pred_class],\n", " )\n", "\n", " _generate_augmented_maps(idx, additional_params, res, img, len(images), image_classifier, saliency_generator)\n", "\n", " results.append(res)\n", "\n", " for result in results:\n", " # Plot each image in set with saliency maps\n", " if display_maps:\n", " display_results([result], display_labels)\n", "\n", " # Compute metrics\n", " compute_metrics([result], metrics)\n", "\n", " return results" ] }, { "cell_type": "markdown", "id": "c15e781c", "metadata": {}, "source": [ "## Running the \"Application\" " ] }, { "cell_type": "markdown", "id": "bb49c99a", "metadata": {}, "source": [ "### Classifier \n", "\n", "We'll use a Hugging Face model conforming to the `maite` image classification protocol, along with the relevant `xaitk-saliency` adapter." ] }, { "cell_type": "code", "execution_count": 8, "id": "f1828e9f", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.48, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/data/barry.ravichandran/envs/nrtk/lib/python3.9/site-packages/torch/cuda/__init__.py:734: UserWarning: Can't initialize NVML\n", " warnings.warn(\"Can't initialize NVML\")\n" ] } ], "source": [ "class HuggingFaceClassifier:\n", " \"\"\"MAITE wrapper for HuggingFaceClassifier\"\"\"\n", "\n", " def __init__(self, model_name: str, device: str) -> None:\n", " \"\"\"Initialize HuggingFaceClassifier\"\"\"\n", " self.image_processor = AutoImageProcessor.from_pretrained(model_name)\n", " self.model = AutoModelForImageClassification.from_pretrained(model_name)\n", " self.device = device\n", "\n", " self.model.eval()\n", " self.model.to(device)\n", " self.metadata = self.model.config.id2label\n", "\n", " def __call__(self, batch: ic.InputBatchType) -> ic.TargetBatchType:\n", " \"\"\"Run classifier for batch and return results\"\"\"\n", " # tensor bridging\n", " input_tensor = torch.as_tensor(batch)\n", " if input_tensor.ndim != 4:\n", " raise ValueError(f\"Invalid input dimensions. Expected 4, got {input_tensor.ndim}\")\n", "\n", " # preprocess\n", " hf_inputs = self.image_processor(input_tensor, return_tensors=\"pt\")\n", "\n", " # put on device\n", " hf_inputs = hf_inputs.to(self.device)\n", "\n", " # get predictions\n", " with torch.no_grad():\n", " return self.model(**hf_inputs).logits.softmax(1).detach().cpu()\n", "\n", "\n", "jatic_classifier: ic.Model = HuggingFaceClassifier(\n", " model_name=\"aaraki/vit-base-patch16-224-in21k-finetuned-cifar10\",\n", " device=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "id": "935845f7", "metadata": {}, "outputs": [], "source": [ "ids = [int(k) for k in jatic_classifier.metadata]\n", "classifier = JATICImageClassifier(classifier=jatic_classifier, ids=ids)" ] }, { "cell_type": "markdown", "id": "8319a32a", "metadata": {}, "source": [ "### Saliency Generator \n", "\n", "We'll use the `SlidingWindowStack` blackbox saliency generator." ] }, { "cell_type": "code", "execution_count": 10, "id": "8c54b646", "metadata": {}, "outputs": [], "source": [ "sal_generator = SlidingWindowStack(window_size=(2, 2), stride=(1, 1), threads=4)\n", "sal_generator.fill = (128, 128, 128)" ] }, { "cell_type": "markdown", "id": "1e6c311e", "metadata": {}, "source": [ "### Results \n", "\n", "Note: for clarity, we'll only be performing the saliency analysis with respect to the groundtruth class, but this analysis could also be applied to the predicted class, which may be useful in cases where the groundtruth and predictions may differ." ] }, { "cell_type": "code", "execution_count": 11, "id": "b87f23da", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Generating saliency maps for reference image (image 1 of 2)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1626/3894463287.py:17: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /pytorch/torch/csrc/utils/tensor_new.cpp:254.)\n", " input_tensor = torch.as_tensor(batch)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Generating saliency maps for s_y=0.0001 (ref image 1 of 2)\n", "Generating saliency maps for s_y=0.00012 (ref image 1 of 2)\n", "Generating saliency maps for s_y=0.00014 (ref image 1 of 2)\n", "Generating saliency maps for reference image (image 2 of 2)\n", "Generating saliency maps for s_y=0.0001 (ref image 2 of 2)\n", "Generating saliency maps for s_y=0.00012 (ref image 2 of 2)\n", "Generating saliency maps for s_y=0.00014 (ref image 2 of 2)\n" ] }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "╒════════════════════════════════════╤════════════════════════╤════════════════════════╤═══════════╤═════════╤════════════╕\n", "│ Perturbation │ Pos Saliency Entropy │ Neg Saliency Entropy │ Entropy │ SSD │ XCorr │\n", "╞════════════════════════════════════╪════════════════════════╪════════════════════════╪═══════════╪═════════╪════════════╡\n", "│ Ref Image │ nan │ nan │ nan │ 0 │ 1 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼─────────┼────────────┤\n", "│ ksize={'s_y': 0.0001, 's_x': 0.0} │ nan │ nan │ nan │ 1.96527 │ 0.0305446 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼─────────┼────────────┤\n", "│ ksize={'s_y': 0.00012, 's_x': 0.0} │ nan │ nan │ nan │ 2.19786 │ -0.0597583 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼─────────┼────────────┤\n", "│ ksize={'s_y': 0.00014, 's_x': 0.0} │ nan │ nan │ nan │ 2.35234 │ -0.124607 │\n", "╘════════════════════════════════════╧════════════════════════╧════════════════════════╧═══════════╧═════════╧════════════╛\n" ] }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/jpeg": "/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACpATsDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiuSl8Sa9NrOq2emaNp00Gn3C25ludReJnYxRyZ2iFuMSAde1AHW0Vyn9s+L/8AoAaL/wCDeX/5Ho/tnxf/ANADRf8Awby//I9AHV0Vyn9s+L/+gBov/g3l/wDkej+2PF//AEANF/8ABvL/API9AHV0Vyn9seL/APoAaL/4N5f/AJHo/tjxf/0ANF/8G8v/AMj0AdXRXKf2z4v/AOgBov8A4N5f/kekOteLwP8AkAaL/wCDeX/5HoA6yiuSGueLj00DRf8Awby//I9OGs+Lz/zANF/8G8v/AMj0AdXRXKf2x4v/AOgBov8A4N5f/kej+2PF/wD0ANF/8G8v/wAj0AdXRXKf2x4v/wCgBov/AIN5f/ketPwzrE+u6KL25tY7WcXE9u8UcpkUNFK8ZIYquQSmeg60AbFFFZviDVDofhzU9WEImNlay3HlFtu/YpbGcHGcelAGlRXmEvxR1aKQodE0hiMcrrDEf+iKl/4WVrJRX/sTRsEZx/bLZ/8ARFa+wqfymP1il/MelUV5u3xG1tSB/YmjHPprL/8AxilHxE1vH/IE0Yf9xl//AIxR7Gp2D6xS/mPR6K87HxA1wqG/sbRMH/qNP/8AGKcfHuvYB/sXRTn01l//AIxS9jPsP29P+Y9Corgf+E38RZx/Yejf+Dh//kenjxl4jIyNE0X/AMHL/wDyPS9nPsP20O53dFcQfFviMKCdH0IZ9daf/wCR6JfFniSLO7RtC4GeNaf/AOR6OSXYftIdzt6K89fx7rqZ3aNogx/1GX/+MUjfEDXFQMdH0PB9Naf/AOMU/Yz7E+3p/wAx6HRXm0vxH1uJCx0PRyACfl1hv/jFVoPixqD6jY202hWCpc3UNuWi1NnZfMkVMhfKGcbs9RT9jUtewlXpt2Uj1KiisK48beFLS5lt7jxLo8M8TlJI5L2NWRgcEEE8EHtWRsbtFc9/wnvg/wD6GrRP/A+L/wCKrYuJJ5tPeTTXt2mdN0DykmM56E7eSPpQBZorA8Iavf6xpNxLqYtvtVvfXNo5tkZEbypWTIDEkZ2561v0AFFFFABXH6N/yMXi3/sKR/8ApHb12Fcdo5x4i8W/9hSP/wBJLegDcopM04UAJQKXFGKACk7Ujnbj3oz8pNACFsVDLMFQnI6HtUcs+CevX0qhc3JETcn7p7VSRLZdguQy9R19KtxNuUGuetLk4wSevoPStqyk3oPof50NAmW6SloqSgrN8B/8i5N/2FNQ/wDSuatPFZngT/kXJv8AsKah/wClc1AHTVzvj7/knfiX/sF3P/opq6Kud8ff8k78S/8AYLuf/RTUAeFPFKZ8lew7+1W8OIlGB0FV7hLqOdsyLwB0Ht9KSSWdYlO8du1fS7nzRqKrM65Hep3hIQnmsyG4uGkUeYOo7CrszXX2dmEi8Y7f/WqGncRMI28oYFXYYWdBx0A71lQTXBQBpAfwH+Fatu02z746DtUSuVG1zYa0fdwp/MVYhspGQfKfzFSRrI7DLCtezs2aFTle/c+tccp2R2Qp8zMC5tbn5AsYOM9x/jT721uef3Yxs9R/jW/Jp0jEcp+ZpuoWciI5yvEZPX61Kq6ot0XZs8/vbecb/k9O49qpSLIIlDKBitnUo5x5pDr2/p7Vg3L3ATHmD73p/wDWrug7o4JKzEnJML/7prDt3ZfFmgx4G06lZn/yYSr1zLcLC/7wfdPYf4Vh2M07+NfD4dwV/tKzyMD/AJ7rRW0pS9Ga4ZfvI+p9XV8ma7aeb4p118ddUu//AEe9fWdfM19beZrmtNjrqt5/6USV52ASdV37f5Hp42XLTT8zrfgRAItU8SKVH+ptDyPeavZro3K2kps44pLkKfKSZyiFuwLAEge4Bryf4Nx+Vr3iJcf8u1mf/Hp69erDEq1WRth3elFnK+DNM1/SEvoNXg0xYri7uLxHtLqSRg0spcqQ0a8DdjOecdK6qiisDYKKKKACuG06Ux+J/Fgx/wAxKM9f+nS3rua8vecxeMPFIG3/AJCEfX/r1gppXZMnZHXic46H86tRtuXPvXKJeEjqldBZS7oGOR97+gptCTL1LUHmDd1FP3gAHIqSxly21o8dzSqf3R+tVLmdWeL5l4Pr9Keky7CNy9fWgVypOTvbk/eNVLhSU69jWgwDMee9OmhGw9ehrSJmzDiXYeDWxp8hAA56Hv71TlQKe/SmpL5bdunemxJm4Zj6frU0bbh+Nc1JeEHqlbVjLvj6j73b8Khou5frK8Cf8i7P/wBhTUP/AErmrVBrL8Cf8i7P/wBhTUP/AErmqSkdLXO+Pv8AknfiX/sF3P8A6KauirnfH3/JO/Ev/YLuf/RTUDPPL/w0rzORcAZC/wDLL2HvWNe+HzFEMXefmx/q/r716bLZOxz5cvQfw+1cvrtpNFDuEMvMuOVPvXr0q8nZXPEq0eW7sYltoQ85f9IH3h/yz/8Ar1qTaGDbsvnjnH/LP/69XbFpHc5TGCO1aoBKHg051ZXFCnFo5H+xNijFx/45/wDXrUtdDPlA/ajyo/g/+vWu1sZBkq/4CrtvDtjAw3AFRKtKxcKCuRR6cVYfvj/3z/8AXrWs4DHEo3k8Ht70sgG0nvSo+2MdK5JSckdkYKLHuDnrTL2PzVYZxlCKilnwRytNknJkA+XmkkynJbGTNoazI2Zhz6x5/rWFf+FwQcXQHz9ovr7130OWiXiqWowskW4K3L+n1rWFeSdrmFTDxavY8w1bQfJtWIuc5Rv+WeO31rkLKzMHjDQCZd+NSs+3/Tda9K1+RmtDgA/u36fSvPot3/CXaDkEf8TKz7f9PC12yblRk32Zy0ly1kl3R9P18/fZTJqGrPjrqt7/AOlElfQNeOabZ+a2pPjrqt9/6VS152Dlyzb8j0MdHmppeZo/CyIw+JvEKn/n0sz/AOP3FepV554Dh8jxjr6/9ONkf/H7mvQ6yru9Rs2w6tSigooorI2CiiigAryLUZQnjTxQCcf6dF2/6dYK9drwjxNei3+IPiWPMgzdRN8vT/j2hq6e5M9joIpgV+929K6SyuQsDDfj5vT2FcHY3JkjzufoOprdivNvG6Tk+tXJEI6ZbjMnD/pU80+yFTux07ViWk29kOW5z1q9dtm2TBPUfyrNItsw31bcy/v/APxz/wCtViHVM/8ALbv/AHf/AK1crtk3D5+/rV22STGd3f1rTlM7nWQXYc/fzxnpWw7Axtz2NcjauVPJP3fWtxroBG5fpU2GJOR+lUpD85ps90M9X6VSkuhvPL0xWHTk7hj1Nb1jMETBbHzen0rnDMG9fxq2lztIGX69jQxnXRTBlB3fpVHwHz4cm/7Cmof+lc1VrW6zEnL96n8AHd4YkPrqWoH/AMm5azaLizqK53x9/wAk78S/9gu5/wDRTV0Vc74+/wCSd+Jf+wXc/wDopqRRoYDIAPQVh61ZyTW4Ajz+8z1Hoa0bQyP5fznkdz7Vant2mjCjbkHPNbRfIzCcfaRZyFpZTBziPqR/EK0lsp/+ef8A48Kvx2EkTZJTr2qVsoev5VrKpd6GEaKS1KQs5RGB5fP1FTpZT7QRH1H94VIJcuRk9KuGYJHHnPI7VnKUjWMIlb7LKeqcfUVBPE0Q5GOfWrzT54XcKz9RjlkiBSTHzDufSiLbeoTSS0M65mCsPm7ntUTTFpkIb07VQvNPvXfK3AAyf42/wq7Hpl0JFzKh5H8R/wAK6bRS3OS8m9jYtZztQFvXtUl+We2QDn5gf0NVBayxLy449CafPHM0CASenc+lYWV7nRd8tmcbrNpd/ZG+T/lm/celcEtrcx+KdCeRMKNSs8nI/wCfhK9Z1iwna1Yb0yUfHJ9K4G6024g1fR5pJEKrqdlkAnP/AB8p7V3KonRkvJnFyONaPqj3yvNvD1v5lpfN66rf/wDpVLXpNcT4Ti3aVeHH/MV1D/0rlrzKcrM9SrHmjYPC0fleOtdX/qHWJ/8AIlzXbVyWiJs+IOuD/qGWP/oy6rramTu7lwVopBRRRUlBRRRQAV81eO2b/ha/iNAMjfCf/IEVfStfOPjKMN8WvEjEfxRD/wAgQ1dP4iZbHSaBag2EZIcZijP6VZdP3i9ag0u9ihsol8zGI0GNp9Kd9sjLA+Z+hrZxuZ3N2w+WOP8AH+taxYNGoyO1ctDqUaqo83GP9n/61XE1ZMD9/wBv7n/1qSpjciwbNAy8v1qZoEjibk/iaotqcZZf33f+7/8AWqO51NdpAm7f3f8A61NQZDZIzBXOCOtJLcYA5Wss3ylj+87/AN2q9xfgbf3nr/DTUAuaMkue4qrJJz1FUvt67T+8/wDHarTXwzxJ3/u1XIK5rpKMdVqwJx6r+dc8l7x/rP0qdLvP8ff0qXGw0zpobvEajKfnXS/Dc7vBwb1v74/+TUtefxXBOPm/Su8+GJz4IiP/AE+3v/pVLWMzSB2Fc74+/wCSd+Jf+wXc/wDopq6Kud8ff8k78S/9gu5/9FNWZoWLAbIYvYd6v53cVUhidETjGB61P8y81ctTOGiEA/dvnjiqwRT1OPxqaYkL8vcGqLi4/h/pRTjZWFVld3sR3SRKxJfuOpHpTzGksUfzZwOxqhewXsn3VzyO49Ks2cN2IgHXoB3FbtWV7nOneTViQQAOPvVcWDdbqMN17UvkSZ5X9asRHYgU8EVlKZvCn5Ga2nhnY4k6+n/1q0PKjXnfyOeop+/BPNRsF/SsqlR9DWnSSeoEJINpbg+hqJrcdt2KcoGan3qFHPNTCo+pdSkuhWvYFeBgNxyrDj6Vx3iGyMVlYybZBjVbDkjj/j6irt2ZW6HNYHi/A0a0Hf8AtbT/AP0rhrZVLRtcwdK8lJo7CuT8G7f7Gu8/9BXUf/SuausrifCUu3SrwZ/5iuof+lctYzlyq50QhzOwxp9Yh+Imq/2PYWN1nS7Lzftd40G397c4xtjfPf0xgdc8b3im8vLDwRrN7bgJfQafNKmw7tsgjJGDgZwfas7RW3/EHWz/ANQyx/8ARl1XVuiujI6hlYYKkZBFNO6uTJWdjz3TtKsPD3ifwn/Yy+WNStZ1vCrE/aVWNXEr/wB5g2Pm6/OR3r0OsXSPCeiaFcm506yMUvl+UrNM8nlx5zsQMxCLkD5VwOB6VtUxBRRRQAV80/EC5Fv8UfERO7mWEfL/ANe8VfS1fKfxafZ8T9f4z++h/wDSeOqi7MT2JbfW8JgSXHAA6/8A16sHVyB9+f8AP/69efQ3agvkD/vqtN7hSp6dPWt1Mz5bs6v+3Mf8tLj8/wD69PXX/wDppc/99f8A164Ka6AzwPzqqb1QT8o/76p+0HynqEeu7mA33HUdT/8AXqWTVS38c35//XrzWxv1a5jXaOXUfe966uJTLCWAPXHHNaRmrE8jb0NxdS5+9L+f/wBeoJtQzj5pfz/+vWTsYHofyqMox7H8qrmQeykaovyRjdJ+dL9pL/xP+JrMjQ56H8quQxn36elS5oPZsvwyEj7x7d6uRMcjk9aqQoQv4DtV+CMll6/e9KylNFKFjStQTs/GvRfhjx4Hh/6/b3/0qlrh7C3YmPr37fWu6+Gox4MQel9ff+lUtYSdyo7nXVzvj7/knfiX/sF3P/opq6Kud8ff8k78S/8AYLuf/RTVJRZDOoGXPQd6huXl8sbZGHPqai85dw6dB39qdI2YxgZroSsczdyItOSP3rf99Gl/ehTmQ/maJ2IA+U96pvMR1T9atK5m3YtHzCPvn86l3uqrh2HHY1mrNuY/L+taVurFAdp5A7UpKwRd9i7G7EcsTz605ycdTUq5x0ofpWHU6dbDQw2jjnFIXXPSopBzTCBkc0+VC5mTFlzwKnVAVBwOlVtmVwDU0Z2gZHaplFFRk7j1QDOQKwPGQH9i2uAP+Qrp3/pXDWzcSgLnjoe9cv4pnR9NslBGTqun9/8Ap7ioUNLjdTWx3dea+Hrny7S/XPTVb/8A9Kpa9KrxrTrzym1JM9NVvv8A0plrkxTtBep34CHPUa8v8jr/AAtJ5vjrXW/6h1kP/IlzXbV534Bm87xhr7f9ONkP/H7mvRK1ou9NGOJjy1ZIKKKK0MAooooAK+U/i7GW+JOvsB/y3hH/AJLx19WV8wfFOEP8QPEDYH/H1CP/ACWjpMGeVl9kjjjrV8XQKnkfkaoXEe24k6ffP86QMcdadwRNNMDu6VTZ+TUjknNRbcmi42WLKXZeQnjiRT+tei6PKk1o3P8Ay0I4HsK81iBWVG9GBrsvD96ywlSTzIew9BQ5tI6cHBTqJM6J0XJ5PWoSq+pqFroknk9fQU6Jy7Yz3qFVZ6FajTjsTIgzVyBOPwqKGEt6davwQ49OlP2jZ5s7Ikij+X8q1bWAll6/eHeq0UI29ugrYs4hlen3xTTOaTNaxt8eX179/rXU/DkY8IY9NQvv/SqWsO0jACfjW78O/wDkUj/2Eb//ANK5aZMWdVXO+Pv+Sd+Jf+wXc/8Aopq6Kud8ff8AJO/Ev/YLuf8A0U1BZix3cpkXKrjH9K0VuMRr06DtXOWsk5kj3uDxzx7VfklmVBhwPwr0JQ6HlxqPc1Jbgle3Q9qzbm4cdAvSopLmU4G/9BVeTz5Dw4xjvRGFhTqXJormQOTtXpXTWMm+3QnH3V/lXIbZkGd61vafPKIAN3RV7D0qasdNC6E7PU6EthDURck9qi81mQgH9KhaV1c/N+lcyidjmTtyeaYR8wqpLdSKRhv0FSbpd4+YflVcrI5ky4rBQMmplO/p9aqeXI65DDmrcSlFBYg8Y4qJWRrG70KmoYjgY/7Lfyrh9fuN8enpxg6pYdv+nqKux1wTCyco4B8t/wCVea6jJdm60tZZVZDqljkAD/n5j9q3pxvTbOWrO1WK9D2uvnprwRalq6Z6are/+lElfQtfLeqXfleIdbTPTVbz/wBHvXmYmPNCx9Jk0eau15fqj1D4VTef4l8QtnpaWY/8fuK9Urxz4JTedrXiNvS3tB/49PXsdaUlaCRyY5WxM15hRRRWhyBRRRQAV80fE1c+PPEP/X5D/wCk0VfS9eWeKvhHd+I/Eeo6pFr8NrHeSpJ5LWJkKlY1j+95gz93PTvSauhM+brmAee545Y9veqxiA9Pyr3l/wBnm5kYk+K4sk5400//AB2oz+znOf8Ama4//Bcf/jtSkwPBzEP8ijyh7flXu/8AwzjP/wBDZH/4Lj/8do/4Zxn/AOhsj/8ABcf/AI7TsxnhSwjPb8q2tJyhAB/iP8q9cH7Oc4/5muP/AMFx/wDjtTw/s/XcByviqE85500//HaUk2aUp8krnm0a7jye1a1pAN/bqO1d8nwO1FDx4ptumOdMb/49VqP4O6tGcjxPZ/jpbf8Ax6o5GbTxHMcZHCqjoPyqzEg9vyrsR8J9ZA/5Gax/8Fb/APx+lHwq1of8zNYf+Ct//j9Uos5pO7ObhQbfwHati0QZHT73pWkvwy11BgeJdP8A/BU//wAfqxH8P/EUeNviPTOuedKf/wCP1SRm0yS3GEX8a2Ph3/yKZ/7CN/8A+lctZyeDvE6AAeItK4/6hMn/AMkV0XhbRJvD+hJp9xdJdTefPM8qRGNSZJWkOFLNgDfjqelUOKaNmud8ff8AJO/Ev/YLuf8A0U1dFWb4g0s654c1PSRMITe2stv5pXds3qVzjIzjPrQUcd9lERBDdAO2O1Q3DsqDk9fWrreDfE7dfEWlf+CmT/5IqGTwJ4jlGG8R6Z1zxpL/APx+u1V4dTz3hp9CgrM7D5zwfWrUY+Xr3qRfAXiNDx4j0z/wVP8A/H6lTwX4mTp4i0r/AMFMn/yRTdeBKwtTqQOvyD61PA7qpAZu3enN4N8TN18RaV/4KZP/AJIpP+EM8Tf9DFpX/gpk/wDkip9tBlLDzTNu1DMvLk80+S3LMT5hH4VmReHPFkQwviDR+uedIk/+SKk/sPxd/wBDBo3/AIKJf/kisXNX0OlU3bUuNY7sZl/8dqwLY7gd/wClZn9h+Lv+hg0b/wAFEv8A8kU8aT4wH/Mf0T/wUS//ACTUuY1TsbccWEAz+lPIwB3rD/szxjtx/b+if+CeX/5JqvL4f8WzD5vEGjDnPGkSf/JFTdPc0s1sL4jncWD4Zh+6k6N7V5lNJI+paRukdh/allwST/y8x13V14E8R3abJPEelgYI+XSZO/8A23qlb/CzVUvbKafxFZyRW93DcsiacyFvLkV8ZMxxnbjoa64Vqcabj1ZwzoVZVVPoj0+vkLxHc+X4t15cjjVLv/0c9fXtYVx4K8K3dzLc3PhrSJp5WLySSWUbM7Hkkkjkn1rhaue1hMS8PNzSvpY8s+AMyvqPiRiw/wBVaDr7zV7hXPf8IF4P/wChV0T/AMAIv/ia2LixhudPaxzLDCyBB9mlaFkA6bWQgr+BoSsZVqvtajn3LNc9beIb5/Gb6DdaUlvEbWS6guRdBzIqSInKBflzvz949OlEHg6wt7iKddQ11mjcOFk1q6dSQc4KmTBHseDWXctrY+JFvqMfhq9ksIrKSxNwLi3AJeWNvMCmTdtAQ9s+1MyO1ooooA4PQBrdz8ONQ1axubybXdQiuJrU3Eu5Q25/J2JIdiLtKcYAPGa07nxZcf8ACWT6FZWFpLJbiMyG5vxBI4cZzFHsO8AdTkc5FO8DWd9pOgnR76wltjZTSrHIXRo5o2kdkKbWJAClRhgMUzxJ4SvPEk7RXGp2qacXR1jNgGni2kE+XNv+UkjOdpIzQB1VcrB4y87T9PcafjUbrUm057Pzv9U6M3mEtt5CojP0GRjpmrX/AAmekef5OzVd+7b/AMgi7xnOOvlYx79KxtD0YXfxG1bxAsF3BYxoI4I7mFog9ywVZpUVgDjZHEu7ofmxQBu2V7qllb41S1ubiWfU5YYfIRG8uAyN5TvtPChAuT15Geab4u1S70vR4hYMiXl5dwWUMrruWIyyBS5HfAJOPUCtS9gu5zbfZLwW3lzq82Yg/mxjOU5+7nj5u2Kq+INFTXtKazad7eVZI54J0ALRSxsHRgDwcEDjuMigDM0O81K08Uah4f1K/bURHaQ3tvcyRIkm12dGRggCnBTIIA4b2qHULnWdY8WX2j6Xqp0yLT7OGZ5EgSRpZZWk2g7wfkAj5xgnd1GKsWfhvUoG1W/m1pJNbvrdbeO8S0Cx2yoG2bYixzhnZjluSe1GpeG9Qm1VtU0nWhp95Para3TPaiVZVUsVYDcu1wXfB5HPIOKAMTTvEer+LToVpaXv9kyXOmNf3k0ESSNvDrGEQOCAu7cSSCcADjrTbXxJrWrw6LpCXiWeo3F1e295ewwqxxasUYorAqC52HkEDJ4rXPgtrCPSW0DUfsFzptobJZJ4PPWaE7SQ67l+bcoYEEck9QaaPBJtdN0tdO1N4dT06aWdb2aESCZ5Sxm3oCuQxYnAIxgYPFABotzrOsaZqumyasYNQ03UGtGv47dC0iBUdW2EbQxWQA8YyDxS+HfEzj4aaVr+rytPcTWkbvsQB5pWwAqqMDczEAAdzVuw8P3+laNdQ2WqRf2pd3LXU97cWu9HkYjP7sOuBtUKBu4AHWqug+DBZeFYfDuvTWOtWNuiJAj2PlgBem4F3DH34oAb4O1HW7rVfEFprdxG8trPD5cUaKFgEkSyGMEDLYLY3Hk4zx0rqZ/M+zy+T/rdh2fXHHWuTsfBlr4Um8Qat4e06yN9dw/6HbJAsQjKxgCPdkfKzqGPTr+NdZB532eL7QYzPsHmGMELuxzjPOM0AccfFeradLpGiXFlaTa1LpsVxcm8vltleQ/Kyx7UYO24EkDAAI55FdmhYopZdrEcrnOD6Vzvinw3feI4pLRdQsorCaHy5IbjTxcMCc5dGLja2COoOMZoXxNo+jommN/a7taKIC/9l3Uu7aMZ3rGQ3TqDg0AQXvjKWz119BOku+qyTILOISny7iA8tMX2/IEw24YJBCgZ3Cr4vdT0+XWrm9tbm6tVu4lsIrZEeQxNHErEAEHAkMhO7nAPbFZk/g46hqT6+NUddYM6S2VyYCBbQAf6jyywJVgzbskEls8bQB0uowXdzZPFY3gs7gspWYxCTADAsNp45AI9s57UAUPFmsS6B4V1HVII1knghJiV/ulzwufbJGay9OudY0jxbaaNqmqnVIb+yluI5XgSNopYmQMo2ADYRICM5I29Tmt/WdKt9d0W80u73CC6iaJyhwy5HUH1HUfSsnTfDeoQ6t/auq6yt/exWrWlsyWohWJWILMV3NuclVyeB8vAFAEet3mpXnimx8P6bqDacr2kt7cXMcSSSYVkRUUOCoyXJJIP3eMZrMe51LxD8OdVMlxcprOmvdwpNYSPCZZ4C6IwCnkNgEocjJ6cCta78N6lM+l6hBrSR63ZWzW0t49mGjuVbaX3RBhj5kVhhuPeqmo6Jd6N8Pr7R9Lt7rVL+8juEaVWjjZppt7NK5ZlAXc3bJHGAaAN3w9q9trmg2d/a3cNyskS73iYEB8DcDjoQeo7VkjxZcXHiy60SzsLR/sksccxnvxFMQyqxeOLYS6gN1JGSCB0re0qyXTdJtLJERRBCkeIxheABxWBrnhK81/UI2u9TtfsMVxHPGgsB9oj2MG2pNv+UEjk7c4JGaAMPwh4s1SHQtEOpWEstne3b2Yv5LvfKZDI4UlCPuZG0HdnpxirzeMXsbRWs9JnuprnxBPpaxPek/MPMO/cwO1cx/dHCg8Zxg3rfwZ5Hh7RtK+37v7Nv0vPN8nHmbZGfbjdx97Gcnp0rH1zwpfWy6RBp91M0sniaTUWuI7fcLcPHO3zDJyoLKpJIznsTQB0+g67NqlxqFjfWIstRsJFWaFJvNQq67kdXwMgjPUAgg1t1iaDoU2l3GoX19fC91G/kVppkh8pAqLtRFTLYAGepJJJrboAKKKKACiiigAooooAKKKKACiiigAooooAK8mv/GGpW1zrElv4oWTVLbVza2mgmOBjPHvQbQoXzehb5t2BivWaydE0NdGfUn84TNe3sl3ny9pTfj5epzjHXj6UAYR8dTRrrd5PpCxaTo080FxdNdDe5RQRsTbzklRywAz1PNV9P+JunzT3EV9/Z6CKylvg2n6kl4AkYBdX2gbXwQQOQcHB4rXHg+2l0bXdLu7h5YNXupbhii7Gi3gYAOTkgqCD+lJD4b1G4tLux1vVra+sri1e2dILAQOwcYLM29snGegUc9KAMZNf1y98ZeFY73TZNMt7tLmURx3nmrKoiBCyABcMMg4+Yc8Hiu0069OoWYuDa3Nrl3TyrlNjja5XOMng4yPUEGubsfCOqR63o+o6l4gF6ulRyRQxLZiLerpty53nLcDnAHsM10mnQXdvZiO+vBeTh3JmEQjypclV2j+6pC574z3oAwNF8WXGua1c2tvYWi2ttcS28rNfj7ShQldzQbOFJHHzZwQcVheEPFmqQ6Foh1Kwlls727ezF/Jd75TIZHCkoR9zI2g7s9OMVuP4SvLzxJZarqGp2sq2M7TQeTYCKc5VlCPLvOVAboFGcDNFv4M8jw9o2lfb939m36Xnm+TjzNsjPtxu4+9jOT06UAUW8YvY2itZ6TPdTXPiCfS1ie9J+YeYd+5gdq5j+6OFB4zjB3dB12bVLjULG+sRZajYSKs0KTeahV13I6vgZBGeoBBBrmNc8KX1sukQafdTNLJ4mk1FriO33C3Dxzt8wycqCyqSSM57E10+g6FNpdxqF9fXwvdRv5FaaZIfKQKi7URUy2ABnqSSSaAKDatL/wAJXr08kkv2PRLBAIFchZJHDSOxHQkKqAZ6Zb1rL0vVtftJPC9/qeprd2+vkRy2ogRFtXeFpk8sgbiBsKncTnOeOldANFkj8Vahd7Ek0/U7NIrlSeVkjJA47hkcg+mwetUNJ8G3NjdaUL3WWvbHR1Yafbm3CMp2GNTI+47yqEqMBeuTk0ATeONWvNI0yyktbprWOa9jhuLiOISyxxkNzHGQd7bgowAxwScHFZugeLZl0LVby8uZdRS3vvstgXhWG5uSVXajxgDY5diBlV+XDEAc1q6h4c1C/t7CV9ZA1SwvJLm2ujagoAwdRG0YI3AI+3IIJxnimWnguzljv28QC21me/uEuJjLaqsQZECIFjJbGFHUknk80AUPD0mu61pXijTdV1M/bobxreGe2Ai+z7oInAQqASFZzgnJIHNb/hbV317wppWqyKFlurWOSRR0DkfMB7ZzWPp3guDwtb+ILnw/aWaX1+zPaqkIiWH92qrGSM5UMpft948evQaHpUWh6DYaVAS0dnbpArHq20AZPuetAF+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA//Z", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "╒════════════════════════════════════╤════════════════════════╤════════════════════════╤═══════════╤══════════╤══════════╕\n", "│ Perturbation │ Pos Saliency Entropy │ Neg Saliency Entropy │ Entropy │ SSD │ XCorr │\n", "╞════════════════════════════════════╪════════════════════════╪════════════════════════╪═══════════╪══════════╪══════════╡\n", "│ Ref Image │ nan │ nan │ nan │ 0 │ 1 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼──────────┼──────────┤\n", "│ ksize={'s_y': 0.0001, 's_x': 0.0} │ nan │ nan │ nan │ 0.930894 │ 0.437872 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼──────────┼──────────┤\n", "│ ksize={'s_y': 0.00012, 's_x': 0.0} │ nan │ nan │ nan │ 1.06851 │ 0.292293 │\n", "├────────────────────────────────────┼────────────────────────┼────────────────────────┼───────────┼──────────┼──────────┤\n", "│ ksize={'s_y': 0.00014, 's_x': 0.0} │ nan │ nan │ nan │ 1.14059 │ 0.221284 │\n", "╘════════════════════════════════════╧════════════════════════╧════════════════════════╧═══════════╧══════════╧══════════╛\n" ] } ], "source": [ "results = generate_perturbed_sal_maps(\n", " images=imgs,\n", " ground_truth=ground_truth,\n", " image_classifier=classifier,\n", " saliency_generator=sal_generator,\n", " display_labels={int(k): str(v) for k, v in jatic_classifier.metadata.items()},\n", " additional_params=[{\"s_y\": 1e-4, \"s_x\": 0.0}, {\"s_y\": 1.2e-4, \"s_x\": 0.0}, {\"s_y\": 1.4e-4, \"s_x\": 0.0}],\n", ")" ] }, { "cell_type": "markdown", "id": "a75e2421", "metadata": {}, "source": [ "We can visually see that as the quality of the input image degrades (more perturbation), the quality of the generated saliency maps similarly degrades.\n", "\n", "In an attempt to quantify these differences, we've also computed several metrics:\n", "\n", "#### Entropy \n", "\n", "If we compare entropy values using both positive and negative saliency we don't see much of a change across degradations. This is likely due to negative and positive saliency \"fighting\" each other as degradation increases (as one increases, the other decreases).\n", "\n", "If we consider entropy values computed from only positive or only negative saliency values, we see differences in values. Looking at the dominant saliency type (i.e. positive/blue) for the ship, we can see that as degradation gets worse, entropy increases -- to a certain point. The reduction in entropy likely corresponds to the classifier being less able to identify key features that led to the original probability distribution for the reference image due to the degradion. Eventually these features may become so degraded that the classifier begins predicting with very low confidence. Looking at the domainant saliency type (i.e. negative/red) for the cat, we see similar changes as the other reference image; however, the positive and negative saliencies are significantly closer. This could be a sign of less definitve features used for identificantion. Since this does not c\n", "\n", "If we look at the opposite saliency type for each reference image, we see a very slight decrease in entropy as degradation increases. This potentially indicates that the degradation introduces noise that the classifier misidentifies as a contraindicator for the ground truth class, but more likely corresponds to the classifier predicting with less confidence due to the loss in higher quality features.\n", "\n", "#### Sum of Squared Differences (SSD) \n", "(0 is most similar) The sum of squared differences lets us quantitatively confirm that as degradation gets worse, saliency maps are increasiningly dissimilar to the original reference saliency map. However, the metric doesn't give us much insight into what is actually happening to create these differences.\n", "\n", "#### Cross-Correlation (XCorr) \n", "(1 is most similar) Cross-correlations tell us similar information as SSD. The introduction of negative correlation values, however, potentially indicates that the saliency maps begin to become the \"opposite\" of the original reference saliency maps. The aligns with the pattern we saw with positive/negative saliency entropy -- we see an introduction of the opposite saliency as the image becomes more degraded and the classifier becomes more confused. The likely doesn't occur with the ship reference image as it was more strongly salient in one direction compared to the cat reference image was contained a more balanced mix of both positive and negative saliency.\n", "\n", "While aspects of model explainability and model robustness have previously been studied independently, this notebook provides a preliminary exploration of their relationship through quantification of how saliency maps change due to various perturbations. Future work will explore whether quantitative changes in the structure and quality of saliency maps provide a mechanism for understanding model failure modes and edge cases due to various perturbations." ] } ], "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.9.21" } }, "nbformat": 4, "nbformat_minor": 5 }