{ "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` 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)\n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Kitware/nrtk/blob/main/docs/examples/maite/jatic-perturbations-saliency.ipynb)\n" ] }, { "cell_type": "markdown", "id": "d9e7b4e6", "metadata": {}, "source": [ "## Set Up the Environment \n", "\n", "**Note for Colab users**: After setting up the environment, you may need to \"Restart Runtime\" in order to resolve package version conflicts (see the [README](https://github.com/Kitware/nrtk/blob/main/docs/examples/README.md#run-the-notebooks-from-colab) for more info)." ] }, { "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": [ "from __future__ import annotations\n", "\n", "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 nrtk[pybsm,headless]\n", "print(\"Installing Hugging Face datasets...\")\n", "!{sys.executable} -m pip install -q datasets>=3.4.0\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": 2, "id": "a14d93f4", "metadata": {}, "outputs": [], "source": [ "from collections.abc import Hashable, Sequence\n", "from dataclasses import dataclass, field\n", "from typing import TYPE_CHECKING, Any\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": 3, "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": 4, "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, strict=False):\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": 5, "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": 6, "id": "38449894", "metadata": {}, "outputs": [], "source": [ "def _compute_entropy(\n", " sal_map: np.ndarray,\n", " clip_min: int | None = None,\n", " clip_max: int | None = None,\n", ") -> 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) -> 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 maps.\"\"\"\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=\"plain\"))" ] }, { "cell_type": "markdown", "id": "f7602444", "metadata": {}, "source": [ "We'll also define a function to display all generated saliency maps." ] }, { "cell_type": "code", "execution_count": 7, "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: list[int] | None = 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`, which simulates varying amounts of sensor jitter on image collection." ] }, { "cell_type": "code", "execution_count": 8, "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": 9, "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.52, 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" ] } ], "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: Sequence[ic.InputType]) -> Sequence[ic.TargetType]:\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": 10, "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": 11, "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": 12, "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_1253135/2834420211.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": "/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAC5ATsDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iivN9d+JmoaV4k1LSrbQra4jspEj86S/aMuWjR/uiJsffx17VMpxgryY4xcnZHpFFeVj4ra0Rx4asP/AAaP/wDGKb/wtjWc4/4Rmx/8Gj//ABisvrNL+Y09jU7Hq1FeVf8AC19aH/Ms2P8A4NH/APjFJ/wtjWf+hZsf/Bo3/wAYo+s0f5g9jU7Hq1FeVD4sa0f+ZZsf/Bo//wAYpf8Ahautf9CzYf8Ag0f/AOMUPE0VvIPYVOx6pRXlR+K+tD/mWrD/AMGj/wDxik/4WzrP/Qs2P/g0b/4xR9aov7Qexqdj1aivJz8XNYH/ADLNj/4NG/8AjNH/AAt3V8/8izY/+DRv/jNP6xS/mF7KfY9YoryU/F7Vwf8AkWLP/wAGjf8Axmk/4XBq3/QsWf8A4NG/+M0fWKX8wexn2PW6K8hb4y6qvXwxZ/8Agzb/AOM16B4N8RP4q8MW+ryWi2jyvKhhWXzAuyRk+9gZztz071cKkZ/CyZQlHdG9RRWb4g1Q6H4c1PVhCJjZWstx5Rbbv2KWxnBxnHpVkmlRXIDX/Fpx/wASDRhn11eT/wCR6kGseLyONB0T/wAHEv8A8j1KnF9SnCS3R1dFcn/bPi/IH9gaLz/1F5f/AJHp51bxgBk6Dog/7jEv/wAjU+ZBys6miuMl8S+KYWKtoeiZHprEn/yPT18Q+KmUMND0PBGf+QxJ/wDI9T7SO1yvZTtex2FFcsNV8YMONB0M/TWJf/kalGqeMScf2Bov/g3l/wDkarM9jqKK5Y6r4wHXQtD/APBxL/8AI1C6t4wYZGg6J/4OJf8A5GosFzqaK5Y6r4wA/wCQDon/AIOJf/kahdV8Ysf+Rf0UfXV5f/kagDqaK5R9Y8XpjOgaJ+GsS/8AyPVW58V+I9PNtJfaFpa28t3BbO0OqO7r5sqxghTAoOCwPUVPMr2K5JWvY7WiisK48beFLS5lt7jxLo8M8TlJI5L2NWRgcEEE8EHtVEm7RXPf8J74P/6GrRP/AAPi/wDiq2LiSebT3k017dpnTdA8pJjOehO3kj6UAWaKwPCGr3+saTcS6mLb7Vb31zaObZGRG8qVkyAxJGduetb9ABRRRQAV4L4q/wCSgeJf+vqL/wBJoa96rwTxUwX4g+JSf+fqL/0mhrkxqbpWRvh/j1KcZOKFBPJFMjlQ5wDxUgOCMdK8VprRnqJprQcV70zy9x4p7NwaWNgDluRipuDQrWs8I3OmB16imbs10OtXeltbj7LbTIdj53H24/iNcZdarDaA7lkPGflA/wAa3dFzehn7RLc0GxiqD3yY/dMG9cg1j3OuzuCYJGXLZG5F6Vb0+Ayl/MwcYx+tdVHBW3MKte+w+W+lHO1MY9DTE1MA8ld3cYNX5LCNoyNo/M1mXFgociMKrdySeldjwsbHMsRJMuRX0Mufn5HXANSYyKw5mNkR6t1xz0+v1rQs73z1/i5bHIFcVbDuOx0063MTSR9TXs3wk/5JzZf9fF3/AOlMleOyKcnnivY/hN/yTqy/6+bv/wBKZK2wO7MsTsjtq53x9/yTvxL/ANgu5/8ARTV0Vc74+/5J34l/7Bdz/wCimr0TkGusqrwo6CrMRbaNwA4qx5cbIGK8YHekdEVAQK5nScdTrVZS92wwY3A+9MvJXWJtgBOB1+tBOORWdqOopbA+YHI2g/KB61nKdkawpuUlYx9SmuvOYiNOo/l9atwyzm3i+Rc7Bn8vrUMM8OqXTxxowIXd8/HoO31rT+wyRxp8yYxxya5lFtto7pyUUovctxaikQxKwVs5xg9KvRXSSxLIGG09Dg1jHTJ5rlW3x7MYIJOe/tV7aLW2SHHzKeSOnc13YfnlKz2PMxXs4xunqVLrVWSZlTYcMRyD61Ytr47cPtHzehquNNWd3cqp3HPU96vR2MSqWKDAOTya9CTglY8qCqOVyyskcifK2WPbFOEhHBxxVcyQRJlEYEdKjjnMkhGTjr0rhnON/dPRhTm17xYuAu0YPY1y3ioH+z7L/sK6f/6VxV05y5AJrn/GEe3T7Ij/AKCmn/8ApXFUNXkmi0+WDTO1r5M12083xTrr7c51S7/9HvX1nXzNfW3ma5rLY66ref8ApRJXr4BJ1Xft/keTjZctNPzOu+BMAi1TxIpUf6m0PT3mr2W6NytpKbOOKS5CnykmcohbsCwBIHuAa8n+Dcfla94iXH/LtZn/AMenr16sMSrVZG2Hd6UWcr4M0zX9IS+g1eDTFiuLu4vEe0upJGDSylypDRrwN2M55x0rqqKKwNgooooAK+fvGeR4+8SMGI/0uIY/7doa+ga8W8TQRzeJvExlYqBqcXOQP+XSGplHm0Y07anlkd7cpe3Y8+UgSEAbzxya7ZGypOKTRtGVbm9fE+13BBI4Iy3TirN7CsM6qM/dzz9TXmY6ilZo7MLNtu5CuCMYpjvs7Z5xVzTI47vUYrR2+9nIU/NwCa6q/wDCFlNp0O6S6GSp4I9D/s1y0cM56s6Z1UtDgEnlunCtI4GccsT1qpq9iu05YH5R/D7109lZrDHMy7ycA8/jWTrIaVCNpztHAHvXp0qXKcdSTZzRs0Ea/d/75rY0BleZ1ZQcsg57dayHJQkD7wOCDUOmTPc6hAFUMRKn3Rnqa6GtDmW52WrxiBCUOPlB4GO9YwlA+Zl3E+tb8lvI1u0bxuM/7PNc3qdsIrh/vZyOD9KlNltIy9RkBlBK5G5sD0qhZXLwzxJliDID97HcVrPDkLkMPSsO9gEUoddxKruGfxpyjzRsTF2lc7BW8yEP0z/jXsfwm/5J3Z/9fN3/AOlMteC6LqRe2ghcxLndkZwepPrXvfwnOfh5ZkdPtN3/AOlMtc+Gg4zkb1pc0UdrXO+Pv+Sd+Jf+wXc/+imroq53x9/yTvxL/wBgu5/9FNXacxcyRGDk4wOKJgWhXDEdKlj3Ki4Xt6VKVDAbjis5U79TSNW1ro46/wBVksoGfDv8rHG/HQVxmo69cardLCpkg3JjIlJxgk+1eka5o9rqtm0LySEGN1/dsM8jHoa4dfBlrod2l/CbwmIdZcbecrzhR61wVKcofEe9g61CUb/aNvwVpUiv9qku2l3xMu1l6fMOc59q7EBSSpUHbxXONIz+F7RogHkMpyq84GWqbTPOZH3RkHC/wn3r0sNQj7Lm7ng47FzliXFrY33wkRcDkelU9Qb/AEFJBwxfGe/esXxPqV9a3At7W3WVGiDE7GY53H0PtTPDV7qU10wuLMxp5RIbymGTuHrXPGuo1bJaHTLBynh+dvU6HTpQ8bAr0C9aRrkrKsWDh8DOfXik8t97MFbLHJ4pLWHcQ7ZDBuBXe7O7PLTkrIgmYrdNF1H/ANasOXVZI7qWNVYbWIyHx0Nb2sXMdlbTXTyImzbkyNhRkgc/nXnGsau04Y27QysZS2EO7jnng141a8ZWR9Jg6ftVe2h6iEKkfOTWP4uTOjWjk9NW08f+TcNXdH1CS8W4MgjBQLt29859/as/xe7PpdmWGP8Aia6f/wClcVdtGKlHmR5OIcoS5HudnXz99lMmoas+Ouq3v/pRJX0DXjmm2fmnUnx11W+/9Kpa9DBy5Zt+R5mOjzU0vM0fhZF5XibxCpH/AC6WZ/8AH7ivUq888Bw+T4x19cf8uNkf/H7mvQ6yru9Rs2w6tSigooorI2CiiigArxPxewTWfErE4/4m8Iz/ANucNe2V4l4yQvqviQAj/kMQ9f8AryiprcTJ9DIltvXCJ/KqWqojXaFRxsH8zWxoEIjsIyVXLRJ0HtXFm9c3MaySSsSQOTnvXLjYc0NDow0lGWoslxNpt+b6BvLaPo+AcZGOh+td/ba89xpNo0tzuLRIx+THO36VwOrAHT5mwP4f5irFlelrKCJWkBWNe/HArlwk3yNHRXSUk0dDppiumdI/myQCOR1zVHxDp7W04ZYtoEYP3s9z71v2NmLCXzGSPaGDEIOoFRa/d216dkcRDFAAWUeua61dmEpHnE9izMzpH8zNkndUPgCz+0amzSx7ljmhOc4xyf8ACt68j+zrvbGC2BtqHwMqpcXJVQPmi6D3atFqjF6M7DXPIt5QY/lUIM9Tzk1wGsymS+kKtkZXt/siuz8QOZG2AnJQdfrXE6jBIkzMWBBIHX2oSBsZEUkQB+doFZt1bCRWITPykdaspDLyQ/B9zWi1rmJjhOh7VS0ZJyscD2xEirt2985r6K+DxLfDLTmPUzXRP/gRJXh7wq4MYVcn1Fe5fCJdnw2sF44nuhx/18SVnCSc3Y0l8KO4rnfH3/JO/Ev/AGC7n/0U1dFXO+Pv+Sd+Jf8AsF3P/opq2MzTiLCNS3TFKJEZiuc4qpNdKtvkbhwOlU7W5Mly43P0J5PvVxpu1zOdVXsXI18tXdhhVGSfQVzHirWYXtnsrefMkiKwTYefm9SPauoustpt4q8MYWAPocGvLHs7pvHmnCaYSQ+Q25GYkHh+x49K48XOV+U9bK6EHeo+h2/hWCWfSIBOu5drkcgc7z6V0EcMERYIuD35NcrdapHodmjHzVj3bAsPGM5PqKmkg1HVLa3uLO8aJXQPhpWUkMARnGa1UalGhGS1TOSUqWJxU4t2ZvSWtvcuJmTcVG3OSP8APWop3WyiBiOwZx61oMFjUjaMdeBXIeINRAvJLZGlUoyng4H3fr71tRoqVS6Ry4jESjSs2dVHKTDG5P3lBzjrxWeZ5kvIkDYQkZGB60ixzzabYtHKVzCpOWIzwKuaksa2k5VFWQRMVYDBBwcHNQqqjKV0a+xc4ws9zzr4ka6wt9T02G5/e/usR7PdG6kf1rK8FaFfXtwr3dtvhe1Dqd6jJJXB4PoTVw+Gr3VPE/2meWCaGTqszFicJjkEHuK9LsrGG0sbeKGGGKSOJUZo1C5wAO3auGnD2zZ79fExwdBU4atoSCzgs1keCPYuMuck8D6/jXMeLtVgf+zrRJss+p6ewTaef9Lj749q624BS2lGfvIen0rhvEdnkadckJlNUsBnHP8Ax9R/416dKnCMWfMVq05zjc9Qrzbw9b+ZaXzY66rf/wDpVLXpNcT4Ti3aVeHH/MV1D/0rlopysx1Y80bB4Wj8rx1rq/8AUOsT/wCRLmu2rktETZ8QdcH/AFDLH/0ZdV1tTJ3dy4K0UgoooqSgooooAK8l1mDztc8T8McatF0/684a9arzSULJ4i8Uxnk/2pG2P+3SCmtwILBMQhTn5VUVw/iG1FtrlqBv27EYlu3zGu9QeWzAcc1znie1EsrTbMlLc4OemNxqmkTzGY8Pn2pADFG/iX61V0ydmv5beUKkcakKx4JwQKu6VcINOhSR+OcjHuar3VowZpbRPndiSc9Qfr+FccqPLK6OhTurM7a78XM9nPAJLMiWNkOG55GOPm964q7vP3oRCjZXsc1jaRcNdpcGdt2wAjjGOvp9K2dPskvLhSse/kj72O1VdisZ7zl2IO3Oe1XNG2WnnSXDCHG1l8w7QcZ9az76JrK7nLrsUSMo5z3P+Fa19DDdRhAu4YIIyR1pVYvSwU2tbl2a7g1C3YJNE6nAzGwPfNcprCQRSsBKN24ZBYelSXTf2NbOkB8no+PvdTjvn0rm7+9lunMhk3OxGTgDtirgmTKxtWl0iqRvTgAdauNcSt8gQENxwDWHa2kzRK+z7yg5yK62GzRRuaPkHPWscRWUdDWjTctSrDb7YVYhg3oa9h+FH/JPbT/r6vP/AEplryt8AEdq9V+FP/JPrT/r6vP/AEplrHBS5pSLxKskdpXO+Pv+Sd+Jf+wXc/8Aopq6Kud8ff8AJO/Ev/YLuf8A0U1eichl2ollMYMZ2kdQD6UXwa3iDKpJ3Y5H1q/ozxTW1uynOQeefek1SIOhULnEnr9a7Ob3rHBye5craK8kjyb1xgr2+tbhxG4fPT1rI0hWErZHBZc/rWpqastjIYh8/GPzFZVYqU9TajKUaehT1zT49bsI4JC+1ZBJ+668Aj0PrXKeGvCKafqGrsY7xVllBUyDGQC/T5fesjXfFuu6Pqc0MV75MSlQo8pGxlQfQ1LafE23t4R/aWr7ZGUf8uxOT3+6ldSo1oU9HozllVpVKl2nc9KCLbnbEdwPPPNUNYnW0tVuSyq7OFIc4HQ/4U3Qtf0rWITJa3PnEOUB8tl5AB7getWNXsI9Qt1R4vMQOGA3EdiPWuKEZxqfvDuqyhKl+7OYs/GW6a4ikmsVETbV+bBPX/a9q62zmjurV8yJgkqSp9q4CXwTI13O8Gn8M5OfOHPJx1au00eyntrN0nj2kuTjcDxgeldOIjS5bxOXDSrc1pGlFFFDgI+cdMkVNuHcj86iESiHcq/N25poVj1FcUYxtod8pyv725Wup90fJUcGuT8RzBrawUMpzqth0P8A09RV01xCWiYBc/Ke9cr4gtZI7ewcpgDVbDnP/T1FXSkuVnG3LnR6bXJ+Ddv9jXef+grqP/pXNXWVxPhKXbpV4M/8xXUP/SuWuScuVXO+EOZ2GNPrEPxE1X+x7Cxus6XZeb9rvGg2/vbnGNsb57+mMDrnje8U3l5YeCNZvbcBL6DT5pU2HdtkEZIwcDOD7VnaK2/4g62f+oZY/wDoy6rq3RXRkdQysMFSMgimndXJkrOx57p2lWHh7xP4T/sZfLGpWs63hViftKrGriV/7zBsfN1+cjvXodYukeE9E0K5Nzp1kYpfL8pWaZ5PLjznYgZiEXIHyrgcD0rapiCiiigArytJd3xF8VW2W/4+Y5Mdv+Pa3H516pXhuqatHpXxX8TySKpDPEvzPt/5YQf4VcIc7sROagrs6Wb5ZWHuayNekRYZgy5/cN29jVuDU7e+TeksXQEhZA2M1FqNslxJ5fnKrOm0DqTnPvQ4OL1GpKS0M3wppv8AaclpGixYk34Eg443dePajX/C2q6cZJ/tUAiacqqxyNwOSOMe1ei+ENLNlo9mWkJ2b+CmOrN7+9J4n8UWumWg5hlcT+WU88AjhvY+lJPmdgb5Vc8b07w5eJNhZYFDMoYBiM/pXb6No7WcB3rCW3kgqPYD0rhJPEXKkWucf9NP/rVG3iUk5+xH/v5/9atVhzNVzpvEOl+YjEJDkzE5I+vtXD3091ZRgtcSZYHG1z2qe61Y3SBfI2fNu+9n+lUGkBxxj8abwt7C+spXMua5uL1trTyNkY+dyfekh06cyFy6FCOBk/4VrDB5zUivgYxmtY4axi8QP08NGjK5zgAD2rcbUIyjYDjj2/xrDCsedp59qm3nYRtPNRUy+nN3Y442pHRFp9QTBH7zP+fevZPhK274dWTetzdn/wAmZK8LIOOOvpXuXwi/5JvYf9fF3/6USVjPCQoK8eptSxE6rakdxXO+Pv8AknfiX/sF3P8A6KauirnfH3/JO/Ev/YLuf/RTVmbDrO3FpbRrtUbR/APX/wDXUNzcxjO5WPzelaayqyKhIHA5zVQ2aSSt+/UZJPT/AOvWkKsW7synRlFWiipp0quz7AQQR/Wq2tm6MoWO4dVKDIDkDOTW2sSWqO5lUjGeeOlQLfxzXKKm1sjqGz60p4mMJ3HDCTqQtsUtO0fTrnT4pdQsLS6lbO55YVck5IHJHpxXF+LvhrPqdzFJp0emW8e+RtpUpwSMDCqeleluTJEFA6HNcpr2n3DSxtFFLJlnJ2oTjpUPHVKUueKujell9OqlCUrMqeD/AApqPhyEveT27osrORC7HOVCjqB3rsUvYpB5QVsjnkDFeWX9jeixkVrO4UnHWM+o9qxbfT7hblmaKVcr3Q+1ctXHzqS5mrHq4fJKUINc/wDX3ntV1fQ24T5HBOfugVzFt4wtmnjQ/ayGcDBxjr/vVzGn2TuH37o8YxlevWurXwuHHy3wbtxHn+tczq1KjujZYahQXLNnQwaxb3SrHGkqls4yAP61ZjjlLlt/BHAya5208LGG5RzdnjPBix2+tdDErWyKAC+1dvTFdtCdV6SR5WKp0Iu8JE5RF4ZVOfauf8YRoNHtGVFB/tXT+g/6e4a3vMWXqQuPU9awfGAUaPaYcH/ia6f/AOlcNatyucyUGrnX15r4eufLtL9c9NVv/wD0qlr0qvGtOvPKbUkz01W+/wDSmWufFO0F6nbgIc9Rry/yOv8AC0nm+Otdb/qHWQ/8iXNdtXnfgGbzvGGvtnP+g2Q/8fua9ErWi700Y4mPLVkgooorQwCiiigAr5y8fRBviH4jfnP2mEf+S0VfRtfO3js/8XB8R/8AX1D/AOk0VdWE/inLi/4Rk6Zqz2AlXCc4HzAnpn0rtLK8XVdUtJIyGXzUQlQR/EPX615yy/MfrW3oGsPp+oWm9mKC5R2CqDkZHr9K6a9G6uc9CrbQ96kuU0jw6ZmYDyv7wJ6vjt9a8N8Sa3LqOoXaMIvL+1O6lVIJ5OOp969G1/xDHdeDbiWMShW24DKuf9YPevIrhklld8HLMTzXNQhys3rVLlbZgZNRsRnirKozq2SOlQPCyc5GK7DmuRknHSkCEnkU7cOhBqVVGaaQmNSItwBVmO3x9/IH1qPJU5Xini4IUAk5+laJGbZOGiUY3HjihAsvCEnJxVQ+ZIcowH1rSjWOzQ+YpLD5gVNUokuRJFpwwHl3r64Ir2L4UKF+H1oq9BdXgGf+vmWvDpNbZ7o28bOAegKj0zXt/wAJWLfDmyY9Tc3ZP/gTJXFjNkdmD3bO2rnfH3/JO/Ev/YLuf/RTV0Vc74+/5J34l/7Bdz/6KavPO8wtQ8TxWFq8jPGCgXqjHrj0+tVNJ8YrqN48QaEgIXG2Nx3Hr9a5rXY5bm2nQMvzBOv4VhaXLNpd28pccoU+UZ7j1+leTztq9z6qGDpOn5nsl5eiS3dVIOVYHg+lZNjMYb6MDHc8/Q1n2+rG4SQZfgd1FSW10i3Cu4YkZ6D2pSm5STOaNDki4nYwTs0QcAc02GZZZJRMdu0/LtHXrVTTb2O4xCquCqluQMdf/r1djtG3u3y/Mc9TXqUJRnTszwcTGcKuhBd2MF7aO29+MDjjv7iufn0HdIfKEjfVlrqY7eQWjxhlyWz/ACojs3AyxUn6msK9BOfuo68NipQhds52Lw7MEB2PyB/GtblvD9nhbdkOCWANWt5Hyj+Hg0jJtOJOc+npWkMPCn7zMauLq1fdQyGSSR1Z1AU9SKkeUDgY60NtWHEYwe1QrG7MSxBqqtRt2iZ0qSSvIkeBty7ASM85NYXjBdmlWYPX+1dP/wDSuKtaW8kiZMscE9gKwPFl/HLYWURDl21XT8HAx/x9xU1iIvRg8LJLmR3dfPTXnlalq6Z6are/+lElfQtfLWqXZi8Ra2memq3n/o96yxEeaFj0smjzV2vL9Ueo/Cqbz/EviFs9LSzH/j1xXqleOfBKbztZ8Rt6W9oP/Hp69jrSkrQSOTHK2JmvMKKKK0OQKKKKACvnnxwAfH3iMYGftcPP/btFX0NXmfiL4WX2teJtS1e3163tkvZEfyZLEyFSsaJ94SLn7menetqFRQnzMxrwc4cqPHcZdx6GkGR8wYhhyCOor0xvgnqTEk+KLXn/AKhjf/HqT/hSOpY/5Gi1/wDBY3/x6u14um0ciws1seenVrw2f2N7ido+4Mpx1z0rJlnkDN87df71eqn4Haif+Zptv/BY3/x6o2+A98xyfFNv/wCC0/8Ax6svb0y3QqM80S8aM8gnP+1U63YlGDHjPvXop+BF+f8Amabf/wAFp/8Aj1Nf4C3z9fFUH4aaf/jtP6xAX1eZwUaI3JRenpVpbQMDggY/2a7aL4FX8X3fFNt0xzpjf/Hqur8HdWQEDxPZ8/8AULb/AOPULEwG8PM8zuIvK4znjPSooozJIQW7V6c/wY1Rzk+J7T8NMb/49TU+C+qRuWHii0yRjnTG/wDj1V9agT9WmctpumxyRZbYflXqgNV9TjEQbof3ZPT616BF8LNbhXaviWwIwBzpb/8Ax+qtz8HdWuzmTxPZj5dvy6W3/wAeqo4uCJeEmzx+T5Zzcjt/D+GOtfQXwfbd8M9Ob1muj/5MSVyJ+BeoMmw+KbbH/YMb/wCPV6T4L8Nv4S8K2uivdrdtA8rGZY/LDb5Gf7uTjG7HXtXNiK0aiXKdGHpSp35jfrnfH3/JO/Ev/YLuf/RTV0VZviDSzrnhzU9JEwhN7ay2/mld2zepXOMjOM+tcp1HmbacWXDzbuBnK5/rWfc6GmCwlAy3/PP/AOvXbzeFfFM+d/iHSBnHTSZO3/bxUB8F+JmGD4i0r/wUyf8AyRXm/Vai2PdhmcEebrfT2pAEkh3+jkf561T1DXbqGYbJJl+XPEpHc16BcfCzW7kKH8S2Axnppb//AB+qcnwa1WQ5bxPadMcaY3/x6rWGl1R1RzTC7u/3GB4Y1m+numP2q4X90T/rmP8AEK9WsrqX7FAzO7Fo1JJY88Vx9j8JdZsJTJF4msSSu35tLY8Zz/z29q1n8DeJHjjQ+I9LwgwMaTJ/8fpqjUi9DjxWLw1Z6fkdKl2fOVMHB5+9V+Nt0YPSuNi8E+JYpA6+ItLyPXSZP/kitGHQ/F0EYRfEGjED10iX/wCSK3pqon7x5tZ0mvcZuFMMxznJqG6jczqRKwGBx+NZ/wDZfjHH/If0T/wTy/8AyTTW0jxgxydf0X/wUS//ACTWlROasY0moO5tRKPKGfm+tShV/uj8qwBpHjADH9v6L/4KJf8A5JpV0rxipyNf0T/wTy//ACTQlYJSvqadxZiTb8wGM/w1zXizTxFY2U3mZ26pp4xt/wCnuKtJdK8YrnGv6Jz/ANQeX/5JqC88NeJdTFtFf67pTW0V3BcusGlyI7eVKsgAYzsBkoB0NS6Ub3LVafLy3Owr5C8R3Hl+LdfXPTVLv/0c9fXtYVx4K8K3dzLc3PhrSJp5WLySSWUbM7Hkkkjkn1rRq5phMS8PNzSvpY8s+AMwfUfEjFh/qrQdfeavcK57/hAvB/8A0Kuif+AEX/xNbFxYw3OntY5lhhZAg+zStCyAdNrIQV/A0JWMq1X2tRz7lmuetvEN8/jN9ButKS3iNrJdQXIug5kVJETlAvy535+8enSiDwdYW9xFOuoa6zRuHCya1dOpIOcFTJgj2PBrLuW1sfEi31GPw1eyWEVlJYm4FxbgEvLG3mBTJu2gIe2famZHa0UUUAFFFFABRRRQAV5HoHjLWbm70BV1bUtQvL++eK5s5tMWO3SBWcM6SiJc7QFP3m9K9crlY/Bph8IWeixahsurKcXNte+T/q5BIXB2buRhipGeQT60AZN58VNOtNRuU/4l5sra6NrKzalGt1uD7GZbfGWUNn+IEgEgHjM+gzazqHxH8QPfIVtNPkSCFY9Sk2IGiVh+5CBHLbtxLHKngZxmr1v4U1DTru4Gl6xBBp89y9y1vNYCV0Z23OEfeAAWJOCrYzWtpujf2frWtaj9o8z+05o5fL2Y8vZEseM55ztz260AY+seI7vSPEuqD/XWVloLagLbhd8iu/8AFgkZCgdx7VXh8aaxLeWFmfDIS41O1a6sQ18NpVdpcSnZ+7IDr0D5zWlrPhX+1r/U7n7b5X27SH0vb5W7ZuLHfnIz97px061Ovh3bq+h3/wBq/wCQXZzWuzy/9b5gi+bOeMeV056+3IBlx+N5rvT9L+w6SZdVv554PsctwESFoGZZS0gU/KCuAQpJ3Dj00/DHiGbxBFqX2jTmsZrC+ayeMyiTcyojFgQBx8/HsAe+Bz+peHG0Cws7y2vrr7dbajdXEU1vpr3QC3Du7I8SHcV5A3Ag5APHSr3w9sL+003VbrUROJdQ1OW7X7RGI5ChVFBKfwZ2EhTyAQDzQB19FFFABRRRQAUUUUAFFFFABRRRQAVj+INcOiw2iQ2jXl7e3AtrW3Vwgd9pYlmOdqhVYk4PToa2KyPEGhnWoLRoLtrO9srgXNrcBA4RwpUgqcblKswIyOvWgDM1PxNqmj6dDPqGn6PaSu7KwutZEUWAARtdo8sTk8bRjHWsibxpq2qzeErvw9bW0lrqhuBLBcXQQM0aNld6xvwGUkMvXA7HNaVz4T1i61Gz1WTXbRtSt4pYC7abui8typ+VDJlWBT7249eRUVp4FudN0fRbex1lRfaTc3E8V1cWvmLIJjJuDoHXtJ1DDkZxzigDskLFFLqFfA3AHIB+venU1AwRQ7BnwNxAwCfp2p1ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcVNqeq61r+uwW2qzaXpmibI5GtbVZ555DGJG4ZW4AIAVVJJz7Cu1rmrvw1fRa7davoWrJYT3qoLuGe1+0RSsg2q4AZSrbeMhsEAccUAc/qmp6hceBNU13SfF1+ZdMt7jONPihDyRgtiRJYiwI4BxtBx0FdPpH22wuYLW8vtU1Q3cJmFzNBCsUG3blSY0TBbdwCD909O9QeDifB2s6HJqLPPq32hp7owgBZJgQSqA9Bnpn8a3BaXaXto8d6FtIYWjlt/JB81jt2tuzlcYbjvu9qAKOu69Npl3YafY2P27Ur8v5MLS+UgVAC7u+DgDKjgEksOKrar4iv8ASNItru8stLtZ5GZZUvNVEMUeDxiQp8xI5xtHvirOu6FNqd1YahY332HUbBn8mZofNQo4AdHTIyDhTwQQVHNUNQ8LanfXOlai2sW39qWKTRtLJp4eJ1kKk4j35VhtUA7j3znNAGPceNtV1VPCd54etrZ4tRu7iC4hmugqs0ccuU3qj/LuQsHXrtXjDHHfxGRoUMqKkhUF1VtwB7gHAyPfArjrbwJcWOkadb2usj7fp+oT30N1Pa71Yy+ZuV0DLniU8gjkZ46V2MQkWFBK6vIFAdlXaCe5AycD2yaAH0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXN+I9U1e21rRNL0iSxhfUGn3y3du8wURpuGFV06/Wukrm/EfhWHxHrWiT3ttZ3VhZNM08Fyu7eXTC4Ugg4PPOKAMjTfiHmGK21CwludSe/ubCMaYgeOd4QCWXcw2gg9yQCDk8ZrTufHFpaid30vVGgs1U388cSMlmSoYq+HySqsC2wNip7jw2qa54euNOhtLWx0v7RugjXYAJE2jYoGOvXpXO3/w/b+3NTu4dE8OarHqE/2jzNURhLAxUBlGEbeuRkDK4yRQBq+I/GsOn2+qwWNrfXM1laGWa7toleK1LIWQvk5PGGwobAIJ4rT0LW4ruy0i2uZy+pXWmpeMPLI3LhAzZA2j5nHHvwOKwtT8L67HLr0OiPpi2mtQqshuC6tbSCEREoqqQylVXgkYOevSug0ez1PTrfS7GQ2jWVtp6wzMpbzDOoQDbxjZgP15zj3oAXWvEFvo01pbfZbq9vbst5FpaIrSOFALN8xVQoyMkkdR602416eGxtrhNA1eeSYMWt40i8yHacHfukC/TBOe1V9d0jUpda07W9Ha1a9tIpbd4LtmSOWKQoT8yhirAxqQcHvWVr/hnWNdutMvLu00e9EMMsc+n3Usn2dXZlKyL8h3kAEYZR1OCKAHX/jqUXfhxtI0q51Cz1UzbxGqLKCiE7AHkQBgwOc8YB71veIdZOh+F7/VzCS9vbtIkLdS+PlU49WIFcppfgvWtE0Pw2lq2mz3+j3N1IYmd4YZEmMnAIRipAdeNpHBHvXUeJtJl17wnqGmBljuLm3Koc5VZMZU57gMBQBm3epa7b3uk+HbKe0m1WSya5u727iJQKhRSQiFclnfjkAAHrWl4Y1mXXNH+0XMKQXkM8trcxo2VWWJyjbSexK5Hsazbuw1m8vdJ8S6ZBbQ6itk1vc2N+7IpWQo5G5QxDKyehBBP1qxoejapoem2luktnPNPezXWpyMGUHzS7t5QHo7KBn+EHvQBz9x471OLXZrVW0sSR6ktkmjsH+2zRFwvnKd2Nu0l/uEbRy1a3ibV/EPh+C51YHSpNNgkQLaGOTz5gzBcB920OSeBtOeOay7jwVrMsV3pgOlmyudTN9/aLF/taAyiTAXbgsMbQ28YAHHGKualpPim68Wf2i1no99YWhB063nv5YRE+OZXUQsGfqAc4UdOSTQBsTalc2fje206WTfZ6hZSPAu0fu5YmXcM9SGWQHnpsPrW7XPz2Fxe+O7O9eJks9NspAkh6SSzMoIH+6sfP8Avj0roKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA//2Q==", "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": [ "Perturbation Pos Saliency Entropy Neg Saliency Entropy Entropy SSD XCorr\n", "Ref Image nan nan nan 0 1\n", "ksize={'s_y': 0.0001, 's_x': 0.0} nan nan nan 1.96528 0.0305445\n", "ksize={'s_y': 0.00012, 's_x': 0.0} nan nan nan 2.19786 -0.0597571\n", "ksize={'s_y': 0.00014, 's_x': 0.0} nan nan nan 2.35233 -0.124605\n" ] }, { "data": { "image/jpeg": "/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAC5ATsDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiuSl8Sa/NrOq2emaLp88Gn3C25luNReJnYxRyZ2iFuMSAde1AHW0Vyf9s+L/8AoX9F/wDBvL/8j0v9s+L/APoX9F/8G8v/AMj0AdXRXKf2z4v/AOhf0X/wby//ACPR/bPjD/oX9F/8G8v/AMj0AdXRXKf2x4w/6F/Rf/BvL/8AI9H9seMP+hf0X/wby/8AyPQB1dFcn/bPi/8A6F/Rf/BvL/8AI9L/AGz4w/6F/Rf/AAby/wDyPQB1dFcn/bPi/wD6F/Rf/BvL/wDI9L/bPjD/AKF/Rf8Awby//I9AHV0Vyn9s+MP+hf0X/wAG8v8A8j0f2z4w/wChf0X/AMG8v/yPQB1dFcp/bPjD/oX9F/8ABvL/API9afhnWJ9d0UXtzax2s4uJ4HijlMihopXjOGKrkEpnoOtAGxRRWb4g1Q6H4c1PVhCJjZWstx5Rbbv2KWxnBxnHpQBpUVyS654uYAjQNF5/6i8v/wAj07+2fF//AEANF/8ABvL/API9OzFzI6uiuT/tnxf/ANADRf8Awby//I9H9teL/wDoAaL/AODeX/5Hosw5kdZRXJ/2z4v/AOgBov8A4N5f/kelGseMD/zANF/8G8v/AMj0WYXR1dFcsNV8Yn/mAaL/AODeX/5Gpw1Pxkf+YBon/g3l/wDkakO509Fcx/afjEf8wHRP/BxL/wDI1H9p+Mf+gDon/g4l/wDkagDp6K5Y6r4xXroGif8Ag3l/+RqYda8Xj/mAaL/4N5f/AJHp2Yro6yiuQOveLgCf+Ef0bj/qLy//ACPVWfxh4isntWvdA01Lea7gtmeLU3dl82VYwQpgAOCwPUUcrFzI7miisK48beFLS5lt7jxLo8M8TlJI5L2NWRgcEEE8EHtSKN2iue/4T3wf/wBDVon/AIHxf/FVsXEk82nvJpr27TOm6B5STGc9CdvJH0oAs0VgeENXv9Y0m4l1MW32q3vrm0c2yMiN5UrJkBiSM7c9a36ACiiigArkNG/5GLxb/wBhSP8A9I7euvrkNG/5GHxb/wBhSP8A9I7egDbooooAKM0GgCgAzRmgikzxmgAJpryoiFmOABnpUMl5DHncrnBxwP8A69Zd5qQaBlTeCykcgelOMbickakd9BIpYPkA46Gp0lWQZU5Fc1pkzMuyQ5yx7e1dBa48sYHY/wA6bQk7k+aM0YoxUlBWb4D/AORcm/7Cmof+lc1aeKzPAn/IuTf9hTUP/SuagDpq53x9/wAk78S/9gu5/wDRTV0Vc74+/wCSd+Jf+wXc/wDopqALESkRr9KfmnImI1+gpCta3MbWG5pM0YNJg0xD1PFSoM1XUkGrEZ4qWOJMq4p3SmqTmnH3qGaoiZ+e1OVqDGCcik24p6C1EkwQaquwH51acEqapyofbrVRImRkhlP0rn/FCgWFl/2FdP8A/SuKtvcQDk1h+J23WFl/2FdP/wDSuKtGtGZJ6o9Ar5M12083xTrr7c51S7/9HvX1nXzNfW3ma5rLY66ref8ApRJW2ASdV37f5E42XLTT8zrvgTAItU8SKVH+ptD095q9lujcraSmzjikuQp8pJnKIW7AsASB7gGvJ/g3H5WveIlx/wAu1mf/AB6evXqwxKtVkbYd3pRZyvgzTNf0hL6DV4NMWK4u7i8R7S6kkYNLKXKkNGvA3YznnHSuqoorA2CiiigAritJY/8ACT+LFBI/4mUZ/wDJS3rta8mvPEl1o3jPxRBAluVa/jcmQHOfssA7EelNK7Jk7I9B5wOTUi1wcXji9YfMlkPwb/4qut0y/a+t2kYx8Pt+Tp0Hv703GwlO5o4oxim7h2Ipc1JoV7ubyWiUDO8kdcelHmH7Ozeh9abexedJCcH5STx+FSRJhcHOM0EmBdrJI74lZfnJ61nz27hP9cx4P+etdW1qpdj83Jp0kKcFmIA75rWMjNxOGCzQuNtxIPoSP6102gzSOAruz4QnLHP8VW5p7a3G77RGCP7ziqE+vLCT5ctsfq3/ANenLUlOxvmjFcqfFTqxG+0/P/69bun332yIuTGcPt+Q/T/GsnGxpzF/FZXgT/kXZ/8AsKah/wClc1a1ZXgT/kXZ/wDsKah/6VzUi0dLXO+Pv+Sd+Jf+wXc/+imroq53x9/yTvxL/wBgu5/9FNQBoJzGv0FBHNOCjYvPYU0jFWjNjdopCBTsj1pD0piIW4apIzxSFcmpE4pvYSWpOopWGaUEEUVk9TZaDRx3pRyKWmg8UtitwK8VDIgI/H0qYHmo5eBn3qoszkrGZIuBXP8AiT/jwsv+wrp//pXFXRzcr+Brm/Ep/wBBsf8AsK6f/wClcVbv4Wc32keiV8/fZTJqGrPjrqt7/wClElfQNeOabZ+adSfHXVb7/wBKparBy5Zt+QsdHmppeZo/CyLyvE3iFSP+XSzP/j9xXqVeeeA4fJ8Y6+uP+XGyP/j9zXodZV3eo2bYdWpRQUUUVkbBRRRQAV5dNpNjf+LfFMlzBvcahGoO9hx9kg9D716jXg/ijWpNO8f+JYEmuE3XUT4jbA/49oR6+1XTV5ET2O0TwxpTKMWfb/nq3+Nbltbw2Fu8cS+WCS2Mk84/+tXkEfi6dcj7Xf8A/fw//FV19jrEoT99PcSHf3cnjj1NaSiSmkdU2ppFMUabBHbb/wDWqydQRIlkeXCtjB2//WrKsvKvHjl8sEPn74GeMj+lS6yqixjWMBSHA4GOxrJRKciv/wAJro5I/wCJh/5Bf/4mp4vF+kPx9uz/ANsX/wDia8QbT9RUj/S//Ijf4VoaboOsXsiiK+Vckj5pXHbPpWvs0Z8zPa4/EelyAbbvPGf9W3+FXZXE8MgiO47SPSuA0bwrqkDK091BIvlYx5jHnj1Fd39qhtlYshwRn5QO1Q1YuzZlTaXNOfnh3DGPvAf1qq3h9Wc7rX/yJ/8AXrRuPEVnCeYp+meFH+NZVx4ttFlbCXQ6dAPT607i5TOv/D8iuPKteMn/AJaf/XrrdLtRZQlCmzMm7Gc+n+FYS+KbCQDdDcE+6r/jVaTxNG8y7WugOOM//Xo3Cx3qkMMisvwJ/wAi7P8A9hTUP/Suaqmnaqs0ETZm5z1PuferPgFt3hmVvXU9QP8A5NzVm1YuLudPXO+Pv+Sd+Jf+wXc/+imroq53x9/yTvxL/wBgu5/9FNSKNJQ2xcegpWRiOlPT/Vr9BSg80cwuUqlGHakAOeatMB6UzaCOgq7kcoxEz2qQIo6ikHymnkZAqZNlRSYfKeBTSzA4qF3Kt1P4VLCwccjJ96iNS7szWVOyug3N3NPwDS4B7Cm96qTIimOwAKrzsxXAPerGRimsgYdBTi0hSTZmMrEEYrA8TxFdPsmI6arp/f8A6e4q68xD0X8q57xfGBpFocD/AJCun/8ApXDWjnoZKGtzsa828PW/mWl82Ouq3/8A6VS16TXE+E4t2lXhx/zFdQ/9K5aVOVmOrHmjYPC0fleOtdX/AKh1if8AyJc121cloibPiDrg/wCoZY/+jLqutqZO7uXBWikFFFFSUFFFFABXyv8AE+7mh+LfiCOFA5LQsRgk/wCoi9K+qK8A13QI9U+Mfia4uLbzYVESBvM2/N5MBxwQehq6fxEy21NXwV4bW80lLi4S6jMkELjAwDlSTjIqpeaRdz3cbfZLk4AHyxn1+ldhZalBptjb2sUvliKJY9u0nG0YxnFSR6xZAfNPzn+43+FaunJmfMlqY+l6ZdRQxKbW4GM9Yz7+1dRbaaXRd6Sr8o7Y5/Kqo8QWijC3WB/1zP8AhSjxNAD/AMffH/XM/wCFJUZFOpFmoNKt0dcvIOeMkf4VJdwfZ7KTyQztwQDz3HpWHN4jiZkIu/u8/wCrP+FUbzxWUbal7gY/55e/0o9nMhyRXvBetI+bV8bzz5bVSbSppcB4LgDpwh/wqceJDM5DXe4df9Xj+lVbzxPcoY/KvMZzn90Pb2q1TYuZkc3hgSNny7vp2X/61InhiJB8wuh9cf4U6PxTciI77z5s/wDPIf4VRvPFN4T+7vO4/wCWQ9PpVchPMa0GgWqA7pJh06kf4VpLZadEpxd8jnmRa4v/AISHUpP+XrP/AGzX/ClS/uX/ANZLnnH3R0/KpcRpna/b4oE8qKWJgOmWBP8AOt/4btv8HK/HzX98eP8Ar6lrzWOXOCD830r0X4X8+BoSf+fy9/8ASqWsaiNYLU7Gud8ff8k78S/9gu5/9FNXRVzvj7/knfiX/sF3P/opqzNDVDERj6CgSE+lCgFFz6ClCDPSmTqGKYz7TgYNOO7BpipzlhxUSbeiNYpLVjldj2pGJPamSSbDhDioHmkB+9+lUqba1M3USeiJ9iFuWx+NOBSM8MPxNZ6SSlgWPH4VIzHqTVKikyXXbRf81f7y/nQCuM7h+dZhl7buntUwkOOv6VTpkqoXDJgcEVA05z/D1qEye/6VGXHrTUBOdy6JC3pWH4w/5Atr/wBhbTv/AErhrXiOW/EVk+Mf+QNaf9hXTv8A0rhqZaFRdzra5Pwbt/sa7z/0FdR/9K5q6yuJ8JS7dKvBn/mK6h/6Vy1lOXKrm8IczsMafWIfiJqv9j2FjdZ0uy837XeNBt/e3OMbY3z39MYHXPG94pvLyw8Eaze24CX0GnzSpsO7bIIyRg4GcH2rO0Vt/wAQdbP/AFDLH/0ZdV1boroyOoZWGCpGQRTTurkyVnY8907SrDw94n8J/wBjL5Y1K1nW8KsT9pVY1cSv/eYNj5uvzkd69DrF0jwnomhXJudOsjFL5flKzTPJ5cec7EDMQi5A+VcDgelbVMQUUUUAFfNPxD8R/wBifE3xFGJbpC00J/ctj/l3i9x6V9LV8n/F8qfidr6Fwp86A8n/AKd46qLs7ikrohTxuJMkzX5+rf8A2VTDxpF3e+/Mf/FVxNnJHEZMyLzjqceta9zpkcisy3anC44XP9a6I1jPku7HSJ40hOPmvfzH/wAVVuLxhbNjIu+nt/8AFV5pc2PlFv3mcY/hqgw2kjPeqdcPZntEfim1c423P4gf41IdetJDkxTH6qP8a8bsI/tFykIOGd1UYGTknHSugk8MagiF47a6lUdStu2K1hVTWpDhY9FGsWvVYpAf90f41Un1i3IHyS9+w/xrgF07UIjzp91xx/qmH9Kcmn3zH/jyuR/2yb/CquiUjsX1WJvuiUfl/jUX29GP8f4//rrBtdIvZGH+jXA5/wCeR9K3LHQJcAzO8PB+/ER39zUOSKUW+hYju1YfLvFX7fzGIO843etS29tDaJt+1RuSAD0GMfjU6lpZFwhHIFYzqLoaKk1uXrUY2Z5616T8MP8AkRof+vy9/wDSqWuF06zdmj+93/h+td78NV2+DEX0vr4f+TUtc7lcpLU66ud8ff8AJO/Ev/YLuf8A0U1dFXO+Pv8AknfiX/sF3P8A6KapKLizfKvLdBStPhRy1c/LqNtZjM00SBQMl5AuM/X61Zt9YsLkBY7y2Y7c4WZTXR7J72OVVk9DTN4qjJ31FJqkSjGJP0/xqF41lHDjisrUYVjB/eA/KP504wi2KdSSWhri8SXkB/xpk0v3cFq520mAuGTg4Xrn6V1tqoe2jOf4B/KqnHkIpzdQyheqq/x09bxXH8f41YmsWc/ePT+7Vc6e6t1Y/wDAaLxYNTRA9x8x5brVlLkEfxVWexk3dH6/3DV2K0Zccnr/AHab5bCipXGlmY8MfzpER2Y/N+taMcWAOf0qykfv2rJzsbKm2RxRkHtWN4yGNFtf+wrp3/pXDXQswUckVzfjGQNpFoAR/wAhXT+//T3DWT1N1ZaHX15r4eufLtL9c9NVv/8A0qlr0qvGtOvPKbUkz01W+/8ASmWuTFO0F6nfgIc9Rry/yOv8LSeb4611v+odZD/yJc121ed+AZvO8Ya+2c/6DZD/AMfua9ErWi700Y4mPLVkgooorQwCiiigAr5N+MVs7/E3Xp1UkedAnUf8+8Zr6yr5l+KFus3jzxCWAOLyEdf+naKkwPIGcq7A4yDitOPWZNhBEfJ9D/jWddpsu5lHQSMB+dQgkUxx01NGe/aQN93nHY1ns25ifU0hJPem0A2my3p1x9l1K1nGP3cyPyPQg17H4e8SWl9psiTzKpMpHyI3QAH3rxNThgfQ11vhq8KR7cnBkJ6D+6KmU3FaHbgKNOrVUZ7HpckmlOSftUnJz90/4VXkm0uIZFzJ68qf8K5K41lYif8AWcNjhRVaK+ub1giSY5AO5R3rONabPUxOFwdHzZ1cmuWVv/qJgzdQGRv8Kj/te6vflijiZeoIBHt3NZtlosszBpjG3JH3iO30rds9OitVHyDOCOGJ71XO2eRUqQ2ghkFm8gLzKVLYPBFbtpbZZcZxvHeqqISOMYFa9kmCv+//AIVSZxylc2rCDyxH14z/AFrpfh1/yKX/AHEL/wD9K5axLVQQh+tbnw7/AORTP/YRv/8A0rlqiYs6qud8ff8AJO/Ev/YLuf8A0U1dFXO+Pv8AknfiX/sF3P8A6Kags8y8YnU5Le8NtbRuCI9uSBn7vvWb4ZXVhc/vLWMfuOcMOuR716Rf6NBPbuJI1IYLn5iPSqtjosNvMWRFHy4+8x44r1o148ljxpUZc5pW90wSTzAo444rH1vUAiHBXO0dQfWtaSMBG28cGuf1W1eXqVxtHf3rKmk5XNKrko2Mm31kpevny8bf7p9q9E0m6E1jE2RzGh4B7ivKLmIW94/HPA4+grutE1HbYRKN3ESDoPStMTTTimjPC1HGTTOwyuOtMYqOpqlHe7143de4FVZ7ubzmVXwBjsK4VB3PQdRWNRnj/vfpSCRSeDVaJJZIwzMDkA1djteMnHX1NJ2RSvIVMnFWF4AzSJGFxxSSnC8etZ3uaJWRQ1C/SCMMzAcE9DXJ+INVju7KxjR1JOq2HRSP+XqI07xVfzQ20exyMpJ2HoK4pL+e4l0xHckHVrLjaB/y8RV2Kh+6cjhliH7ZR9D3yvnprzytS1dM9NVvf/SiSvoWvlrVLsxeItbTPTVbz/0e9eTiI80LH0+TR5q7Xl+qPUfhVN5/iXxC2elpZj/x64r1SvHPglN52s+I29Le0H/j09ex1pSVoJHJjlbEzXmFFFFaHIFFFFABXzP8Tif+E78QgEj/AEyH/wBJYq+mK8u8T/Ca88QeJNR1WHX4LWO8kSTyXsTIVKxqn3vMGfu56d6Ur20Ez5surJXmZtwyWJ+7VQ2YH8Q/75r6Eb4DXzHJ8U2//gtP/wAeqM/AG8P/ADNUH/gtP/x2oSkB89m1H979KT7IP7/6V9C/8KBvP+hqg/8ABaf/AI7Sj4B3o/5mqD/wWn/47Vagj57Wzyfv/pWlp1u8bALOw5J447fWvdR8B75T/wAjTb/+C0//AB6p4vgjqUJyvii1/HTG/wDj1JqTLhKUHdM8ht9JMzZefdlc4Zc/1ro7HSoIpCQkZ5H/ACzAr0VfhBq6dPE9l0x/yC2/+PVKPhRrQP8AyM1j/wCCt/8A4/UOMuho6l9WccsaRKQqr68DFOX5jXYH4U60T/yM1j/4K3/+P05fhZra9PEth/4K3/8Aj9Uosxk7s5uBFK8gdB2rZtI1yvA+96VoL8NNeUYHiTTv/BU//wAfqwngDxEnTxHpnXPOlP8A/H6pIhpksCBUXp3rW+Hf/Ipn/sI3/wD6Vy1mp4N8ToAB4i0rj10mT/5Iro/C2iTeH9CTT7i6S6m8+eZ5UiMakyStIcKWbAG/HU9KocU0bNc74+/5J34l/wCwXc/+imroqzfEGlnXPDmp6SJhCb21lt/NK7tm9SucZGcZ9aCitNErRYwOg7VFFbrnt09Kq/2R4wxj+39F/wDBRL/8kUq6T4wXpr+if+CeX/5JrRTsrGTp3dy61mhGPl/75qrPpMcnUp0/uCk/s3xl/wBB7RP/AATy/wDyTSHTPGJ/5j+if+CeX/5JoVRoHSizGv8AwrDPIziZFJI/5Yj0+taNhoaW8AXzVPyqP9XjoPrU50rxif8AmP6J/wCCeX/5Jo/srxj/ANB/RP8AwTy//JNaPESasZLCwTujThsY0X+E8/3af9ih3FjHGSf9gVl/2Z4x/wCg/on/AIJ5f/kmj+zPGP8A0H9E/wDBPL/8k1i5SOhQibSwoBgKoA9BT+nSsL+zfGX/AEH9E/8ABPL/APJNH9m+Mv8AoPaJ/wCCeX/5JqXqUtDdqOb7g+tY39m+Mv8AoPaJ/wCCeX/5JpDpfjE/8x/RP/BPL/8AJNC0B6o5rxND51vHlsYR+2ewrkY7URPpjbgcavZdv+niKvSJ/DXiuddr+INHAwRxpEn/AMkVSbwJrs81p9r1/T3ghu4Llki0x0ZvLkWQAMZiBkrjoa7ViV7NwPP+qy9qpnoFfIXiO48vxbr656apd/8Ao56+vawrjwV4Vu7mW5ufDWkTTysXkkkso2Z2PJJJHJPrXC1c9rCYl4ebmlfSx5Z8AZg+o+JGLD/VWg6+81e4Vz3/AAgXg/8A6FXRP/ACL/4mti4sYbnT2scywwsgQfZpWhZAOm1kIK/gaErGVar7Wo59yzXPW3iG+fxm+g3WlJbxG1kuoLkXQcyKkiJygX5c78/ePTpRB4OsLe4inXUNdZo3DhZNaunUkHOCpkwR7Hg1l3La2PiRb6jH4avZLCKyksTcC4twCXljbzApk3bQEPbPtTMjtaKKKACiiigAooooAK8j0DxlrNzd6Aq6tqWoXl/fPFc2c2mLHbpArOGdJREudoCn7zeleuVysfg0w+ELPRYtQ2XVlOLm2vfJ/wBXIJC4OzdyMMVIzyCfWgDJvPipp1pqNyn/ABLzZW10bWVm1KNbrcH2My2+MsobP8QJAJAPGZ9Bm1nUPiP4ge+QraafIkEKx6lJsQNErD9yECOW3biWOVPAzjNXrfwpqGnXdwNL1iCDT57l7lreawEroztucI+8AAsScFWxmtbTdG/s/Wta1H7R5n9pzRy+Xsx5eyJY8Zzznbnt1oAx9Y8R3ekeJdUH+usrLQW1AW3C75Fd/wCLBIyFA7j2qvD401iW8sLM+GQlxqdq11Yhr4bSq7S4lOz92QHXoHzmtLWfCv8Aa1/qdz9t8r7dpD6Xt8rds3FjvzkZ+9046danXw7t1fQ7/wC1f8guzmtdnl/63zBF82c8Y8rpz19uQDLj8bzXen6X9h0ky6rfzzwfY5bgIkLQMyylpAp+UFcAhSTuHHpp+GPEM3iCLUvtGnNYzWF81k8ZlEm5lRGLAgDj5+PYA98Dn9S8ONoFhZ3ltfXX2621G6uIprfTXugFuHd2R4kO4ryBuBByAeOlXvh7YX9ppuq3WoicS6hqct2v2iMRyFCqKCU/gzsJCnkAgHmgDr6KKKACiiigAooooAKKKKACiiigArlh4suLjxZdaJZ2Fo/2SWOOYz34imIZVYvHFsJdQG6kjJBA6V1NcrrnhK81/UI2u9TtfsMVxHPGgsB9oj2MG2pNv+UEjk7c4JGaAMPwh4s1SHQtEOpWEstne3b2Yv5LvfKZDI4UlCPuZG0HdnpxirzeMXsbRWs9JnuprnxBPpaxPek/MPMO/cwO1cx/dHCg8Zxg3rfwZ5Hh7RtK+37v7Nv0vPN8nHmbZGfbjdx97Gcnp0rH1zwpfWy6RBp91M0sniaTUWuI7fcLcPHO3zDJyoLKpJIznsTQB0+g67NqlxqFjfWIstRsJFWaFJvNQq67kdXwMgjPUAgg1t1iaDoU2l3GoX19fC91G/kVppkh8pAqLtRFTLYAGepJJJrboAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDO8Qasmg+HdR1Z4zItlbST7Acbtqk4/HGK5N9Q1TR7LTtT1/xVcQyXex3gg0rzbRMlcoWVC6/eADM4yefUV2t9ZW+pafc2N3GJLa5iaKVD/ErDBH5GuTk8F6vcaTHod14l8/R4zGArWQ+0lEYMqmXftP3QM7MmgCC8tdfh8Z6dpCeMNVFvd2dzcMfs1nuVo2iCgHyOn7w9c9BXXaVdPdWOZIrtHid4SbuNUeQoxXzMLxhsbgRjII4HSq9xo32jxRYa19o2/ZLWe38nZnf5jRnO7PGPL6Y5z7VbsILu3gkW8vBdyGaR1cRCPahYlUwOu0YGe+M0AYGl+LLjV/EF3p9tYWgt7S5e2mZ78C4Xbxv8nZ90nod3IIOKwvC/izVLXR7B9QsJJ7G41Wax+3yXe6Xe1zIkfyEHKA7UzuBGOmBW5deErzUfENnqN/qdrJFZ3RuYBFYCOcdcIZt5ymDggKM45oj8GeX4csdI+35+y6ouo+b5P3sXJn2Y3cdduc++O1AFKXxi2nW9w9rpU91NJr7aWsTXhbc5GQ4LAhF4HyjgcmtvQteuNSvdQ07ULBbHUbExmSJJ/ORkkBKOr7VJB2sMEDBU1zXiHwrewQWkdjczvLc+JV1AzRQZ+zAq3LDkFQQMk4Bzjiul0LQrjTb3UNR1C/W+1G+MYklSDyUVIwQiKm5iANzHJJyWNAG5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeTX/jDUra51iS38ULJqltq5tbTQTHAxnj3oNoUL5vQt827AxXrNZOiaGujPqT+cJmvb2S7z5e0pvx8vU5xjrx9KAMI+Opo11u8n0hYtJ0aeaC4umuhvcooI2Jt5ySo5YAZ6nmq+n/E3T5p7iK+/s9BFZS3wbT9SS8ASMAur7QNr4IIHIODg8VrjwfbS6Nrul3dw8sGr3UtwxRdjRbwMAHJyQVBB/Skh8N6jcWl3Y63q1tfWVxavbOkFgIHYOMFmbe2TjPQKOelAGMmv65e+MvCsd7psmmW92lzKI47zzVlURAhZAAuGGQcfMOeDxXaadenULMXBtbm1y7p5VymxxtcrnGTwcZHqCDXN2PhHVI9b0fUdS8QC9XSo5IoYlsxFvV025c7zluBzgD2Ga6TToLu3sxHfXgvJw7kzCIR5UuSq7R/dUhc98Z70AYGi+LLjXNaubW3sLRbW2uJbeVmvx9pQoSu5oNnCkjj5s4IOKwvCHizVIdC0Q6lYSy2d7dvZi/ku98pkMjhSUI+5kbQd2enGK3H8JXl54kstV1DU7WVbGdpoPJsBFOcqyhHl3nKgN0CjOBmi38GeR4e0bSvt+7+zb9LzzfJx5m2Rn243cfexnJ6dKAKLeMXsbRWs9JnuprnxBPpaxPek/MPMO/cwO1cx/dHCg8Zxg7ug67NqlxqFjfWIstRsJFWaFJvNQq67kdXwMgjPUAgg1zGueFL62XSINPupmlk8TSai1xHb7hbh452+YZOVBZVJJGc9ia6fQdCm0u41C+vr4Xuo38itNMkPlIFRdqIqZbAAz1JJJNAFBtWl/wCEr16eSSX7HolggECuQskjhpHYjoSFVAM9Mt61l6Xq2v2knhe/1PU1u7fXyI5bUQIi2rvC0yeWQNxA2FTuJznPHSugGiyR+KtQu9iSafqdmkVypPKyRkgcdwyOQfTYPWqGk+DbmxutKF7rLXtjo6sNPtzbhGU7DGpkfcd5VCVGAvXJyaAJvHGrXmkaZZSWt01rHNexw3FxHEJZY4yG5jjIO9twUYAY4JODis3QPFsy6Fqt5eXMuopb332WwLwrDc3JKrtR4wBscuxAyq/LhiAOa1dQ8Oahf29hK+sgapYXklzbXRtQUAYOojaMEbgEfbkEE4zxTLTwXZyx37eIBbazPf3CXExltVWIMiBECxktjCjqSTyeaAKHh6TXda0rxRpuq6mft0N41vDPbARfZ90ETgIVAJCs5wTkkDmt/wALau+veFNK1WRQst1axySKOgcj5gPbOax9O8FweFrfxBc+H7SzS+v2Z7VUhESw/u1VYyRnKhlL9vvHj16DQ9Ki0PQbDSoCWjs7dIFY9W2gDJ9z1oAv0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAH/2Q==", "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": [ "Perturbation Pos Saliency Entropy Neg Saliency Entropy Entropy SSD XCorr\n", "Ref Image nan nan nan 0 1\n", "ksize={'s_y': 0.0001, 's_x': 0.0} nan nan nan 0.930901 0.437871\n", "ksize={'s_y': 0.00012, 's_x': 0.0} nan nan nan 1.06851 0.292291\n", "ksize={'s_y': 0.00014, 's_x': 0.0} nan nan nan 1.14059 0.221283\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 demonstrates 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 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.15" } }, "nbformat": 4, "nbformat_minor": 5 }