diff --git a/README.md b/README.md index a2507b41561b9b6a1401cf7dc61ae1aa2d54dc88..9825413613829addc15cdf2a219932f66eea13fe 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ --- title: Comparative Explainability -emoji: 📈 +emoji: 🏆 colorFrom: red -colorTo: indigo +colorTo: gray sdk: gradio sdk_version: 3.34.0 app_file: app.py diff --git a/Transformer-Explainability/BERT_explainability.ipynb b/Transformer-Explainability/BERT_explainability.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8ee59a51022e1c02bb3309254993455db22a8451 --- /dev/null +++ b/Transformer-Explainability/BERT_explainability.ipynb @@ -0,0 +1,581 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "BERT-explainability.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyOm8dIRrumd5XNcc+fntVA5", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YCdGaMuy56TA", + "outputId": "8f802262-55eb-4366-b772-89c4756224b3" + }, + "source": [ + "!git clone https://github.com/hila-chefer/Transformer-Explainability.git\n", + "\n", + "import os\n", + "os.chdir(f'./Transformer-Explainability')\n", + "\n", + "!pip install -r requirements.txt\n", + "!pip install captum" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fatal: destination path 'Transformer-Explainability' already exists and is not an empty directory.\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: Pillow>=8.1.1 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 1)) (9.4.0)\n", + "Requirement already satisfied: einops==0.3.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 2)) (0.3.0)\n", + "Requirement already satisfied: h5py==2.8.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 3)) (2.8.0)\n", + "Requirement already satisfied: imageio==2.9.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 4)) (2.9.0)\n", + "Collecting matplotlib==3.3.2\n", + " Using cached matplotlib-3.3.2-cp38-cp38-manylinux1_x86_64.whl (11.6 MB)\n", + "Requirement already satisfied: opencv_python in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 6)) (4.6.0.66)\n", + "Requirement already satisfied: scikit_image==0.17.2 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 7)) (0.17.2)\n", + "Requirement already satisfied: scipy==1.5.2 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 8)) (1.5.2)\n", + "Requirement already satisfied: sklearn in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 9)) (0.0.post1)\n", + "Requirement already satisfied: torch==1.7.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 10)) (1.7.0)\n", + "Requirement already satisfied: torchvision==0.8.1 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 11)) (0.8.1)\n", + "Requirement already satisfied: tqdm==4.51.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 12)) (4.51.0)\n", + "Requirement already satisfied: transformers==3.5.1 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 13)) (3.5.1)\n", + "Requirement already satisfied: utils==1.0.1 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 14)) (1.0.1)\n", + "Requirement already satisfied: Pygments>=2.7.4 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 15)) (2.14.0)\n", + "Requirement already satisfied: numpy>=1.7 in /usr/local/lib/python3.8/dist-packages (from h5py==2.8.0->-r requirements.txt (line 3)) (1.21.6)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.8/dist-packages (from h5py==2.8.0->-r requirements.txt (line 3)) (1.15.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2->-r requirements.txt (line 5)) (1.4.4)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2->-r requirements.txt (line 5)) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2->-r requirements.txt (line 5)) (2.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2->-r requirements.txt (line 5)) (0.11.0)\n", + "Requirement already satisfied: certifi>=2020.06.20 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2->-r requirements.txt (line 5)) (2022.12.7)\n", + "Requirement already satisfied: networkx>=2.0 in /usr/local/lib/python3.8/dist-packages (from scikit_image==0.17.2->-r requirements.txt (line 7)) (3.0)\n", + "Requirement already satisfied: tifffile>=2019.7.26 in /usr/local/lib/python3.8/dist-packages (from scikit_image==0.17.2->-r requirements.txt (line 7)) (2022.10.10)\n", + "Requirement already satisfied: PyWavelets>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from scikit_image==0.17.2->-r requirements.txt (line 7)) (1.4.1)\n", + "Requirement already satisfied: dataclasses in /usr/local/lib/python3.8/dist-packages (from torch==1.7.0->-r requirements.txt (line 10)) (0.6)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch==1.7.0->-r requirements.txt (line 10)) (4.4.0)\n", + "Requirement already satisfied: future in /usr/local/lib/python3.8/dist-packages (from torch==1.7.0->-r requirements.txt (line 10)) (0.16.0)\n", + "Requirement already satisfied: sacremoses in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (0.0.53)\n", + "Requirement already satisfied: protobuf in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (3.19.6)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (3.9.0)\n", + "Requirement already satisfied: sentencepiece==0.1.91 in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (0.1.91)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (21.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (2022.6.2)\n", + "Requirement already satisfied: tokenizers==0.9.3 in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (0.9.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from transformers==3.5.1->-r requirements.txt (line 13)) (2.25.1)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests->transformers==3.5.1->-r requirements.txt (line 13)) (4.0.0)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->transformers==3.5.1->-r requirements.txt (line 13)) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->transformers==3.5.1->-r requirements.txt (line 13)) (2.10)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.8/dist-packages (from sacremoses->transformers==3.5.1->-r requirements.txt (line 13)) (1.2.0)\n", + "Requirement already satisfied: click in /usr/local/lib/python3.8/dist-packages (from sacremoses->transformers==3.5.1->-r requirements.txt (line 13)) (7.1.2)\n", + "Installing collected packages: matplotlib\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.6.3\n", + " Uninstalling matplotlib-3.6.3:\n", + " Successfully uninstalled matplotlib-3.6.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "fastai 2.7.10 requires torchvision>=0.8.2, but you have torchvision 0.8.1 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed matplotlib-3.3.2\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: captum in /usr/local/lib/python3.8/dist-packages (0.6.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (from captum) (3.3.2)\n", + "Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.8/dist-packages (from captum) (1.7.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from captum) (1.21.6)\n", + "Requirement already satisfied: future in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum) (0.16.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum) (4.4.0)\n", + "Requirement already satisfied: dataclasses in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum) (0.6)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (0.11.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (9.4.0)\n", + "Requirement already satisfied: certifi>=2020.06.20 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (2022.12.7)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (1.4.4)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib->captum) (1.15.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install captum==0.6.0\n", + "!pip install matplotlib==3.3.2" + ], + "metadata": { + "id": "zDPnh4lofcNw", + "outputId": "3d585bbc-ff3b-4a09-b5bf-57bb4d46e830", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: captum==0.6.0 in /usr/local/lib/python3.8/dist-packages (0.6.0)\n", + "Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.8/dist-packages (from captum==0.6.0) (1.7.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from captum==0.6.0) (1.21.6)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (from captum==0.6.0) (3.6.3)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum==0.6.0) (4.4.0)\n", + "Requirement already satisfied: future in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum==0.6.0) (0.16.0)\n", + "Requirement already satisfied: dataclasses in /usr/local/lib/python3.8/dist-packages (from torch>=1.6->captum==0.6.0) (0.6)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (1.4.4)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (1.0.7)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (9.4.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (2.8.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (21.3)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (3.0.9)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (4.38.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib->captum==0.6.0) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.7->matplotlib->captum==0.6.0) (1.15.0)\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting matplotlib==3.3.2\n", + " Using cached matplotlib-3.3.2-cp38-cp38-manylinux1_x86_64.whl (11.6 MB)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (9.4.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (0.11.0)\n", + "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (1.21.6)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (1.4.4)\n", + "Requirement already satisfied: certifi>=2020.06.20 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (2022.12.7)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib==3.3.2) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib==3.3.2) (1.15.0)\n", + "Installing collected packages: matplotlib\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.6.3\n", + " Uninstalling matplotlib-3.6.3:\n", + " Successfully uninstalled matplotlib-3.6.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "fastai 2.7.10 requires torchvision>=0.8.2, but you have torchvision 0.8.1 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed matplotlib-3.3.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4-XGl_Zw6Aht" + }, + "source": [ + "from transformers import BertTokenizer\n", + "from BERT_explainability.modules.BERT.ExplanationGenerator import Generator\n", + "from BERT_explainability.modules.BERT.BertForSequenceClassification import BertForSequenceClassification\n", + "from transformers import BertTokenizer\n", + "from BERT_explainability.modules.BERT.ExplanationGenerator import Generator\n", + "from transformers import AutoTokenizer\n", + "\n", + "from captum.attr import visualization\n", + "import torch" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "VakYjrkC6C3S" + }, + "source": [ + "model = BertForSequenceClassification.from_pretrained(\"textattack/bert-base-uncased-SST-2\").to(\"cuda\")\n", + "model.eval()\n", + "tokenizer = AutoTokenizer.from_pretrained(\"textattack/bert-base-uncased-SST-2\")\n", + "# initialize the explanations generator\n", + "explanations = Generator(model)\n", + "\n", + "classifications = [\"NEGATIVE\", \"POSITIVE\"]\n" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jGRp376FPOvV" + }, + "source": [ + "#Positive sentiment example" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uSLZtv546H2z", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 219 + }, + "outputId": "26712e90-0b77-40b0-a908-fef13dd88bcd" + }, + "source": [ + "# encode a sentence\n", + "text_batch = [\"This movie was the best movie I have ever seen! some scenes were ridiculous, but acting was great.\"]\n", + "encoding = tokenizer(text_batch, return_tensors='pt')\n", + "input_ids = encoding['input_ids'].to(\"cuda\")\n", + "attention_mask = encoding['attention_mask'].to(\"cuda\")\n", + "\n", + "# true class is positive - 1\n", + "true_class = 1\n", + "\n", + "# generate an explanation for the input\n", + "expl = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, start_layer=0)[0]\n", + "# normalize scores\n", + "expl = (expl - expl.min()) / (expl.max() - expl.min())\n", + "\n", + "# get the model classification\n", + "output = torch.nn.functional.softmax(model(input_ids=input_ids, attention_mask=attention_mask)[0], dim=-1)\n", + "classification = output.argmax(dim=-1).item()\n", + "# get class name\n", + "class_name = classifications[classification]\n", + "# if the classification is negative, higher explanation scores are more negative\n", + "# flip for visualization\n", + "if class_name == \"NEGATIVE\":\n", + " expl *= (-1)\n", + "\n", + "tokens = tokenizer.convert_ids_to_tokens(input_ids.flatten())\n", + "print([(tokens[i], expl[i].item()) for i in range(len(tokens))])\n", + "vis_data_records = [visualization.VisualizationDataRecord(\n", + " expl,\n", + " output[0][classification],\n", + " classification,\n", + " true_class,\n", + " true_class,\n", + " 1, \n", + " tokens,\n", + " 1)]\n", + "visualization.visualize_text(vis_data_records)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[('[CLS]', 0.0), ('this', 0.4267549514770508), ('movie', 0.30920878052711487), ('was', 0.2684089243412018), ('the', 0.33637329936027527), ('best', 0.6280889511108398), ('movie', 0.28546375036239624), ('i', 0.1863601952791214), ('have', 0.10115814208984375), ('ever', 0.1419338583946228), ('seen', 0.1898290067911148), ('!', 0.5944811105728149), ('some', 0.003896803595125675), ('scenes', 0.033401958644390106), ('were', 0.018588582053780556), ('ridiculous', 0.018908796831965446), (',', 0.0), ('but', 0.42920616269111633), ('acting', 0.43855082988739014), ('was', 0.500239372253418), ('great', 1.0), ('.', 0.014817383140325546), ('[SEP]', 0.0868983045220375)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
11 (1.00)11.00 [CLS] this movie was the best movie i have ever seen ! some scenes were ridiculous , but acting was great . [SEP]
" + ] + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
11 (1.00)11.00 [CLS] this movie was the best movie i have ever seen ! some scenes were ridiculous , but acting was great . [SEP]
" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oO_k1BtSPVt3" + }, + "source": [ + "#Negative sentiment example" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 219 + }, + "id": "gD4xcvovI1KI", + "outputId": "e4a50a94-da4c-460e-b602-052b09cec28f" + }, + "source": [ + "# encode a sentence\n", + "text_batch = [\"I really didn't like this movie. Some of the actors were good, but overall the movie was boring.\"]\n", + "encoding = tokenizer(text_batch, return_tensors='pt')\n", + "input_ids = encoding['input_ids'].to(\"cuda\")\n", + "attention_mask = encoding['attention_mask'].to(\"cuda\")\n", + "\n", + "# generate an explanation for the input\n", + "expl = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, start_layer=0)[0]\n", + "# normalize scores\n", + "expl = (expl - expl.min()) / (expl.max() - expl.min())\n", + "\n", + "# get the model classification\n", + "output = torch.nn.functional.softmax(model(input_ids=input_ids, attention_mask=attention_mask)[0], dim=-1)\n", + "classification = output.argmax(dim=-1).item()\n", + "# get class name\n", + "class_name = classifications[classification]\n", + "# if the classification is negative, higher explanation scores are more negative\n", + "# flip for visualization\n", + "if class_name == \"NEGATIVE\":\n", + " expl *= (-1)\n", + "\n", + "tokens = tokenizer.convert_ids_to_tokens(input_ids.flatten())\n", + "print([(tokens[i], expl[i].item()) for i in range(len(tokens))])\n", + "vis_data_records = [visualization.VisualizationDataRecord(\n", + " expl,\n", + " output[0][classification],\n", + " classification,\n", + " 1,\n", + " 1,\n", + " 1, \n", + " tokens,\n", + " 1)]\n", + "visualization.visualize_text(vis_data_records)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[('[CLS]', -0.0), ('i', -0.19109757244586945), ('really', -0.1888734996318817), ('didn', -0.2894313633441925), (\"'\", -0.006574898026883602), ('t', -0.36788827180862427), ('like', -0.15249046683311462), ('this', -0.18922168016433716), ('movie', -0.0404353104531765), ('.', -0.019592661410570145), ('some', -0.02311306819319725), ('of', -0.0), ('the', -0.02295113168656826), ('actors', -0.09577538073062897), ('were', -0.013370633125305176), ('good', -0.0323222391307354), (',', -0.004366681911051273), ('but', -0.05878860130906105), ('overall', -0.33596664667129517), ('the', -0.21820111572742462), ('movie', -0.05482065677642822), ('was', -0.6248231530189514), ('boring', -1.0), ('.', -0.031107747927308083), ('[SEP]', -0.052539654076099396)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (1.00)11.00 [CLS] i really didn ' t like this movie . some of the actors were good , but overall the movie was boring . [SEP]
" + ] + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (1.00)11.00 [CLS] i really didn ' t like this movie . some of the actors were good , but overall the movie was boring . [SEP]
" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Choosing class for visualization example" + ], + "metadata": { + "id": "UUn2_SMPNG-Y" + } + }, + { + "cell_type": "code", + "source": [ + "# encode a sentence\n", + "text_batch = [\"I hate that I love you.\"]\n", + "encoding = tokenizer(text_batch, return_tensors='pt')\n", + "input_ids = encoding['input_ids'].to(\"cuda\")\n", + "attention_mask = encoding['attention_mask'].to(\"cuda\")\n", + "\n", + "# true class is positive - 1\n", + "true_class = 1\n", + "\n", + "# generate an explanation for the input\n", + "target_class = 0\n", + "expl = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, start_layer=11, index=target_class)[0]\n", + "# normalize scores\n", + "expl = (expl - expl.min()) / (expl.max() - expl.min())\n", + "\n", + "# get the model classification\n", + "output = torch.nn.functional.softmax(model(input_ids=input_ids, attention_mask=attention_mask)[0], dim=-1)\n", + "\n", + "# get class name\n", + "class_name = classifications[target_class]\n", + "# if the classification is negative, higher explanation scores are more negative\n", + "# flip for visualization\n", + "if class_name == \"NEGATIVE\":\n", + " expl *= (-1)\n", + "\n", + "tokens = tokenizer.convert_ids_to_tokens(input_ids.flatten())\n", + "print([(tokens[i], expl[i].item()) for i in range(len(tokens))])\n", + "vis_data_records = [visualization.VisualizationDataRecord(\n", + " expl,\n", + " output[0][classification],\n", + " classification,\n", + " true_class,\n", + " true_class,\n", + " 1, \n", + " tokens,\n", + " 1)]\n", + "visualization.visualize_text(vis_data_records)" + ], + "metadata": { + "id": "VQVmMFnzhPoV", + "outputId": "26a43f8a-340c-4821-b39c-80105a565810", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 219 + } + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[('[CLS]', -0.0), ('i', -0.19790242612361908), ('hate', -1.0), ('that', -0.40287283062934875), ('i', -0.12505637109279633), ('love', -0.1307140290737152), ('you', -0.05467141419649124), ('.', -6.108225989009952e-06), ('[SEP]', -0.0)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (0.91)11.00 [CLS] i hate that i love you . [SEP]
" + ] + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (0.91)11.00 [CLS] i hate that i love you . [SEP]
" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# encode a sentence\n", + "text_batch = [\"I hate that I love you.\"]\n", + "encoding = tokenizer(text_batch, return_tensors='pt')\n", + "input_ids = encoding['input_ids'].to(\"cuda\")\n", + "attention_mask = encoding['attention_mask'].to(\"cuda\")\n", + "\n", + "# true class is positive - 1\n", + "true_class = 1\n", + "\n", + "# generate an explanation for the input\n", + "target_class = 1\n", + "expl = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, start_layer=11, index=target_class)[0]\n", + "# normalize scores\n", + "expl = (expl - expl.min()) / (expl.max() - expl.min())\n", + "\n", + "# get the model classification\n", + "output = torch.nn.functional.softmax(model(input_ids=input_ids, attention_mask=attention_mask)[0], dim=-1)\n", + "\n", + "# get class name\n", + "class_name = classifications[target_class]\n", + "# if the classification is negative, higher explanation scores are more negative\n", + "# flip for visualization\n", + "if class_name == \"NEGATIVE\":\n", + " expl *= (-1)\n", + "\n", + "tokens = tokenizer.convert_ids_to_tokens(input_ids.flatten())\n", + "print([(tokens[i], expl[i].item()) for i in range(len(tokens))])\n", + "vis_data_records = [visualization.VisualizationDataRecord(\n", + " expl,\n", + " output[0][classification],\n", + " classification,\n", + " true_class,\n", + " true_class,\n", + " 1, \n", + " tokens,\n", + " 1)]\n", + "visualization.visualize_text(vis_data_records)" + ], + "metadata": { + "id": "WiQAWw0-imCg", + "outputId": "a8c66996-dcd0-4132-a8b0-2346d9bf9c7b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 219 + } + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[('[CLS]', 0.0), ('i', 0.2725590765476227), ('hate', 0.17270179092884064), ('that', 0.23211266100406647), ('i', 0.17642731964588165), ('love', 1.0), ('you', 0.2465524971485138), ('.', 0.0), ('[SEP]', 0.00015733683540020138)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (0.91)11.00 [CLS] i hate that i love you . [SEP]
" + ] + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Legend: Negative Neutral Positive
True LabelPredicted LabelAttribution LabelAttribution ScoreWord Importance
10 (0.91)11.00 [CLS] i hate that i love you . [SEP]
" + ] + }, + "metadata": {}, + "execution_count": 15 + } + ] + } + ] +} \ No newline at end of file diff --git a/Transformer-Explainability/BERT_explainability/modules/BERT/BERT.py b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT.py new file mode 100644 index 0000000000000000000000000000000000000000..3be9dc53a66e7bb8b885836be39e45f5dd946f4a --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT.py @@ -0,0 +1,748 @@ +from __future__ import absolute_import + +import math + +import torch +import torch.nn.functional as F +from BERT_explainability.modules.layers_ours import * +from torch import nn +from transformers import BertConfig, BertPreTrainedModel, PreTrainedModel +from transformers.modeling_outputs import (BaseModelOutput, + BaseModelOutputWithPooling) + +ACT2FN = { + "relu": ReLU, + "tanh": Tanh, + "gelu": GELU, +} + + +def get_activation(activation_string): + if activation_string in ACT2FN: + return ACT2FN[activation_string] + else: + raise KeyError( + "function {} not found in ACT2FN mapping {}".format( + activation_string, list(ACT2FN.keys()) + ) + ) + + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + all_layer_matrices = [ + all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + for i in range(len(all_layer_matrices)) + ] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer + 1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + + +class BertEmbeddings(nn.Module): + """Construct the embeddings from word, position and token_type embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding( + config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id + ) + self.position_embeddings = nn.Embedding( + config.max_position_embeddings, config.hidden_size + ) + self.token_type_embeddings = nn.Embedding( + config.type_vocab_size, config.hidden_size + ) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + + # position_ids (1, len position emb) is contiguous in memory and exported when serialized + self.register_buffer( + "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)) + ) + + self.add1 = Add() + self.add2 = Add() + + def forward( + self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None + ): + if input_ids is not None: + input_shape = input_ids.size() + else: + input_shape = inputs_embeds.size()[:-1] + + seq_length = input_shape[1] + + if position_ids is None: + position_ids = self.position_ids[:, :seq_length] + + if token_type_ids is None: + token_type_ids = torch.zeros( + input_shape, dtype=torch.long, device=self.position_ids.device + ) + + if inputs_embeds is None: + inputs_embeds = self.word_embeddings(input_ids) + position_embeddings = self.position_embeddings(position_ids) + token_type_embeddings = self.token_type_embeddings(token_type_ids) + + # embeddings = inputs_embeds + position_embeddings + token_type_embeddings + embeddings = self.add1([token_type_embeddings, position_embeddings]) + embeddings = self.add2([embeddings, inputs_embeds]) + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + def relprop(self, cam, **kwargs): + cam = self.dropout.relprop(cam, **kwargs) + cam = self.LayerNorm.relprop(cam, **kwargs) + + # [inputs_embeds, position_embeddings, token_type_embeddings] + (cam) = self.add2.relprop(cam, **kwargs) + + return cam + + +class BertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.layer = nn.ModuleList( + [BertLayer(config) for _ in range(config.num_hidden_layers)] + ) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + output_hidden_states=False, + return_dict=False, + ): + all_hidden_states = () if output_hidden_states else None + all_attentions = () if output_attentions else None + for i, layer_module in enumerate(self.layer): + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer_head_mask = head_mask[i] if head_mask is not None else None + + if getattr(self.config, "gradient_checkpointing", False): + + def create_custom_forward(module): + def custom_forward(*inputs): + return module(*inputs, output_attentions) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(layer_module), + hidden_states, + attention_mask, + layer_head_mask, + ) + else: + layer_outputs = layer_module( + hidden_states, + attention_mask, + layer_head_mask, + output_attentions, + ) + hidden_states = layer_outputs[0] + if output_attentions: + all_attentions = all_attentions + (layer_outputs[1],) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + if not return_dict: + return tuple( + v + for v in [hidden_states, all_hidden_states, all_attentions] + if v is not None + ) + return BaseModelOutput( + last_hidden_state=hidden_states, + hidden_states=all_hidden_states, + attentions=all_attentions, + ) + + def relprop(self, cam, **kwargs): + # assuming output_hidden_states is False + for layer_module in reversed(self.layer): + cam = layer_module.relprop(cam, **kwargs) + return cam + + +# not adding relprop since this is only pooling at the end of the network, does not impact tokens importance +class BertPooler(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.hidden_size) + self.activation = Tanh() + self.pool = IndexSelect() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + self._seq_size = hidden_states.shape[1] + + # first_token_tensor = hidden_states[:, 0] + first_token_tensor = self.pool( + hidden_states, 1, torch.tensor(0, device=hidden_states.device) + ) + first_token_tensor = first_token_tensor.squeeze(1) + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + def relprop(self, cam, **kwargs): + cam = self.activation.relprop(cam, **kwargs) + # print(cam.sum()) + cam = self.dense.relprop(cam, **kwargs) + # print(cam.sum()) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + # print(cam.sum()) + + return cam + + +class BertAttention(nn.Module): + def __init__(self, config): + super().__init__() + self.self = BertSelfAttention(config) + self.output = BertSelfOutput(config) + self.pruned_heads = set() + self.clone = Clone() + + def prune_heads(self, heads): + if len(heads) == 0: + return + heads, index = find_pruneable_heads_and_indices( + heads, + self.self.num_attention_heads, + self.self.attention_head_size, + self.pruned_heads, + ) + + # Prune linear layers + self.self.query = prune_linear_layer(self.self.query, index) + self.self.key = prune_linear_layer(self.self.key, index) + self.self.value = prune_linear_layer(self.self.value, index) + self.output.dense = prune_linear_layer(self.output.dense, index, dim=1) + + # Update hyper params and store pruned heads + self.self.num_attention_heads = self.self.num_attention_heads - len(heads) + self.self.all_head_size = ( + self.self.attention_head_size * self.self.num_attention_heads + ) + self.pruned_heads = self.pruned_heads.union(heads) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + ): + h1, h2 = self.clone(hidden_states, 2) + self_outputs = self.self( + h1, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + output_attentions, + ) + attention_output = self.output(self_outputs[0], h2) + outputs = (attention_output,) + self_outputs[ + 1: + ] # add attentions if we output them + return outputs + + def relprop(self, cam, **kwargs): + # assuming that we don't ouput the attentions (outputs = (attention_output,)), self_outputs=(context_layer,) + (cam1, cam2) = self.output.relprop(cam, **kwargs) + # print(cam1.sum(), cam2.sum(), (cam1 + cam2).sum()) + cam1 = self.self.relprop(cam1, **kwargs) + # print(cam1.sum(), cam2.sum(), (cam1 + cam2).sum()) + + return self.clone.relprop((cam1, cam2), **kwargs) + + +class BertSelfAttention(nn.Module): + def __init__(self, config): + super().__init__() + if config.hidden_size % config.num_attention_heads != 0 and not hasattr( + config, "embedding_size" + ): + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = Linear(config.hidden_size, self.all_head_size) + self.key = Linear(config.hidden_size, self.all_head_size) + self.value = Linear(config.hidden_size, self.all_head_size) + + self.dropout = Dropout(config.attention_probs_dropout_prob) + + self.matmul1 = MatMul() + self.matmul2 = MatMul() + self.softmax = Softmax(dim=-1) + self.add = Add() + self.mul = Mul() + self.head_mask = None + self.attention_mask = None + self.clone = Clone() + + self.attn_cam = None + self.attn = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def transpose_for_scores_relprop(self, x): + return x.permute(0, 2, 1, 3).flatten(2) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + ): + self.head_mask = head_mask + self.attention_mask = attention_mask + + h1, h2, h3 = self.clone(hidden_states, 3) + mixed_query_layer = self.query(h1) + + # If this is instantiated as a cross-attention module, the keys + # and values come from an encoder; the attention mask needs to be + # such that the encoder's padding tokens are not attended to. + if encoder_hidden_states is not None: + mixed_key_layer = self.key(encoder_hidden_states) + mixed_value_layer = self.value(encoder_hidden_states) + attention_mask = encoder_attention_mask + else: + mixed_key_layer = self.key(h2) + mixed_value_layer = self.value(h3) + + query_layer = self.transpose_for_scores(mixed_query_layer) + key_layer = self.transpose_for_scores(mixed_key_layer) + value_layer = self.transpose_for_scores(mixed_value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = self.matmul1([query_layer, key_layer.transpose(-1, -2)]) + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + attention_scores = self.add([attention_scores, attention_mask]) + + # Normalize the attention scores to probabilities. + attention_probs = self.softmax(attention_scores) + + self.save_attn(attention_probs) + attention_probs.register_hook(self.save_attn_gradients) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs = self.dropout(attention_probs) + + # Mask heads if we want to + if head_mask is not None: + attention_probs = attention_probs * head_mask + + context_layer = self.matmul2([attention_probs, value_layer]) + + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = ( + (context_layer, attention_probs) if output_attentions else (context_layer,) + ) + return outputs + + def relprop(self, cam, **kwargs): + # Assume output_attentions == False + cam = self.transpose_for_scores(cam) + + # [attention_probs, value_layer] + (cam1, cam2) = self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam2 /= 2 + if self.head_mask is not None: + # [attention_probs, head_mask] + (cam1, _) = self.mul.relprop(cam1, **kwargs) + + self.save_attn_cam(cam1) + + cam1 = self.dropout.relprop(cam1, **kwargs) + + cam1 = self.softmax.relprop(cam1, **kwargs) + + if self.attention_mask is not None: + # [attention_scores, attention_mask] + (cam1, _) = self.add.relprop(cam1, **kwargs) + + # [query_layer, key_layer.transpose(-1, -2)] + (cam1_1, cam1_2) = self.matmul1.relprop(cam1, **kwargs) + cam1_1 /= 2 + cam1_2 /= 2 + + # query + cam1_1 = self.transpose_for_scores_relprop(cam1_1) + cam1_1 = self.query.relprop(cam1_1, **kwargs) + + # key + cam1_2 = self.transpose_for_scores_relprop(cam1_2.transpose(-1, -2)) + cam1_2 = self.key.relprop(cam1_2, **kwargs) + + # value + cam2 = self.transpose_for_scores_relprop(cam2) + cam2 = self.value.relprop(cam2, **kwargs) + + cam = self.clone.relprop((cam1_1, cam1_2, cam2), **kwargs) + + return cam + + +class BertSelfOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + self.add = Add() + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + add = self.add([hidden_states, input_tensor]) + hidden_states = self.LayerNorm(add) + return hidden_states + + def relprop(self, cam, **kwargs): + cam = self.LayerNorm.relprop(cam, **kwargs) + # [hidden_states, input_tensor] + (cam1, cam2) = self.add.relprop(cam, **kwargs) + cam1 = self.dropout.relprop(cam1, **kwargs) + cam1 = self.dense.relprop(cam1, **kwargs) + + return (cam1, cam2) + + +class BertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.intermediate_size) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act]() + else: + self.intermediate_act_fn = config.hidden_act + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + def relprop(self, cam, **kwargs): + cam = self.intermediate_act_fn.relprop(cam, **kwargs) # FIXME only ReLU + # print(cam.sum()) + cam = self.dense.relprop(cam, **kwargs) + # print(cam.sum()) + return cam + + +class BertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + self.add = Add() + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + add = self.add([hidden_states, input_tensor]) + hidden_states = self.LayerNorm(add) + return hidden_states + + def relprop(self, cam, **kwargs): + # print("in", cam.sum()) + cam = self.LayerNorm.relprop(cam, **kwargs) + # print(cam.sum()) + # [hidden_states, input_tensor] + (cam1, cam2) = self.add.relprop(cam, **kwargs) + # print("add", cam1.sum(), cam2.sum(), cam1.sum() + cam2.sum()) + cam1 = self.dropout.relprop(cam1, **kwargs) + # print(cam1.sum()) + cam1 = self.dense.relprop(cam1, **kwargs) + # print("dense", cam1.sum()) + + # print("out", cam1.sum() + cam2.sum(), cam1.sum(), cam2.sum()) + return (cam1, cam2) + + +class BertLayer(nn.Module): + def __init__(self, config): + super().__init__() + self.attention = BertAttention(config) + self.intermediate = BertIntermediate(config) + self.output = BertOutput(config) + self.clone = Clone() + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + output_attentions=False, + ): + self_attention_outputs = self.attention( + hidden_states, + attention_mask, + head_mask, + output_attentions=output_attentions, + ) + attention_output = self_attention_outputs[0] + outputs = self_attention_outputs[ + 1: + ] # add self attentions if we output attention weights + + ao1, ao2 = self.clone(attention_output, 2) + intermediate_output = self.intermediate(ao1) + layer_output = self.output(intermediate_output, ao2) + + outputs = (layer_output,) + outputs + return outputs + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.output.relprop(cam, **kwargs) + # print("output", cam1.sum(), cam2.sum(), cam1.sum() + cam2.sum()) + cam1 = self.intermediate.relprop(cam1, **kwargs) + # print("intermediate", cam1.sum()) + cam = self.clone.relprop((cam1, cam2), **kwargs) + # print("clone", cam.sum()) + cam = self.attention.relprop(cam, **kwargs) + # print("attention", cam.sum()) + return cam + + +class BertModel(BertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.config = config + + self.embeddings = BertEmbeddings(config) + self.encoder = BertEncoder(config) + self.pooler = BertPooler(config) + + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + + def forward( + self, + input_ids=None, + attention_mask=None, + token_type_ids=None, + position_ids=None, + head_mask=None, + inputs_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention + if the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask + is used in the cross-attention if the model is configured as a decoder. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + """ + output_attentions = ( + output_attentions + if output_attentions is not None + else self.config.output_attentions + ) + output_hidden_states = ( + output_hidden_states + if output_hidden_states is not None + else self.config.output_hidden_states + ) + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + if input_ids is not None and inputs_embeds is not None: + raise ValueError( + "You cannot specify both input_ids and inputs_embeds at the same time" + ) + elif input_ids is not None: + input_shape = input_ids.size() + elif inputs_embeds is not None: + input_shape = inputs_embeds.size()[:-1] + else: + raise ValueError("You have to specify either input_ids or inputs_embeds") + + device = input_ids.device if input_ids is not None else inputs_embeds.device + + if attention_mask is None: + attention_mask = torch.ones(input_shape, device=device) + if token_type_ids is None: + token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + extended_attention_mask: torch.Tensor = self.get_extended_attention_mask( + attention_mask, input_shape, device + ) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if self.config.is_decoder and encoder_hidden_states is not None: + ( + encoder_batch_size, + encoder_sequence_length, + _, + ) = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + if encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = None + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + token_type_ids=token_type_ids, + inputs_embeds=inputs_embeds, + ) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + sequence_output = encoder_outputs[0] + pooled_output = self.pooler(sequence_output) + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPooling( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + ) + + def relprop(self, cam, **kwargs): + cam = self.pooler.relprop(cam, **kwargs) + # print("111111111111",cam.sum()) + cam = self.encoder.relprop(cam, **kwargs) + # print("222222222222222", cam.sum()) + # print("conservation: ", cam.sum()) + return cam + + +if __name__ == "__main__": + + class Config: + def __init__( + self, hidden_size, num_attention_heads, attention_probs_dropout_prob + ): + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.attention_probs_dropout_prob = attention_probs_dropout_prob + + model = BertSelfAttention(Config(1024, 4, 0.1)) + x = torch.rand(2, 20, 1024) + x.requires_grad_() + + model.eval() + + y = model.forward(x) + + relprop = model.relprop(torch.rand(2, 20, 1024), (torch.rand(2, 20, 1024),)) + + print(relprop[1][0].shape) diff --git a/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_cls_lrp.py b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_cls_lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..67a61ec9d350251eb4a4ab84ba4775cc2ffae058 --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_cls_lrp.py @@ -0,0 +1,240 @@ +from typing import Any, List + +import torch +import torch.nn as nn +from BERT_explainability.modules.BERT.BERT_orig_lrp import BertModel +from BERT_explainability.modules.layers_lrp import * +from BERT_rationale_benchmark.models.model_utils import PaddedSequence +from torch.nn import CrossEntropyLoss, MSELoss +from transformers import BertPreTrainedModel +from transformers.utils import logging + + +class BertForSequenceClassification(BertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.num_labels = config.num_labels + + self.bert = BertModel(config) + self.dropout = Dropout(config.hidden_dropout_prob) + self.classifier = Linear(config.hidden_size, config.num_labels) + + self.init_weights() + + def forward( + self, + input_ids=None, + attention_mask=None, + token_type_ids=None, + position_ids=None, + head_mask=None, + inputs_embeds=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`): + Labels for computing the sequence classification/regression loss. + Indices should be in :obj:`[0, ..., config.num_labels - 1]`. + If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss), + If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy). + """ + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + token_type_ids=token_type_ids, + position_ids=position_ids, + head_mask=head_mask, + inputs_embeds=inputs_embeds, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + pooled_output = outputs[1] + + pooled_output = self.dropout(pooled_output) + logits = self.classifier(pooled_output) + + loss = None + if labels is not None: + if self.num_labels == 1: + # We are doing regression + loss_fct = MSELoss() + loss = loss_fct(logits.view(-1), labels.view(-1)) + else: + loss_fct = CrossEntropyLoss() + loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1)) + + if not return_dict: + output = (logits,) + outputs[2:] + return ((loss,) + output) if loss is not None else output + + return SequenceClassifierOutput( + loss=loss, + logits=logits, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def relprop(self, cam=None, **kwargs): + cam = self.classifier.relprop(cam, **kwargs) + cam = self.dropout.relprop(cam, **kwargs) + cam = self.bert.relprop(cam, **kwargs) + return cam + + +# this is the actual classifier we will be using +class BertClassifier(nn.Module): + """Thin wrapper around BertForSequenceClassification""" + + def __init__( + self, + bert_dir: str, + pad_token_id: int, + cls_token_id: int, + sep_token_id: int, + num_labels: int, + max_length: int = 512, + use_half_precision=True, + ): + super(BertClassifier, self).__init__() + bert = BertForSequenceClassification.from_pretrained( + bert_dir, num_labels=num_labels + ) + if use_half_precision: + import apex + + bert = bert.half() + self.bert = bert + self.pad_token_id = pad_token_id + self.cls_token_id = cls_token_id + self.sep_token_id = sep_token_id + self.max_length = max_length + + def forward( + self, + query: List[torch.tensor], + docids: List[Any], + document_batch: List[torch.tensor], + ): + assert len(query) == len(document_batch) + print(query) + # note about device management: + # since distributed training is enabled, the inputs to this module can be on *any* device (preferably cpu, since we wrap and unwrap the module) + # we want to keep these params on the input device (assuming CPU) for as long as possible for cheap memory access + target_device = next(self.parameters()).device + cls_token = torch.tensor([self.cls_token_id]).to( + device=document_batch[0].device + ) + sep_token = torch.tensor([self.sep_token_id]).to( + device=document_batch[0].device + ) + input_tensors = [] + position_ids = [] + for q, d in zip(query, document_batch): + if len(q) + len(d) + 2 > self.max_length: + d = d[: (self.max_length - len(q) - 2)] + input_tensors.append(torch.cat([cls_token, q, sep_token, d])) + position_ids.append( + torch.tensor(list(range(0, len(q) + 1)) + list(range(0, len(d) + 1))) + ) + bert_input = PaddedSequence.autopad( + input_tensors, + batch_first=True, + padding_value=self.pad_token_id, + device=target_device, + ) + positions = PaddedSequence.autopad( + position_ids, batch_first=True, padding_value=0, device=target_device + ) + (classes,) = self.bert( + bert_input.data, + attention_mask=bert_input.mask( + on=0.0, off=float("-inf"), device=target_device + ), + position_ids=positions.data, + ) + assert torch.all(classes == classes) # for nans + + print(input_tensors[0]) + print(self.relprop()[0]) + + return classes + + def relprop(self, cam=None, **kwargs): + return self.bert.relprop(cam, **kwargs) + + +if __name__ == "__main__": + import os + + from transformers import BertTokenizer + + class Config: + def __init__( + self, + hidden_size, + num_attention_heads, + attention_probs_dropout_prob, + num_labels, + hidden_dropout_prob, + ): + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.attention_probs_dropout_prob = attention_probs_dropout_prob + self.num_labels = num_labels + self.hidden_dropout_prob = hidden_dropout_prob + + tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") + x = tokenizer.encode_plus( + "In this movie the acting is great. The movie is perfect! [sep]", + add_special_tokens=True, + max_length=512, + return_token_type_ids=False, + return_attention_mask=True, + pad_to_max_length=True, + return_tensors="pt", + truncation=True, + ) + + print(x["input_ids"]) + + model = BertForSequenceClassification.from_pretrained( + "bert-base-uncased", num_labels=2 + ) + model_save_file = os.path.join( + "./BERT_explainability/output_bert/movies/classifier/", "classifier.pt" + ) + model.load_state_dict(torch.load(model_save_file)) + + # x = torch.randint(100, (2, 20)) + # x = torch.tensor([[101, 2054, 2003, 1996, 15792, 1997, 2023, 3319, 1029, 102, + # 101, 4079, 102, 101, 6732, 102, 101, 2643, 102, 101, + # 2038, 102, 101, 1037, 102, 101, 2933, 102, 101, 2005, + # 102, 101, 2032, 102, 101, 1010, 102, 101, 1037, 102, + # 101, 3800, 102, 101, 2005, 102, 101, 2010, 102, 101, + # 2166, 102, 101, 1010, 102, 101, 1998, 102, 101, 2010, + # 102, 101, 4650, 102, 101, 1010, 102, 101, 2002, 102, + # 101, 2074, 102, 101, 2515, 102, 101, 1050, 102, 101, + # 1005, 102, 101, 1056, 102, 101, 2113, 102, 101, 2054, + # 102, 101, 1012, 102]]) + # x.requires_grad_() + + model.eval() + + y = model(x["input_ids"], x["attention_mask"]) + print(y) + + cam, _ = model.relprop() + + # print(cam.shape) + + cam = cam.sum(-1) + # print(cam) diff --git a/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_orig_lrp.py b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_orig_lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..9736d07741f8b22768aea05a7870aed6531344ab --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/BERT/BERT_orig_lrp.py @@ -0,0 +1,748 @@ +from __future__ import absolute_import + +import math + +import torch +import torch.nn.functional as F +from BERT_explainability.modules.layers_lrp import * +from torch import nn +from transformers import BertConfig, BertPreTrainedModel, PreTrainedModel +from transformers.modeling_outputs import (BaseModelOutput, + BaseModelOutputWithPooling) + +ACT2FN = { + "relu": ReLU, + "tanh": Tanh, + "gelu": GELU, +} + + +def get_activation(activation_string): + if activation_string in ACT2FN: + return ACT2FN[activation_string] + else: + raise KeyError( + "function {} not found in ACT2FN mapping {}".format( + activation_string, list(ACT2FN.keys()) + ) + ) + + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + all_layer_matrices = [ + all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + for i in range(len(all_layer_matrices)) + ] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer + 1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + + +class BertEmbeddings(nn.Module): + """Construct the embeddings from word, position and token_type embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding( + config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id + ) + self.position_embeddings = nn.Embedding( + config.max_position_embeddings, config.hidden_size + ) + self.token_type_embeddings = nn.Embedding( + config.type_vocab_size, config.hidden_size + ) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + + # position_ids (1, len position emb) is contiguous in memory and exported when serialized + self.register_buffer( + "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)) + ) + + self.add1 = Add() + self.add2 = Add() + + def forward( + self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None + ): + if input_ids is not None: + input_shape = input_ids.size() + else: + input_shape = inputs_embeds.size()[:-1] + + seq_length = input_shape[1] + + if position_ids is None: + position_ids = self.position_ids[:, :seq_length] + + if token_type_ids is None: + token_type_ids = torch.zeros( + input_shape, dtype=torch.long, device=self.position_ids.device + ) + + if inputs_embeds is None: + inputs_embeds = self.word_embeddings(input_ids) + position_embeddings = self.position_embeddings(position_ids) + token_type_embeddings = self.token_type_embeddings(token_type_ids) + + # embeddings = inputs_embeds + position_embeddings + token_type_embeddings + embeddings = self.add1([token_type_embeddings, position_embeddings]) + embeddings = self.add2([embeddings, inputs_embeds]) + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + def relprop(self, cam, **kwargs): + cam = self.dropout.relprop(cam, **kwargs) + cam = self.LayerNorm.relprop(cam, **kwargs) + + # [inputs_embeds, position_embeddings, token_type_embeddings] + (cam) = self.add2.relprop(cam, **kwargs) + + return cam + + +class BertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.layer = nn.ModuleList( + [BertLayer(config) for _ in range(config.num_hidden_layers)] + ) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + output_hidden_states=False, + return_dict=False, + ): + all_hidden_states = () if output_hidden_states else None + all_attentions = () if output_attentions else None + for i, layer_module in enumerate(self.layer): + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer_head_mask = head_mask[i] if head_mask is not None else None + + if getattr(self.config, "gradient_checkpointing", False): + + def create_custom_forward(module): + def custom_forward(*inputs): + return module(*inputs, output_attentions) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(layer_module), + hidden_states, + attention_mask, + layer_head_mask, + ) + else: + layer_outputs = layer_module( + hidden_states, + attention_mask, + layer_head_mask, + output_attentions, + ) + hidden_states = layer_outputs[0] + if output_attentions: + all_attentions = all_attentions + (layer_outputs[1],) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + if not return_dict: + return tuple( + v + for v in [hidden_states, all_hidden_states, all_attentions] + if v is not None + ) + return BaseModelOutput( + last_hidden_state=hidden_states, + hidden_states=all_hidden_states, + attentions=all_attentions, + ) + + def relprop(self, cam, **kwargs): + # assuming output_hidden_states is False + for layer_module in reversed(self.layer): + cam = layer_module.relprop(cam, **kwargs) + return cam + + +# not adding relprop since this is only pooling at the end of the network, does not impact tokens importance +class BertPooler(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.hidden_size) + self.activation = Tanh() + self.pool = IndexSelect() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + self._seq_size = hidden_states.shape[1] + + # first_token_tensor = hidden_states[:, 0] + first_token_tensor = self.pool( + hidden_states, 1, torch.tensor(0, device=hidden_states.device) + ) + first_token_tensor = first_token_tensor.squeeze(1) + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + def relprop(self, cam, **kwargs): + cam = self.activation.relprop(cam, **kwargs) + # print(cam.sum()) + cam = self.dense.relprop(cam, **kwargs) + # print(cam.sum()) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + # print(cam.sum()) + + return cam + + +class BertAttention(nn.Module): + def __init__(self, config): + super().__init__() + self.self = BertSelfAttention(config) + self.output = BertSelfOutput(config) + self.pruned_heads = set() + self.clone = Clone() + + def prune_heads(self, heads): + if len(heads) == 0: + return + heads, index = find_pruneable_heads_and_indices( + heads, + self.self.num_attention_heads, + self.self.attention_head_size, + self.pruned_heads, + ) + + # Prune linear layers + self.self.query = prune_linear_layer(self.self.query, index) + self.self.key = prune_linear_layer(self.self.key, index) + self.self.value = prune_linear_layer(self.self.value, index) + self.output.dense = prune_linear_layer(self.output.dense, index, dim=1) + + # Update hyper params and store pruned heads + self.self.num_attention_heads = self.self.num_attention_heads - len(heads) + self.self.all_head_size = ( + self.self.attention_head_size * self.self.num_attention_heads + ) + self.pruned_heads = self.pruned_heads.union(heads) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + ): + h1, h2 = self.clone(hidden_states, 2) + self_outputs = self.self( + h1, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + output_attentions, + ) + attention_output = self.output(self_outputs[0], h2) + outputs = (attention_output,) + self_outputs[ + 1: + ] # add attentions if we output them + return outputs + + def relprop(self, cam, **kwargs): + # assuming that we don't ouput the attentions (outputs = (attention_output,)), self_outputs=(context_layer,) + (cam1, cam2) = self.output.relprop(cam, **kwargs) + # print(cam1.sum(), cam2.sum(), (cam1 + cam2).sum()) + cam1 = self.self.relprop(cam1, **kwargs) + # print(cam1.sum(), cam2.sum(), (cam1 + cam2).sum()) + + return self.clone.relprop((cam1, cam2), **kwargs) + + +class BertSelfAttention(nn.Module): + def __init__(self, config): + super().__init__() + if config.hidden_size % config.num_attention_heads != 0 and not hasattr( + config, "embedding_size" + ): + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = Linear(config.hidden_size, self.all_head_size) + self.key = Linear(config.hidden_size, self.all_head_size) + self.value = Linear(config.hidden_size, self.all_head_size) + + self.dropout = Dropout(config.attention_probs_dropout_prob) + + self.matmul1 = MatMul() + self.matmul2 = MatMul() + self.softmax = Softmax(dim=-1) + self.add = Add() + self.mul = Mul() + self.head_mask = None + self.attention_mask = None + self.clone = Clone() + + self.attn_cam = None + self.attn = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def transpose_for_scores_relprop(self, x): + return x.permute(0, 2, 1, 3).flatten(2) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=False, + ): + self.head_mask = head_mask + self.attention_mask = attention_mask + + h1, h2, h3 = self.clone(hidden_states, 3) + mixed_query_layer = self.query(h1) + + # If this is instantiated as a cross-attention module, the keys + # and values come from an encoder; the attention mask needs to be + # such that the encoder's padding tokens are not attended to. + if encoder_hidden_states is not None: + mixed_key_layer = self.key(encoder_hidden_states) + mixed_value_layer = self.value(encoder_hidden_states) + attention_mask = encoder_attention_mask + else: + mixed_key_layer = self.key(h2) + mixed_value_layer = self.value(h3) + + query_layer = self.transpose_for_scores(mixed_query_layer) + key_layer = self.transpose_for_scores(mixed_key_layer) + value_layer = self.transpose_for_scores(mixed_value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = self.matmul1([query_layer, key_layer.transpose(-1, -2)]) + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + attention_scores = self.add([attention_scores, attention_mask]) + + # Normalize the attention scores to probabilities. + attention_probs = self.softmax(attention_scores) + + self.save_attn(attention_probs) + attention_probs.register_hook(self.save_attn_gradients) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs = self.dropout(attention_probs) + + # Mask heads if we want to + if head_mask is not None: + attention_probs = attention_probs * head_mask + + context_layer = self.matmul2([attention_probs, value_layer]) + + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = ( + (context_layer, attention_probs) if output_attentions else (context_layer,) + ) + return outputs + + def relprop(self, cam, **kwargs): + # Assume output_attentions == False + cam = self.transpose_for_scores(cam) + + # [attention_probs, value_layer] + (cam1, cam2) = self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam2 /= 2 + if self.head_mask is not None: + # [attention_probs, head_mask] + (cam1, _) = self.mul.relprop(cam1, **kwargs) + + self.save_attn_cam(cam1) + + cam1 = self.dropout.relprop(cam1, **kwargs) + + cam1 = self.softmax.relprop(cam1, **kwargs) + + if self.attention_mask is not None: + # [attention_scores, attention_mask] + (cam1, _) = self.add.relprop(cam1, **kwargs) + + # [query_layer, key_layer.transpose(-1, -2)] + (cam1_1, cam1_2) = self.matmul1.relprop(cam1, **kwargs) + cam1_1 /= 2 + cam1_2 /= 2 + + # query + cam1_1 = self.transpose_for_scores_relprop(cam1_1) + cam1_1 = self.query.relprop(cam1_1, **kwargs) + + # key + cam1_2 = self.transpose_for_scores_relprop(cam1_2.transpose(-1, -2)) + cam1_2 = self.key.relprop(cam1_2, **kwargs) + + # value + cam2 = self.transpose_for_scores_relprop(cam2) + cam2 = self.value.relprop(cam2, **kwargs) + + cam = self.clone.relprop((cam1_1, cam1_2, cam2), **kwargs) + + return cam + + +class BertSelfOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + self.add = Add() + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + add = self.add([hidden_states, input_tensor]) + hidden_states = self.LayerNorm(add) + return hidden_states + + def relprop(self, cam, **kwargs): + cam = self.LayerNorm.relprop(cam, **kwargs) + # [hidden_states, input_tensor] + (cam1, cam2) = self.add.relprop(cam, **kwargs) + cam1 = self.dropout.relprop(cam1, **kwargs) + cam1 = self.dense.relprop(cam1, **kwargs) + + return (cam1, cam2) + + +class BertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.hidden_size, config.intermediate_size) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act]() + else: + self.intermediate_act_fn = config.hidden_act + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + def relprop(self, cam, **kwargs): + cam = self.intermediate_act_fn.relprop(cam, **kwargs) # FIXME only ReLU + # print(cam.sum()) + cam = self.dense.relprop(cam, **kwargs) + # print(cam.sum()) + return cam + + +class BertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = Dropout(config.hidden_dropout_prob) + self.add = Add() + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + add = self.add([hidden_states, input_tensor]) + hidden_states = self.LayerNorm(add) + return hidden_states + + def relprop(self, cam, **kwargs): + # print("in", cam.sum()) + cam = self.LayerNorm.relprop(cam, **kwargs) + # print(cam.sum()) + # [hidden_states, input_tensor] + (cam1, cam2) = self.add.relprop(cam, **kwargs) + # print("add", cam1.sum(), cam2.sum(), cam1.sum() + cam2.sum()) + cam1 = self.dropout.relprop(cam1, **kwargs) + # print(cam1.sum()) + cam1 = self.dense.relprop(cam1, **kwargs) + # print("dense", cam1.sum()) + + # print("out", cam1.sum() + cam2.sum(), cam1.sum(), cam2.sum()) + return (cam1, cam2) + + +class BertLayer(nn.Module): + def __init__(self, config): + super().__init__() + self.attention = BertAttention(config) + self.intermediate = BertIntermediate(config) + self.output = BertOutput(config) + self.clone = Clone() + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + output_attentions=False, + ): + self_attention_outputs = self.attention( + hidden_states, + attention_mask, + head_mask, + output_attentions=output_attentions, + ) + attention_output = self_attention_outputs[0] + outputs = self_attention_outputs[ + 1: + ] # add self attentions if we output attention weights + + ao1, ao2 = self.clone(attention_output, 2) + intermediate_output = self.intermediate(ao1) + layer_output = self.output(intermediate_output, ao2) + + outputs = (layer_output,) + outputs + return outputs + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.output.relprop(cam, **kwargs) + # print("output", cam1.sum(), cam2.sum(), cam1.sum() + cam2.sum()) + cam1 = self.intermediate.relprop(cam1, **kwargs) + # print("intermediate", cam1.sum()) + cam = self.clone.relprop((cam1, cam2), **kwargs) + # print("clone", cam.sum()) + cam = self.attention.relprop(cam, **kwargs) + # print("attention", cam.sum()) + return cam + + +class BertModel(BertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.config = config + + self.embeddings = BertEmbeddings(config) + self.encoder = BertEncoder(config) + self.pooler = BertPooler(config) + + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + + def forward( + self, + input_ids=None, + attention_mask=None, + token_type_ids=None, + position_ids=None, + head_mask=None, + inputs_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention + if the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask + is used in the cross-attention if the model is configured as a decoder. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + """ + output_attentions = ( + output_attentions + if output_attentions is not None + else self.config.output_attentions + ) + output_hidden_states = ( + output_hidden_states + if output_hidden_states is not None + else self.config.output_hidden_states + ) + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + if input_ids is not None and inputs_embeds is not None: + raise ValueError( + "You cannot specify both input_ids and inputs_embeds at the same time" + ) + elif input_ids is not None: + input_shape = input_ids.size() + elif inputs_embeds is not None: + input_shape = inputs_embeds.size()[:-1] + else: + raise ValueError("You have to specify either input_ids or inputs_embeds") + + device = input_ids.device if input_ids is not None else inputs_embeds.device + + if attention_mask is None: + attention_mask = torch.ones(input_shape, device=device) + if token_type_ids is None: + token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + extended_attention_mask: torch.Tensor = self.get_extended_attention_mask( + attention_mask, input_shape, device + ) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if self.config.is_decoder and encoder_hidden_states is not None: + ( + encoder_batch_size, + encoder_sequence_length, + _, + ) = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + if encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = None + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + token_type_ids=token_type_ids, + inputs_embeds=inputs_embeds, + ) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + sequence_output = encoder_outputs[0] + pooled_output = self.pooler(sequence_output) + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPooling( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + ) + + def relprop(self, cam, **kwargs): + cam = self.pooler.relprop(cam, **kwargs) + # print("111111111111",cam.sum()) + cam = self.encoder.relprop(cam, **kwargs) + # print("222222222222222", cam.sum()) + # print("conservation: ", cam.sum()) + return cam + + +if __name__ == "__main__": + + class Config: + def __init__( + self, hidden_size, num_attention_heads, attention_probs_dropout_prob + ): + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.attention_probs_dropout_prob = attention_probs_dropout_prob + + model = BertSelfAttention(Config(1024, 4, 0.1)) + x = torch.rand(2, 20, 1024) + x.requires_grad_() + + model.eval() + + y = model.forward(x) + + relprop = model.relprop(torch.rand(2, 20, 1024), (torch.rand(2, 20, 1024),)) + + print(relprop[1][0].shape) diff --git a/Transformer-Explainability/BERT_explainability/modules/BERT/BertForSequenceClassification.py b/Transformer-Explainability/BERT_explainability/modules/BERT/BertForSequenceClassification.py new file mode 100644 index 0000000000000000000000000000000000000000..0d48f31e0586d6dcb6035879a4c2f34846da81ae --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/BERT/BertForSequenceClassification.py @@ -0,0 +1,241 @@ +from typing import Any, List + +import torch +import torch.nn as nn +from BERT_explainability.modules.BERT.BERT import BertModel +from BERT_explainability.modules.layers_ours import * +from BERT_rationale_benchmark.models.model_utils import PaddedSequence +from torch.nn import CrossEntropyLoss, MSELoss +from transformers import BertPreTrainedModel +from transformers.utils import logging + + +class BertForSequenceClassification(BertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.num_labels = config.num_labels + + self.bert = BertModel(config) + self.dropout = Dropout(config.hidden_dropout_prob) + self.classifier = Linear(config.hidden_size, config.num_labels) + + self.init_weights() + + def forward( + self, + input_ids=None, + attention_mask=None, + token_type_ids=None, + position_ids=None, + head_mask=None, + inputs_embeds=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`): + Labels for computing the sequence classification/regression loss. + Indices should be in :obj:`[0, ..., config.num_labels - 1]`. + If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss), + If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy). + """ + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + token_type_ids=token_type_ids, + position_ids=position_ids, + head_mask=head_mask, + inputs_embeds=inputs_embeds, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + pooled_output = outputs[1] + + pooled_output = self.dropout(pooled_output) + logits = self.classifier(pooled_output) + + loss = None + if labels is not None: + if self.num_labels == 1: + # We are doing regression + loss_fct = MSELoss() + loss = loss_fct(logits.view(-1), labels.view(-1)) + else: + loss_fct = CrossEntropyLoss() + loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1)) + + if not return_dict: + output = (logits,) + outputs[2:] + return ((loss,) + output) if loss is not None else output + + return SequenceClassifierOutput( + loss=loss, + logits=logits, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def relprop(self, cam=None, **kwargs): + cam = self.classifier.relprop(cam, **kwargs) + cam = self.dropout.relprop(cam, **kwargs) + cam = self.bert.relprop(cam, **kwargs) + # print("conservation: ", cam.sum()) + return cam + + +# this is the actual classifier we will be using +class BertClassifier(nn.Module): + """Thin wrapper around BertForSequenceClassification""" + + def __init__( + self, + bert_dir: str, + pad_token_id: int, + cls_token_id: int, + sep_token_id: int, + num_labels: int, + max_length: int = 512, + use_half_precision=True, + ): + super(BertClassifier, self).__init__() + bert = BertForSequenceClassification.from_pretrained( + bert_dir, num_labels=num_labels + ) + if use_half_precision: + import apex + + bert = bert.half() + self.bert = bert + self.pad_token_id = pad_token_id + self.cls_token_id = cls_token_id + self.sep_token_id = sep_token_id + self.max_length = max_length + + def forward( + self, + query: List[torch.tensor], + docids: List[Any], + document_batch: List[torch.tensor], + ): + assert len(query) == len(document_batch) + print(query) + # note about device management: + # since distributed training is enabled, the inputs to this module can be on *any* device (preferably cpu, since we wrap and unwrap the module) + # we want to keep these params on the input device (assuming CPU) for as long as possible for cheap memory access + target_device = next(self.parameters()).device + cls_token = torch.tensor([self.cls_token_id]).to( + device=document_batch[0].device + ) + sep_token = torch.tensor([self.sep_token_id]).to( + device=document_batch[0].device + ) + input_tensors = [] + position_ids = [] + for q, d in zip(query, document_batch): + if len(q) + len(d) + 2 > self.max_length: + d = d[: (self.max_length - len(q) - 2)] + input_tensors.append(torch.cat([cls_token, q, sep_token, d])) + position_ids.append( + torch.tensor(list(range(0, len(q) + 1)) + list(range(0, len(d) + 1))) + ) + bert_input = PaddedSequence.autopad( + input_tensors, + batch_first=True, + padding_value=self.pad_token_id, + device=target_device, + ) + positions = PaddedSequence.autopad( + position_ids, batch_first=True, padding_value=0, device=target_device + ) + (classes,) = self.bert( + bert_input.data, + attention_mask=bert_input.mask( + on=0.0, off=float("-inf"), device=target_device + ), + position_ids=positions.data, + ) + assert torch.all(classes == classes) # for nans + + print(input_tensors[0]) + print(self.relprop()[0]) + + return classes + + def relprop(self, cam=None, **kwargs): + return self.bert.relprop(cam, **kwargs) + + +if __name__ == "__main__": + import os + + from transformers import BertTokenizer + + class Config: + def __init__( + self, + hidden_size, + num_attention_heads, + attention_probs_dropout_prob, + num_labels, + hidden_dropout_prob, + ): + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.attention_probs_dropout_prob = attention_probs_dropout_prob + self.num_labels = num_labels + self.hidden_dropout_prob = hidden_dropout_prob + + tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") + x = tokenizer.encode_plus( + "In this movie the acting is great. The movie is perfect! [sep]", + add_special_tokens=True, + max_length=512, + return_token_type_ids=False, + return_attention_mask=True, + pad_to_max_length=True, + return_tensors="pt", + truncation=True, + ) + + print(x["input_ids"]) + + model = BertForSequenceClassification.from_pretrained( + "bert-base-uncased", num_labels=2 + ) + model_save_file = os.path.join( + "./BERT_explainability/output_bert/movies/classifier/", "classifier.pt" + ) + model.load_state_dict(torch.load(model_save_file)) + + # x = torch.randint(100, (2, 20)) + # x = torch.tensor([[101, 2054, 2003, 1996, 15792, 1997, 2023, 3319, 1029, 102, + # 101, 4079, 102, 101, 6732, 102, 101, 2643, 102, 101, + # 2038, 102, 101, 1037, 102, 101, 2933, 102, 101, 2005, + # 102, 101, 2032, 102, 101, 1010, 102, 101, 1037, 102, + # 101, 3800, 102, 101, 2005, 102, 101, 2010, 102, 101, + # 2166, 102, 101, 1010, 102, 101, 1998, 102, 101, 2010, + # 102, 101, 4650, 102, 101, 1010, 102, 101, 2002, 102, + # 101, 2074, 102, 101, 2515, 102, 101, 1050, 102, 101, + # 1005, 102, 101, 1056, 102, 101, 2113, 102, 101, 2054, + # 102, 101, 1012, 102]]) + # x.requires_grad_() + + model.eval() + + y = model(x["input_ids"], x["attention_mask"]) + print(y) + + cam, _ = model.relprop() + + # print(cam.shape) + + cam = cam.sum(-1) + # print(cam) diff --git a/Transformer-Explainability/BERT_explainability/modules/BERT/ExplanationGenerator.py b/Transformer-Explainability/BERT_explainability/modules/BERT/ExplanationGenerator.py new file mode 100644 index 0000000000000000000000000000000000000000..6b9089ca84ddc5e33ed79936b17b33a3ff5af6cc --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/BERT/ExplanationGenerator.py @@ -0,0 +1,165 @@ +import argparse +import glob + +import numpy as np +import torch + + +# compute rollout between attention layers +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration- code adapted from https://github.com/samiraabnar/attention_flow + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + matrices_aug = [ + all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + for i in range(len(all_layer_matrices)) + ] + joint_attention = matrices_aug[start_layer] + for i in range(start_layer + 1, len(matrices_aug)): + joint_attention = matrices_aug[i].bmm(joint_attention) + return joint_attention + + +class Generator: + def __init__(self, model): + self.model = model + self.model.eval() + + def forward(self, input_ids, attention_mask): + return self.model(input_ids, attention_mask) + + def generate_LRP(self, input_ids, attention_mask, index=None, start_layer=11): + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + kwargs = {"alpha": 1} + + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs) + + cams = [] + blocks = self.model.bert.encoder.layer + for blk in blocks: + grad = blk.attention.self.get_attn_gradients() + cam = blk.attention.self.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cams.append(cam.unsqueeze(0)) + rollout = compute_rollout_attention(cams, start_layer=start_layer) + rollout[:, 0, 0] = rollout[:, 0].min() + return rollout[:, 0] + + def generate_LRP_last_layer(self, input_ids, attention_mask, index=None): + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + kwargs = {"alpha": 1} + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs) + + cam = self.model.bert.encoder.layer[-1].attention.self.get_attn_cam()[0] + cam = cam.clamp(min=0).mean(dim=0).unsqueeze(0) + cam[:, 0, 0] = 0 + return cam[:, 0] + + def generate_full_lrp(self, input_ids, attention_mask, index=None): + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + kwargs = {"alpha": 1} + + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + cam = self.model.relprop( + torch.tensor(one_hot_vector).to(input_ids.device), **kwargs + ) + cam = cam.sum(dim=2) + cam[:, 0] = 0 + return cam + + def generate_attn_last_layer(self, input_ids, attention_mask, index=None): + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + cam = self.model.bert.encoder.layer[-1].attention.self.get_attn()[0] + cam = cam.mean(dim=0).unsqueeze(0) + cam[:, 0, 0] = 0 + return cam[:, 0] + + def generate_rollout(self, input_ids, attention_mask, start_layer=0, index=None): + self.model.zero_grad() + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + blocks = self.model.bert.encoder.layer + all_layer_attentions = [] + for blk in blocks: + attn_heads = blk.attention.self.get_attn() + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + all_layer_attentions.append(avg_heads) + rollout = compute_rollout_attention( + all_layer_attentions, start_layer=start_layer + ) + rollout[:, 0, 0] = 0 + return rollout[:, 0] + + def generate_attn_gradcam(self, input_ids, attention_mask, index=None): + output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0] + kwargs = {"alpha": 1} + + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs) + + cam = self.model.bert.encoder.layer[-1].attention.self.get_attn() + grad = self.model.bert.encoder.layer[-1].attention.self.get_attn_gradients() + + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + grad = grad.mean(dim=[1, 2], keepdim=True) + cam = (cam * grad).mean(0).clamp(min=0).unsqueeze(0) + cam = (cam - cam.min()) / (cam.max() - cam.min()) + cam[:, 0, 0] = 0 + return cam[:, 0] diff --git a/Transformer-Explainability/BERT_explainability/modules/__init__.py b/Transformer-Explainability/BERT_explainability/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/BERT_explainability/modules/layers_lrp.py b/Transformer-Explainability/BERT_explainability/modules/layers_lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..ed85f016b5689f7880331706ab89123bf02fdd98 --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/layers_lrp.py @@ -0,0 +1,352 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = [ + "forward_hook", + "Clone", + "Add", + "Cat", + "ReLU", + "GELU", + "Dropout", + "BatchNorm2d", + "Linear", + "MaxPool2d", + "AdaptiveAvgPool2d", + "AvgPool2d", + "Conv2d", + "Sequential", + "safe_divide", + "einsum", + "Softmax", + "IndexSelect", + "LayerNorm", + "AddEye", + "Tanh", + "MatMul", + "Mul", +] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + + +class ReLU(nn.ReLU, RelProp): + pass + + +class Tanh(nn.Tanh, RelProp): + pass + + +class GELU(nn.GELU, RelProp): + pass + + +class Softmax(nn.Softmax, RelProp): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class Dropout(nn.Dropout, RelProp): + pass + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class MatMul(RelPropSimple): + def forward(self, inputs): + return torch.matmul(*inputs) + + +class Mul(RelPropSimple): + def forward(self, inputs): + return torch.mul(*inputs) + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__("dim", dim) + self.__setattr__("indices", indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__("num", num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__("dim", dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + ( + self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + + self.eps + ).pow(0.5) + ) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * torch.autograd.grad(Z1, x1, S1)[0] + C2 = x2 * torch.autograd.grad(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] + - 2 * self.padding[0] + + self.kernel_size[0] + ) + + return F.conv_transpose2d( + DY, + weight, + stride=self.stride, + padding=self.padding, + output_padding=output_padding, + ) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = ( + self.X * 0 + + torch.min( + torch.min( + torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + H = ( + self.X * 0 + + torch.max( + torch.max( + torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + Za = ( + torch.conv2d( + X, self.weight, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + L, pw, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + H, nw, bias=None, stride=self.stride, padding=self.padding + ) + + 1e-9 + ) + + S = R / Za + C = ( + X * self.gradprop2(S, self.weight) + - L * self.gradprop2(S, pw) + - H * self.gradprop2(S, nw) + ) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d( + x1, w1, bias=None, stride=self.stride, padding=self.padding + ) + Z2 = F.conv2d( + x2, w2, bias=None, stride=self.stride, padding=self.padding + ) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R diff --git a/Transformer-Explainability/BERT_explainability/modules/layers_ours.py b/Transformer-Explainability/BERT_explainability/modules/layers_ours.py new file mode 100644 index 0000000000000000000000000000000000000000..9fe0a1af2d4cfa1620e5f140325432bcb7b73508 --- /dev/null +++ b/Transformer-Explainability/BERT_explainability/modules/layers_ours.py @@ -0,0 +1,373 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = [ + "forward_hook", + "Clone", + "Add", + "Cat", + "ReLU", + "GELU", + "Dropout", + "BatchNorm2d", + "Linear", + "MaxPool2d", + "AdaptiveAvgPool2d", + "AvgPool2d", + "Conv2d", + "Sequential", + "safe_divide", + "einsum", + "Softmax", + "IndexSelect", + "LayerNorm", + "AddEye", + "Tanh", + "MatMul", + "Mul", +] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + + +class ReLU(nn.ReLU, RelProp): + pass + + +class GELU(nn.GELU, RelProp): + pass + + +class Softmax(nn.Softmax, RelProp): + pass + + +class Mul(RelPropSimple): + def forward(self, inputs): + return torch.mul(*inputs) + + +class Tanh(nn.Tanh, RelProp): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class Dropout(nn.Dropout, RelProp): + pass + + +class MatMul(RelPropSimple): + def forward(self, inputs): + return torch.matmul(*inputs) + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + a = self.X[0] * C[0] + b = self.X[1] * C[1] + + a_sum = a.sum() + b_sum = b.sum() + + a_fact = safe_divide(a_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + b_fact = safe_divide(b_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + + a = a * safe_divide(a_fact, a.sum()) + b = b * safe_divide(b_fact, b.sum()) + + outputs = [a, b] + + return outputs + + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__("dim", dim) + self.__setattr__("indices", indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__("num", num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__("dim", dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + ( + self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + + self.eps + ).pow(0.5) + ) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1 + Z2) + S2 = safe_divide(R, Z1 + Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] + - 2 * self.padding[0] + + self.kernel_size[0] + ) + + return F.conv_transpose2d( + DY, + weight, + stride=self.stride, + padding=self.padding, + output_padding=output_padding, + ) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = ( + self.X * 0 + + torch.min( + torch.min( + torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + H = ( + self.X * 0 + + torch.max( + torch.max( + torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + Za = ( + torch.conv2d( + X, self.weight, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + L, pw, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + H, nw, bias=None, stride=self.stride, padding=self.padding + ) + + 1e-9 + ) + + S = R / Za + C = ( + X * self.gradprop2(S, self.weight) + - L * self.gradprop2(S, pw) + - H * self.gradprop2(S, nw) + ) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d( + x1, w1, bias=None, stride=self.stride, padding=self.padding + ) + Z2 = F.conv2d( + x2, w2, bias=None, stride=self.stride, padding=self.padding + ) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R diff --git a/Transformer-Explainability/BERT_params/boolq.json b/Transformer-Explainability/BERT_params/boolq.json new file mode 100644 index 0000000000000000000000000000000000000000..c9317b6a655397493353996cbab3f7aa381ff30c --- /dev/null +++ b/Transformer-Explainability/BERT_params/boolq.json @@ -0,0 +1,26 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.05 + }, + "evidence_identifier": { + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "False", "True" ], + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "everything" + } +} diff --git a/Transformer-Explainability/BERT_params/boolq_baas.json b/Transformer-Explainability/BERT_params/boolq_baas.json new file mode 100644 index 0000000000000000000000000000000000000000..9ea4928bd542e63de31b82d61dfa99d6eec1e8c5 --- /dev/null +++ b/Transformer-Explainability/BERT_params/boolq_baas.json @@ -0,0 +1,26 @@ +{ + "start_server": 0, + "bert_dir": "model_components/uncased_L-12_H-768_A-12/", + "max_length": 512, + "pooling_strategy": "CLS_TOKEN", + "evidence_identifier": { + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "False", "True" ], + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "everything" + } +} + + diff --git a/Transformer-Explainability/BERT_params/boolq_bert.json b/Transformer-Explainability/BERT_params/boolq_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..e454fb17ae262db22f77faa350f2bae33e07bdd1 --- /dev/null +++ b/Transformer-Explainability/BERT_params/boolq_bert.json @@ -0,0 +1,32 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 10, + "epochs": 10, + "patience": 10, + "warmup_steps": 50, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "random", + "sampling_ratio": 1, + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ + "False", + "True" + ], + "batch_size": 10, + "warmup_steps": 50, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/boolq_soft.json b/Transformer-Explainability/BERT_params/boolq_soft.json new file mode 100644 index 0000000000000000000000000000000000000000..721697d0b51f6b19432013ffbbca0054a067e9e2 --- /dev/null +++ b/Transformer-Explainability/BERT_params/boolq_soft.json @@ -0,0 +1,21 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.2 + }, + "classifier": { + "classes": [ "False", "True" ], + "has_query": 1, + "hidden_size": 32, + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 16, + "epochs": 50, + "attention_epochs": 50, + "patience": 10, + "lr": 1e-3, + "dropout": 0.2, + "k_fraction": 0.07, + "threshold": 0.1 + } +} diff --git a/Transformer-Explainability/BERT_params/cose_bert.json b/Transformer-Explainability/BERT_params/cose_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..f32cadd89e46eec94e8e049ca9a911ef4a58ffc4 --- /dev/null +++ b/Transformer-Explainability/BERT_params/cose_bert.json @@ -0,0 +1,30 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 0, + "use_evidence_token_identifier": 1, + "evidence_token_identifier": { + "batch_size": 32, + "epochs": 10, + "patience": 10, + "warmup_steps": 10, + "lr": 1e-05, + "max_grad_norm": 0.5, + "sampling_method": "everything", + "use_half_precision": 0, + "cose_data_hack": 1 + }, + "evidence_classifier": { + "classes": [ "false", "true"], + "batch_size": 32, + "warmup_steps": 10, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 0.5, + "sampling_method": "everything", + "use_half_precision": 0, + "cose_data_hack": 1 + } +} diff --git a/Transformer-Explainability/BERT_params/cose_multiclass.json b/Transformer-Explainability/BERT_params/cose_multiclass.json new file mode 100644 index 0000000000000000000000000000000000000000..199f1ae7b976439a14a99c3695c0680f225d8afa --- /dev/null +++ b/Transformer-Explainability/BERT_params/cose_multiclass.json @@ -0,0 +1,35 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 32, + "epochs": 10, + "patience": 10, + "warmup_steps": 50, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "random", + "sampling_ratio": 1, + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ + "A", + "B", + "C", + "D", + "E" + ], + "batch_size": 10, + "warmup_steps": 50, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/esnli_bert.json b/Transformer-Explainability/BERT_params/esnli_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..7feb838bda1e905de01675733b9c73667f1e6534 --- /dev/null +++ b/Transformer-Explainability/BERT_params/esnli_bert.json @@ -0,0 +1,28 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 0, + "use_evidence_token_identifier": 1, + "evidence_token_identifier": { + "batch_size": 32, + "epochs": 10, + "patience": 10, + "warmup_steps": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ "contradiction", "neutral", "entailment" ], + "batch_size": 32, + "warmup_steps": 10, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/evidence_inference.json b/Transformer-Explainability/BERT_params/evidence_inference.json new file mode 100644 index 0000000000000000000000000000000000000000..910dcff76c26811da48aefddf7b58bfb8d90fbfc --- /dev/null +++ b/Transformer-Explainability/BERT_params/evidence_inference.json @@ -0,0 +1,26 @@ +{ + "embeddings": { + "embedding_file": "model_components/PubMed-w2v.bin", + "dropout": 0.05 + }, + "evidence_identifier": { + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "significantly decreased", "no significant difference", "significantly increased" ], + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "everything" + } +} diff --git a/Transformer-Explainability/BERT_params/evidence_inference_bert.json b/Transformer-Explainability/BERT_params/evidence_inference_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..b595a64f674d2e1d415516cca3bbda2de24afb4c --- /dev/null +++ b/Transformer-Explainability/BERT_params/evidence_inference_bert.json @@ -0,0 +1,33 @@ +{ + "max_length": 512, + "bert_vocab": "allenai/scibert_scivocab_uncased", + "bert_dir": "allenai/scibert_scivocab_uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 10, + "epochs": 10, + "patience": 10, + "warmup_steps": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "random", + "use_half_precision": 0, + "sampling_ratio": 1 + }, + "evidence_classifier": { + "classes": [ + "significantly decreased", + "no significant difference", + "significantly increased" + ], + "batch_size": 10, + "warmup_steps": 10, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/evidence_inference_soft.json b/Transformer-Explainability/BERT_params/evidence_inference_soft.json new file mode 100644 index 0000000000000000000000000000000000000000..e416f0b336a927dc9815823e66756249c910f3df --- /dev/null +++ b/Transformer-Explainability/BERT_params/evidence_inference_soft.json @@ -0,0 +1,22 @@ +{ + "embeddings": { + "embedding_file": "model_components/PubMed-w2v.bin", + "dropout": 0.2 + }, + "classifier": { + "classes": [ "significantly decreased", "no significant difference", "significantly increased" ], + "use_token_selection": 1, + "has_query": 1, + "hidden_size": 32, + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 16, + "epochs": 50, + "attention_epochs": 0, + "patience": 10, + "lr": 1e-3, + "dropout": 0.2, + "k_fraction": 0.013, + "threshold": 0.1 + } +} diff --git a/Transformer-Explainability/BERT_params/fever.json b/Transformer-Explainability/BERT_params/fever.json new file mode 100644 index 0000000000000000000000000000000000000000..da96f140a9d534b33366d6cc529b6f3169cd4c6c --- /dev/null +++ b/Transformer-Explainability/BERT_params/fever.json @@ -0,0 +1,26 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.05 + }, + "evidence_identifier": { + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "SUPPORTS", "REFUTES" ], + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-5, + "sampling_method": "everything" + } +} diff --git a/Transformer-Explainability/BERT_params/fever_baas.json b/Transformer-Explainability/BERT_params/fever_baas.json new file mode 100644 index 0000000000000000000000000000000000000000..10c4c9fabdf2d7334042421e62f16b3e339cf005 --- /dev/null +++ b/Transformer-Explainability/BERT_params/fever_baas.json @@ -0,0 +1,25 @@ +{ + "start_server": 0, + "bert_dir": "model_components/uncased_L-12_H-768_A-12/", + "max_length": 512, + "pooling_strategy": "CLS_TOKEN", + "evidence_identifier": { + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "SUPPORTS", "REFUTES" ], + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "everything" + } +} + diff --git a/Transformer-Explainability/BERT_params/fever_bert.json b/Transformer-Explainability/BERT_params/fever_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..c7c7a86350d8877f4b42031a416c43a88b78553c --- /dev/null +++ b/Transformer-Explainability/BERT_params/fever_bert.json @@ -0,0 +1,32 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 16, + "epochs": 10, + "patience": 10, + "warmup_steps": 10, + "lr": 1e-05, + "max_grad_norm": 1.0, + "sampling_method": "random", + "sampling_ratio": 1.0, + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ + "SUPPORTS", + "REFUTES" + ], + "batch_size": 10, + "warmup_steps": 10, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1.0, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/fever_soft.json b/Transformer-Explainability/BERT_params/fever_soft.json new file mode 100644 index 0000000000000000000000000000000000000000..acd23efc86eddd91f297c99f3f76572daea0b34f --- /dev/null +++ b/Transformer-Explainability/BERT_params/fever_soft.json @@ -0,0 +1,21 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.2 + }, + "classifier": { + "classes": [ "SUPPORTS", "REFUTES" ], + "has_query": 1, + "hidden_size": 32, + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 128, + "epochs": 50, + "attention_epochs": 50, + "patience": 10, + "lr": 1e-3, + "dropout": 0.2, + "k_fraction": 0.07, + "threshold": 0.1 + } +} diff --git a/Transformer-Explainability/BERT_params/movies.json b/Transformer-Explainability/BERT_params/movies.json new file mode 100644 index 0000000000000000000000000000000000000000..546f21c5fbe1fabc5d66ef5bd2a9f0f5a02dbc9d --- /dev/null +++ b/Transformer-Explainability/BERT_params/movies.json @@ -0,0 +1,26 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.05 + }, + "evidence_identifier": { + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-4, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "NEG", "POS" ], + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "everything" + } +} diff --git a/Transformer-Explainability/BERT_params/movies_baas.json b/Transformer-Explainability/BERT_params/movies_baas.json new file mode 100644 index 0000000000000000000000000000000000000000..846b0207637a2519e6315b606281c392dfba6135 --- /dev/null +++ b/Transformer-Explainability/BERT_params/movies_baas.json @@ -0,0 +1,26 @@ +{ + "start_server": 0, + "bert_dir": "model_components/uncased_L-12_H-768_A-12/", + "max_length": 512, + "pooling_strategy": "CLS_TOKEN", + "evidence_identifier": { + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "NEG", "POS" ], + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "everything" + } +} + + diff --git a/Transformer-Explainability/BERT_params/movies_bert.json b/Transformer-Explainability/BERT_params/movies_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..7535a747e636a29640cb5e10a7ce2a28b724c4e3 --- /dev/null +++ b/Transformer-Explainability/BERT_params/movies_bert.json @@ -0,0 +1,32 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 16, + "epochs": 10, + "patience": 10, + "warmup_steps": 50, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "random", + "sampling_ratio": 1, + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ + "NEG", + "POS" + ], + "batch_size": 10, + "warmup_steps": 50, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/movies_soft.json b/Transformer-Explainability/BERT_params/movies_soft.json new file mode 100644 index 0000000000000000000000000000000000000000..99d54dad58bf17149ac4930b2e03c9f79f24b947 --- /dev/null +++ b/Transformer-Explainability/BERT_params/movies_soft.json @@ -0,0 +1,21 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.2 + }, + "classifier": { + "classes": [ "NEG", "POS" ], + "has_query": 0, + "hidden_size": 32, + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 16, + "epochs": 50, + "attention_epochs": 50, + "patience": 10, + "lr": 1e-3, + "dropout": 0.2, + "k_fraction": 0.07, + "threshold": 0.1 + } +} diff --git a/Transformer-Explainability/BERT_params/multirc.json b/Transformer-Explainability/BERT_params/multirc.json new file mode 100644 index 0000000000000000000000000000000000000000..dc3cb2d10eb961de882408609f3d6d3946c95c43 --- /dev/null +++ b/Transformer-Explainability/BERT_params/multirc.json @@ -0,0 +1,26 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.05 + }, + "evidence_identifier": { + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "False", "True" ], + "mlp_size": 128, + "dropout": 0.05, + "batch_size": 768, + "epochs": 50, + "patience": 10, + "lr": 1e-3, + "sampling_method": "everything" + } +} diff --git a/Transformer-Explainability/BERT_params/multirc_baas.json b/Transformer-Explainability/BERT_params/multirc_baas.json new file mode 100644 index 0000000000000000000000000000000000000000..9ea4928bd542e63de31b82d61dfa99d6eec1e8c5 --- /dev/null +++ b/Transformer-Explainability/BERT_params/multirc_baas.json @@ -0,0 +1,26 @@ +{ + "start_server": 0, + "bert_dir": "model_components/uncased_L-12_H-768_A-12/", + "max_length": 512, + "pooling_strategy": "CLS_TOKEN", + "evidence_identifier": { + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "random", + "sampling_ratio": 1.0 + }, + "evidence_classifier": { + "classes": [ "False", "True" ], + "batch_size": 64, + "epochs": 3, + "patience": 10, + "lr": 1e-3, + "max_grad_norm": 1.0, + "sampling_method": "everything" + } +} + + diff --git a/Transformer-Explainability/BERT_params/multirc_bert.json b/Transformer-Explainability/BERT_params/multirc_bert.json new file mode 100644 index 0000000000000000000000000000000000000000..1ab31b5722dddcf06c9f38a79e1071358afd386b --- /dev/null +++ b/Transformer-Explainability/BERT_params/multirc_bert.json @@ -0,0 +1,32 @@ +{ + "max_length": 512, + "bert_vocab": "bert-base-uncased", + "bert_dir": "bert-base-uncased", + "use_evidence_sentence_identifier": 1, + "use_evidence_token_identifier": 0, + "evidence_identifier": { + "batch_size": 32, + "epochs": 10, + "patience": 10, + "warmup_steps": 50, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "random", + "sampling_ratio": 1, + "use_half_precision": 0 + }, + "evidence_classifier": { + "classes": [ + "False", + "True" + ], + "batch_size": 32, + "warmup_steps": 50, + "epochs": 10, + "patience": 10, + "lr": 1e-05, + "max_grad_norm": 1, + "sampling_method": "everything", + "use_half_precision": 0 + } +} diff --git a/Transformer-Explainability/BERT_params/multirc_soft.json b/Transformer-Explainability/BERT_params/multirc_soft.json new file mode 100644 index 0000000000000000000000000000000000000000..721697d0b51f6b19432013ffbbca0054a067e9e2 --- /dev/null +++ b/Transformer-Explainability/BERT_params/multirc_soft.json @@ -0,0 +1,21 @@ +{ + "embeddings": { + "embedding_file": "model_components/glove.6B.200d.txt", + "dropout": 0.2 + }, + "classifier": { + "classes": [ "False", "True" ], + "has_query": 1, + "hidden_size": 32, + "mlp_size": 128, + "dropout": 0.2, + "batch_size": 16, + "epochs": 50, + "attention_epochs": 50, + "patience": 10, + "lr": 1e-3, + "dropout": 0.2, + "k_fraction": 0.07, + "threshold": 0.1 + } +} diff --git a/Transformer-Explainability/BERT_rationale_benchmark/__init__.py b/Transformer-Explainability/BERT_rationale_benchmark/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/BERT_rationale_benchmark/metrics.py b/Transformer-Explainability/BERT_rationale_benchmark/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..c71a000de73a5478fe83c064b02beecb74d4af3c --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/metrics.py @@ -0,0 +1,1007 @@ +import argparse +import json +import logging +import os +import pprint +from collections import Counter, defaultdict, namedtuple +from dataclasses import dataclass +from itertools import chain +from typing import Any, Callable, Dict, List, Set, Tuple + +import numpy as np +import torch +from BERT_rationale_benchmark.utils import (Annotation, Evidence, + annotations_from_jsonl, + load_documents, + load_flattened_documents, + load_jsonl) +from scipy.stats import entropy +from sklearn.metrics import (accuracy_score, auc, average_precision_score, + classification_report, precision_recall_curve, + roc_auc_score) + +logging.basicConfig( + level=logging.DEBUG, format="%(relativeCreated)6d %(threadName)s %(message)s" +) + + +# start_token is inclusive, end_token is exclusive +@dataclass(eq=True, frozen=True) +class Rationale: + ann_id: str + docid: str + start_token: int + end_token: int + + def to_token_level(self) -> List["Rationale"]: + ret = [] + for t in range(self.start_token, self.end_token): + ret.append(Rationale(self.ann_id, self.docid, t, t + 1)) + return ret + + @classmethod + def from_annotation(cls, ann: Annotation) -> List["Rationale"]: + ret = [] + for ev_group in ann.evidences: + for ev in ev_group: + ret.append( + Rationale(ann.annotation_id, ev.docid, ev.start_token, ev.end_token) + ) + return ret + + @classmethod + def from_instance(cls, inst: dict) -> List["Rationale"]: + ret = [] + for rat in inst["rationales"]: + for pred in rat.get("hard_rationale_predictions", []): + ret.append( + Rationale( + inst["annotation_id"], + rat["docid"], + pred["start_token"], + pred["end_token"], + ) + ) + return ret + + +@dataclass(eq=True, frozen=True) +class PositionScoredDocument: + ann_id: str + docid: str + scores: Tuple[float] + truths: Tuple[bool] + + @classmethod + def from_results( + cls, + instances: List[dict], + annotations: List[Annotation], + docs: Dict[str, List[Any]], + use_tokens: bool = True, + ) -> List["PositionScoredDocument"]: + """Creates a paired list of annotation ids/docids/predictions/truth values""" + key_to_annotation = dict() + for ann in annotations: + for ev in chain.from_iterable(ann.evidences): + key = (ann.annotation_id, ev.docid) + if key not in key_to_annotation: + key_to_annotation[key] = [False for _ in docs[ev.docid]] + if use_tokens: + start, end = ev.start_token, ev.end_token + else: + start, end = ev.start_sentence, ev.end_sentence + for t in range(start, end): + key_to_annotation[key][t] = True + ret = [] + if use_tokens: + field = "soft_rationale_predictions" + else: + field = "soft_sentence_predictions" + for inst in instances: + for rat in inst["rationales"]: + docid = rat["docid"] + scores = rat[field] + key = (inst["annotation_id"], docid) + assert len(scores) == len(docs[docid]) + if key in key_to_annotation: + assert len(scores) == len(key_to_annotation[key]) + else: + # In case model makes a prediction on docuemnt(s) for which ground truth evidence is not present + key_to_annotation[key] = [False for _ in docs[docid]] + ret.append( + PositionScoredDocument( + inst["annotation_id"], + docid, + tuple(scores), + tuple(key_to_annotation[key]), + ) + ) + return ret + + +def _f1(_p, _r): + if _p == 0 or _r == 0: + return 0 + return 2 * _p * _r / (_p + _r) + + +def _keyed_rationale_from_list( + rats: List[Rationale], +) -> Dict[Tuple[str, str], Rationale]: + ret = defaultdict(set) + for r in rats: + ret[(r.ann_id, r.docid)].add(r) + return ret + + +def partial_match_score( + truth: List[Rationale], pred: List[Rationale], thresholds: List[float] +) -> List[Dict[str, Any]]: + """Computes a partial match F1 + + Computes an instance-level (annotation) micro- and macro-averaged F1 score. + True Positives are computed by using intersection-over-union and + thresholding the resulting intersection-over-union fraction. + + Micro-average results are computed by ignoring instance level distinctions + in the TP calculation (and recall, and precision, and finally the F1 of + those numbers). Macro-average results are computed first by measuring + instance (annotation + document) precisions and recalls, averaging those, + and finally computing an F1 of the resulting average. + """ + + ann_to_rat = _keyed_rationale_from_list(truth) + pred_to_rat = _keyed_rationale_from_list(pred) + + num_classifications = {k: len(v) for k, v in pred_to_rat.items()} + num_truth = {k: len(v) for k, v in ann_to_rat.items()} + ious = defaultdict(dict) + for k in set(ann_to_rat.keys()) | set(pred_to_rat.keys()): + for p in pred_to_rat.get(k, []): + best_iou = 0.0 + for t in ann_to_rat.get(k, []): + num = len( + set(range(p.start_token, p.end_token)) + & set(range(t.start_token, t.end_token)) + ) + denom = len( + set(range(p.start_token, p.end_token)) + | set(range(t.start_token, t.end_token)) + ) + iou = 0 if denom == 0 else num / denom + if iou > best_iou: + best_iou = iou + ious[k][p] = best_iou + scores = [] + for threshold in thresholds: + threshold_tps = dict() + for k, vs in ious.items(): + threshold_tps[k] = sum(int(x >= threshold) for x in vs.values()) + micro_r = ( + sum(threshold_tps.values()) / sum(num_truth.values()) + if sum(num_truth.values()) > 0 + else 0 + ) + micro_p = ( + sum(threshold_tps.values()) / sum(num_classifications.values()) + if sum(num_classifications.values()) > 0 + else 0 + ) + micro_f1 = _f1(micro_r, micro_p) + macro_rs = list( + threshold_tps.get(k, 0.0) / n if n > 0 else 0 for k, n in num_truth.items() + ) + macro_ps = list( + threshold_tps.get(k, 0.0) / n if n > 0 else 0 + for k, n in num_classifications.items() + ) + macro_r = sum(macro_rs) / len(macro_rs) if len(macro_rs) > 0 else 0 + macro_p = sum(macro_ps) / len(macro_ps) if len(macro_ps) > 0 else 0 + macro_f1 = _f1(macro_r, macro_p) + scores.append( + { + "threshold": threshold, + "micro": {"p": micro_p, "r": micro_r, "f1": micro_f1}, + "macro": {"p": macro_p, "r": macro_r, "f1": macro_f1}, + } + ) + return scores + + +def score_hard_rationale_predictions( + truth: List[Rationale], pred: List[Rationale] +) -> Dict[str, Dict[str, float]]: + """Computes instance (annotation)-level micro/macro averaged F1s""" + scores = dict() + truth = set(truth) + pred = set(pred) + micro_prec = len(truth & pred) / len(pred) + micro_rec = len(truth & pred) / len(truth) + micro_f1 = _f1(micro_prec, micro_rec) + scores["instance_micro"] = { + "p": micro_prec, + "r": micro_rec, + "f1": micro_f1, + } + + ann_to_rat = _keyed_rationale_from_list(truth) + pred_to_rat = _keyed_rationale_from_list(pred) + instances_to_scores = dict() + for k in set(ann_to_rat.keys()) | (pred_to_rat.keys()): + if len(pred_to_rat.get(k, set())) > 0: + instance_prec = len( + ann_to_rat.get(k, set()) & pred_to_rat.get(k, set()) + ) / len(pred_to_rat[k]) + else: + instance_prec = 0 + if len(ann_to_rat.get(k, set())) > 0: + instance_rec = len( + ann_to_rat.get(k, set()) & pred_to_rat.get(k, set()) + ) / len(ann_to_rat[k]) + else: + instance_rec = 0 + instance_f1 = _f1(instance_prec, instance_rec) + instances_to_scores[k] = { + "p": instance_prec, + "r": instance_rec, + "f1": instance_f1, + } + # these are calculated as sklearn would + macro_prec = sum(instance["p"] for instance in instances_to_scores.values()) / len( + instances_to_scores + ) + macro_rec = sum(instance["r"] for instance in instances_to_scores.values()) / len( + instances_to_scores + ) + macro_f1 = sum(instance["f1"] for instance in instances_to_scores.values()) / len( + instances_to_scores + ) + + f1_scores = [instance["f1"] for instance in instances_to_scores.values()] + print(macro_f1, np.argsort(f1_scores)[::-1]) + + scores["instance_macro"] = { + "p": macro_prec, + "r": macro_rec, + "f1": macro_f1, + } + return scores + + +def _auprc(truth: Dict[Any, List[bool]], preds: Dict[Any, List[float]]) -> float: + if len(preds) == 0: + return 0.0 + assert len(truth.keys() and preds.keys()) == len(truth.keys()) + aucs = [] + for k, true in truth.items(): + pred = preds[k] + true = [int(t) for t in true] + precision, recall, _ = precision_recall_curve(true, pred) + aucs.append(auc(recall, precision)) + return np.average(aucs) + + +def _score_aggregator( + truth: Dict[Any, List[bool]], + preds: Dict[Any, List[float]], + score_function: Callable[[List[float], List[float]], float], + discard_single_class_answers: bool, +) -> float: + if len(preds) == 0: + return 0.0 + assert len(truth.keys() and preds.keys()) == len(truth.keys()) + scores = [] + for k, true in truth.items(): + pred = preds[k] + if (all(true) or all(not x for x in true)) and discard_single_class_answers: + continue + true = [int(t) for t in true] + scores.append(score_function(true, pred)) + return np.average(scores) + + +def score_soft_tokens(paired_scores: List[PositionScoredDocument]) -> Dict[str, float]: + truth = {(ps.ann_id, ps.docid): ps.truths for ps in paired_scores} + pred = {(ps.ann_id, ps.docid): ps.scores for ps in paired_scores} + auprc_score = _auprc(truth, pred) + ap = _score_aggregator(truth, pred, average_precision_score, True) + roc_auc = _score_aggregator(truth, pred, roc_auc_score, True) + + return { + "auprc": auprc_score, + "average_precision": ap, + "roc_auc_score": roc_auc, + } + + +def _instances_aopc( + instances: List[dict], thresholds: List[float], key: str +) -> Tuple[float, List[float]]: + dataset_scores = [] + for inst in instances: + kls = inst["classification"] + beta_0 = inst["classification_scores"][kls] + instance_scores = [] + for score in filter( + lambda x: x["threshold"] in thresholds, + sorted(inst["thresholded_scores"], key=lambda x: x["threshold"]), + ): + beta_k = score[key][kls] + delta = beta_0 - beta_k + instance_scores.append(delta) + assert len(instance_scores) == len(thresholds) + dataset_scores.append(instance_scores) + dataset_scores = np.array(dataset_scores) + # a careful reading of Samek, et al. "Evaluating the Visualization of What a Deep Neural Network Has Learned" + # and some algebra will show the reader that we can average in any of several ways and get the same result: + # over a flattened array, within an instance and then between instances, or over instances (by position) an + # then across them. + final_score = np.average(dataset_scores) + position_scores = np.average(dataset_scores, axis=0).tolist() + + return final_score, position_scores + + +def compute_aopc_scores(instances: List[dict], aopc_thresholds: List[float]): + if aopc_thresholds is None: + aopc_thresholds = sorted( + set( + chain.from_iterable( + [x["threshold"] for x in y["thresholded_scores"]] for y in instances + ) + ) + ) + aopc_comprehensiveness_score, aopc_comprehensiveness_points = _instances_aopc( + instances, aopc_thresholds, "comprehensiveness_classification_scores" + ) + aopc_sufficiency_score, aopc_sufficiency_points = _instances_aopc( + instances, aopc_thresholds, "sufficiency_classification_scores" + ) + return ( + aopc_thresholds, + aopc_comprehensiveness_score, + aopc_comprehensiveness_points, + aopc_sufficiency_score, + aopc_sufficiency_points, + ) + + +def score_classifications( + instances: List[dict], + annotations: List[Annotation], + docs: Dict[str, List[str]], + aopc_thresholds: List[float], +) -> Dict[str, float]: + def compute_kl(cls_scores_, faith_scores_): + keys = list(cls_scores_.keys()) + cls_scores_ = [cls_scores_[k] for k in keys] + faith_scores_ = [faith_scores_[k] for k in keys] + return entropy(faith_scores_, cls_scores_) + + labels = list(set(x.classification for x in annotations)) + label_to_int = {l: i for i, l in enumerate(labels)} + key_to_instances = {inst["annotation_id"]: inst for inst in instances} + truth = [] + predicted = [] + for ann in annotations: + truth.append(label_to_int[ann.classification]) + inst = key_to_instances[ann.annotation_id] + predicted.append(label_to_int[inst["classification"]]) + classification_scores = classification_report( + truth, predicted, output_dict=True, target_names=labels, digits=3 + ) + accuracy = accuracy_score(truth, predicted) + if "comprehensiveness_classification_scores" in instances[0]: + comprehensiveness_scores = [ + x["classification_scores"][x["classification"]] + - x["comprehensiveness_classification_scores"][x["classification"]] + for x in instances + ] + comprehensiveness_score = np.average(comprehensiveness_scores) + else: + comprehensiveness_score = None + comprehensiveness_scores = None + + if "sufficiency_classification_scores" in instances[0]: + sufficiency_scores = [ + x["classification_scores"][x["classification"]] + - x["sufficiency_classification_scores"][x["classification"]] + for x in instances + ] + sufficiency_score = np.average(sufficiency_scores) + else: + sufficiency_score = None + sufficiency_scores = None + + if "comprehensiveness_classification_scores" in instances[0]: + comprehensiveness_entropies = [ + entropy(list(x["classification_scores"].values())) + - entropy(list(x["comprehensiveness_classification_scores"].values())) + for x in instances + ] + comprehensiveness_entropy = np.average(comprehensiveness_entropies) + comprehensiveness_kl = np.average( + list( + compute_kl( + x["classification_scores"], + x["comprehensiveness_classification_scores"], + ) + for x in instances + ) + ) + else: + comprehensiveness_entropies = None + comprehensiveness_kl = None + comprehensiveness_entropy = None + + if "sufficiency_classification_scores" in instances[0]: + sufficiency_entropies = [ + entropy(list(x["classification_scores"].values())) + - entropy(list(x["sufficiency_classification_scores"].values())) + for x in instances + ] + sufficiency_entropy = np.average(sufficiency_entropies) + sufficiency_kl = np.average( + list( + compute_kl( + x["classification_scores"], x["sufficiency_classification_scores"] + ) + for x in instances + ) + ) + else: + sufficiency_entropies = None + sufficiency_kl = None + sufficiency_entropy = None + + if "thresholded_scores" in instances[0]: + ( + aopc_thresholds, + aopc_comprehensiveness_score, + aopc_comprehensiveness_points, + aopc_sufficiency_score, + aopc_sufficiency_points, + ) = compute_aopc_scores(instances, aopc_thresholds) + else: + ( + aopc_thresholds, + aopc_comprehensiveness_score, + aopc_comprehensiveness_points, + aopc_sufficiency_score, + aopc_sufficiency_points, + ) = (None, None, None, None, None) + if "tokens_to_flip" in instances[0]: + token_percentages = [] + for ann in annotations: + # in practice, this is of size 1 for everything except e-snli + docids = set(ev.docid for ev in chain.from_iterable(ann.evidences)) + inst = key_to_instances[ann.annotation_id] + tokens = inst["tokens_to_flip"] + doc_lengths = sum(len(docs[d]) for d in docids) + token_percentages.append(tokens / doc_lengths) + token_percentages = np.average(token_percentages) + else: + token_percentages = None + + return { + "accuracy": accuracy, + "prf": classification_scores, + "comprehensiveness": comprehensiveness_score, + "sufficiency": sufficiency_score, + "comprehensiveness_entropy": comprehensiveness_entropy, + "comprehensiveness_kl": comprehensiveness_kl, + "sufficiency_entropy": sufficiency_entropy, + "sufficiency_kl": sufficiency_kl, + "aopc_thresholds": aopc_thresholds, + "comprehensiveness_aopc": aopc_comprehensiveness_score, + "comprehensiveness_aopc_points": aopc_comprehensiveness_points, + "sufficiency_aopc": aopc_sufficiency_score, + "sufficiency_aopc_points": aopc_sufficiency_points, + } + + +def verify_instance(instance: dict, docs: Dict[str, list], thresholds: Set[float]): + error = False + docids = [] + # verify the internal structure of these instances is correct: + # * hard predictions are present + # * start and end tokens are valid + # * soft rationale predictions, if present, must have the same document length + + for rat in instance["rationales"]: + docid = rat["docid"] + if docid not in docid: + error = True + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, docid={docid} could not be found as a preprocessed document! Gave up on additional processing.' + ) + continue + doc_length = len(docs[docid]) + for h1 in rat.get("hard_rationale_predictions", []): + # verify that each token is valid + # verify that no annotations overlap + for h2 in rat.get("hard_rationale_predictions", []): + if h1 == h2: + continue + if ( + len( + set(range(h1["start_token"], h1["end_token"])) + & set(range(h2["start_token"], h2["end_token"])) + ) + > 0 + ): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, docid={docid} {h1} and {h2} overlap!' + ) + error = True + if h1["start_token"] > doc_length: + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, docid={docid} received an impossible tokenspan: {h1} for a document of length {doc_length}' + ) + error = True + if h1["end_token"] > doc_length: + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, docid={docid} received an impossible tokenspan: {h1} for a document of length {doc_length}' + ) + error = True + # length check for soft rationale + # note that either flattened_documents or sentence-broken documents must be passed in depending on result + soft_rationale_predictions = rat.get("soft_rationale_predictions", []) + if ( + len(soft_rationale_predictions) > 0 + and len(soft_rationale_predictions) != doc_length + ): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, docid={docid} expected classifications for {doc_length} tokens but have them for {len(soft_rationale_predictions)} tokens instead!' + ) + error = True + + # count that one appears per-document + docids = Counter(docids) + for docid, count in docids.items(): + if count > 1: + error = True + logging.info( + 'Error! For instance annotation={instance["annotation_id"]}, docid={docid} appear {count} times, may only appear once!' + ) + + classification = instance.get("classification", "") + if not isinstance(classification, str): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, classification field {classification} is not a string!' + ) + error = True + classification_scores = instance.get("classification_scores", dict()) + if not isinstance(classification_scores, dict): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, classification_scores field {classification_scores} is not a dict!' + ) + error = True + comprehensiveness_classification_scores = instance.get( + "comprehensiveness_classification_scores", dict() + ) + if not isinstance(comprehensiveness_classification_scores, dict): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, comprehensiveness_classification_scores field {comprehensiveness_classification_scores} is not a dict!' + ) + error = True + sufficiency_classification_scores = instance.get( + "sufficiency_classification_scores", dict() + ) + if not isinstance(sufficiency_classification_scores, dict): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, sufficiency_classification_scores field {sufficiency_classification_scores} is not a dict!' + ) + error = True + if ("classification" in instance) != ("classification_scores" in instance): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, when providing a classification, you must also provide classification scores!' + ) + error = True + if ("comprehensiveness_classification_scores" in instance) and not ( + "classification" in instance + ): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, when providing a classification, you must also provide a comprehensiveness_classification_score' + ) + error = True + if ("sufficiency_classification_scores" in instance) and not ( + "classification_scores" in instance + ): + logging.info( + f'Error! For instance annotation={instance["annotation_id"]}, when providing a sufficiency_classification_score, you must also provide a classification score!' + ) + error = True + if "thresholded_scores" in instance: + instance_thresholds = set( + x["threshold"] for x in instance["thresholded_scores"] + ) + if instance_thresholds != thresholds: + error = True + logging.info( + 'Error: {instance["thresholded_scores"]} has thresholds that differ from previous thresholds: {thresholds}' + ) + if ( + "comprehensiveness_classification_scores" not in instance + or "sufficiency_classification_scores" not in instance + or "classification" not in instance + or "classification_scores" not in instance + ): + error = True + logging.info( + "Error: {instance} must have comprehensiveness_classification_scores, sufficiency_classification_scores, classification, and classification_scores defined when including thresholded scores" + ) + if not all( + "sufficiency_classification_scores" in x + for x in instance["thresholded_scores"] + ): + error = True + logging.info( + "Error: {instance} must have sufficiency_classification_scores for every threshold" + ) + if not all( + "comprehensiveness_classification_scores" in x + for x in instance["thresholded_scores"] + ): + error = True + logging.info( + "Error: {instance} must have comprehensiveness_classification_scores for every threshold" + ) + return error + + +def verify_instances(instances: List[dict], docs: Dict[str, list]): + annotation_ids = list(x["annotation_id"] for x in instances) + key_counter = Counter(annotation_ids) + multi_occurrence_annotation_ids = list( + filter(lambda kv: kv[1] > 1, key_counter.items()) + ) + error = False + if len(multi_occurrence_annotation_ids) > 0: + error = True + logging.info( + f"Error in instances: {len(multi_occurrence_annotation_ids)} appear multiple times in the annotations file: {multi_occurrence_annotation_ids}" + ) + failed_validation = set() + instances_with_classification = list() + instances_with_soft_rationale_predictions = list() + instances_with_soft_sentence_predictions = list() + instances_with_comprehensiveness_classifications = list() + instances_with_sufficiency_classifications = list() + instances_with_thresholded_scores = list() + if "thresholded_scores" in instances[0]: + thresholds = set(x["threshold"] for x in instances[0]["thresholded_scores"]) + else: + thresholds = None + for instance in instances: + instance_error = verify_instance(instance, docs, thresholds) + if instance_error: + error = True + failed_validation.add(instance["annotation_id"]) + if instance.get("classification", None) != None: + instances_with_classification.append(instance) + if instance.get("comprehensiveness_classification_scores", None) != None: + instances_with_comprehensiveness_classifications.append(instance) + if instance.get("sufficiency_classification_scores", None) != None: + instances_with_sufficiency_classifications.append(instance) + has_soft_rationales = [] + has_soft_sentences = [] + for rat in instance["rationales"]: + if rat.get("soft_rationale_predictions", None) != None: + has_soft_rationales.append(rat) + if rat.get("soft_sentence_predictions", None) != None: + has_soft_sentences.append(rat) + if len(has_soft_rationales) > 0: + instances_with_soft_rationale_predictions.append(instance) + if len(has_soft_rationales) != len(instance["rationales"]): + error = True + logging.info( + f'Error: instance {instance["annotation"]} has soft rationales for some but not all reported documents!' + ) + if len(has_soft_sentences) > 0: + instances_with_soft_sentence_predictions.append(instance) + if len(has_soft_sentences) != len(instance["rationales"]): + error = True + logging.info( + f'Error: instance {instance["annotation"]} has soft sentences for some but not all reported documents!' + ) + if "thresholded_scores" in instance: + instances_with_thresholded_scores.append(instance) + logging.info( + f"Error in instances: {len(failed_validation)} instances fail validation: {failed_validation}" + ) + if len(instances_with_classification) != 0 and len( + instances_with_classification + ) != len(instances): + logging.info( + f"Either all {len(instances)} must have a classification or none may, instead {len(instances_with_classification)} do!" + ) + error = True + if len(instances_with_soft_sentence_predictions) != 0 and len( + instances_with_soft_sentence_predictions + ) != len(instances): + logging.info( + f"Either all {len(instances)} must have a sentence prediction or none may, instead {len(instances_with_soft_sentence_predictions)} do!" + ) + error = True + if len(instances_with_soft_rationale_predictions) != 0 and len( + instances_with_soft_rationale_predictions + ) != len(instances): + logging.info( + f"Either all {len(instances)} must have a soft rationale prediction or none may, instead {len(instances_with_soft_rationale_predictions)} do!" + ) + error = True + if len(instances_with_comprehensiveness_classifications) != 0 and len( + instances_with_comprehensiveness_classifications + ) != len(instances): + error = True + logging.info( + f"Either all {len(instances)} must have a comprehensiveness classification or none may, instead {len(instances_with_comprehensiveness_classifications)} do!" + ) + if len(instances_with_sufficiency_classifications) != 0 and len( + instances_with_sufficiency_classifications + ) != len(instances): + error = True + logging.info( + f"Either all {len(instances)} must have a sufficiency classification or none may, instead {len(instances_with_sufficiency_classifications)} do!" + ) + if len(instances_with_thresholded_scores) != 0 and len( + instances_with_thresholded_scores + ) != len(instances): + error = True + logging.info( + f"Either all {len(instances)} must have thresholded scores or none may, instead {len(instances_with_thresholded_scores)} do!" + ) + if error: + raise ValueError( + "Some instances are invalid, please fix your formatting and try again" + ) + + +def _has_hard_predictions(results: List[dict]) -> bool: + # assumes that we have run "verification" over the inputs + return ( + "rationales" in results[0] + and len(results[0]["rationales"]) > 0 + and "hard_rationale_predictions" in results[0]["rationales"][0] + and results[0]["rationales"][0]["hard_rationale_predictions"] is not None + and len(results[0]["rationales"][0]["hard_rationale_predictions"]) > 0 + ) + + +def _has_soft_predictions(results: List[dict]) -> bool: + # assumes that we have run "verification" over the inputs + return ( + "rationales" in results[0] + and len(results[0]["rationales"]) > 0 + and "soft_rationale_predictions" in results[0]["rationales"][0] + and results[0]["rationales"][0]["soft_rationale_predictions"] is not None + ) + + +def _has_soft_sentence_predictions(results: List[dict]) -> bool: + # assumes that we have run "verification" over the inputs + return ( + "rationales" in results[0] + and len(results[0]["rationales"]) > 0 + and "soft_sentence_predictions" in results[0]["rationales"][0] + and results[0]["rationales"][0]["soft_sentence_predictions"] is not None + ) + + +def _has_classifications(results: List[dict]) -> bool: + # assumes that we have run "verification" over the inputs + return "classification" in results[0] and results[0]["classification"] is not None + + +def main(): + parser = argparse.ArgumentParser( + description="""Computes rationale and final class classification scores""", + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + "--data_dir", + dest="data_dir", + required=True, + help="Which directory contains a {train,val,test}.jsonl file?", + ) + parser.add_argument( + "--split", + dest="split", + required=True, + help="Which of {train,val,test} are we scoring on?", + ) + parser.add_argument( + "--strict", + dest="strict", + required=False, + action="store_true", + default=False, + help="Do we perform strict scoring?", + ) + parser.add_argument( + "--results", + dest="results", + required=True, + help="""Results File + Contents are expected to be jsonl of: + { + "annotation_id": str, required + # these classifications *must not* overlap + "rationales": List[ + { + "docid": str, required + "hard_rationale_predictions": List[{ + "start_token": int, inclusive, required + "end_token": int, exclusive, required + }], optional, + # token level classifications, a value must be provided per-token + # in an ideal world, these correspond to the hard-decoding above. + "soft_rationale_predictions": List[float], optional. + # sentence level classifications, a value must be provided for every + # sentence in each document, or not at all + "soft_sentence_predictions": List[float], optional. + } + ], + # the classification the model made for the overall classification task + "classification": str, optional + # A probability distribution output by the model. We require this to be normalized. + "classification_scores": Dict[str, float], optional + # The next two fields are measures for how faithful your model is (the + # rationales it predicts are in some sense causal of the prediction), and + # how sufficient they are. We approximate a measure for comprehensiveness by + # asking that you remove the top k%% of tokens from your documents, + # running your models again, and reporting the score distribution in the + # "comprehensiveness_classification_scores" field. + # We approximate a measure of sufficiency by asking exactly the converse + # - that you provide model distributions on the removed k%% tokens. + # 'k' is determined by human rationales, and is documented in our paper. + # You should determine which of these tokens to remove based on some kind + # of information about your model: gradient based, attention based, other + # interpretability measures, etc. + # scores per class having removed k%% of the data, where k is determined by human comprehensive rationales + "comprehensiveness_classification_scores": Dict[str, float], optional + # scores per class having access to only k%% of the data, where k is determined by human comprehensive rationales + "sufficiency_classification_scores": Dict[str, float], optional + # the number of tokens required to flip the prediction - see "Is Attention Interpretable" by Serrano and Smith. + "tokens_to_flip": int, optional + "thresholded_scores": List[{ + "threshold": float, required, + "comprehensiveness_classification_scores": like "classification_scores" + "sufficiency_classification_scores": like "classification_scores" + }], optional. if present, then "classification" and "classification_scores" must be present + } + When providing one of the optional fields, it must be provided for *every* instance. + The classification, classification_score, and comprehensiveness_classification_scores + must together be present for every instance or absent for every instance. + """, + ) + parser.add_argument( + "--iou_thresholds", + dest="iou_thresholds", + required=False, + nargs="+", + type=float, + default=[0.5], + help="""Thresholds for IOU scoring. + + These are used for "soft" or partial match scoring of rationale spans. + A span is considered a match if the size of the intersection of the prediction + and the annotation, divided by the union of the two spans, is larger than + the IOU threshold. This score can be computed for arbitrary thresholds. + """, + ) + parser.add_argument( + "--score_file", + dest="score_file", + required=False, + default=None, + help="Where to write results?", + ) + parser.add_argument( + "--aopc_thresholds", + nargs="+", + required=False, + type=float, + default=[0.01, 0.05, 0.1, 0.2, 0.5], + help="Thresholds for AOPC Thresholds", + ) + args = parser.parse_args() + results = load_jsonl(args.results) + docids = set( + chain.from_iterable( + [rat["docid"] for rat in res["rationales"]] for res in results + ) + ) + docs = load_flattened_documents(args.data_dir, docids) + verify_instances(results, docs) + # load truth + annotations = annotations_from_jsonl( + os.path.join(args.data_dir, args.split + ".jsonl") + ) + docids |= set( + chain.from_iterable( + (ev.docid for ev in chain.from_iterable(ann.evidences)) + for ann in annotations + ) + ) + + has_final_predictions = _has_classifications(results) + scores = dict() + if args.strict: + if not args.iou_thresholds: + raise ValueError( + "--iou_thresholds must be provided when running strict scoring" + ) + if not has_final_predictions: + raise ValueError( + "We must have a 'classification', 'classification_score', and 'comprehensiveness_classification_score' field in order to perform scoring!" + ) + # TODO think about offering a sentence level version of these scores. + if _has_hard_predictions(results): + truth = list( + chain.from_iterable(Rationale.from_annotation(ann) for ann in annotations) + ) + pred = list( + chain.from_iterable(Rationale.from_instance(inst) for inst in results) + ) + if args.iou_thresholds is not None: + iou_scores = partial_match_score(truth, pred, args.iou_thresholds) + scores["iou_scores"] = iou_scores + # NER style scoring + rationale_level_prf = score_hard_rationale_predictions(truth, pred) + scores["rationale_prf"] = rationale_level_prf + token_level_truth = list( + chain.from_iterable(rat.to_token_level() for rat in truth) + ) + token_level_pred = list( + chain.from_iterable(rat.to_token_level() for rat in pred) + ) + token_level_prf = score_hard_rationale_predictions( + token_level_truth, token_level_pred + ) + scores["token_prf"] = token_level_prf + else: + logging.info("No hard predictions detected, skipping rationale scoring") + + if _has_soft_predictions(results): + flattened_documents = load_flattened_documents(args.data_dir, docids) + paired_scoring = PositionScoredDocument.from_results( + results, annotations, flattened_documents, use_tokens=True + ) + token_scores = score_soft_tokens(paired_scoring) + scores["token_soft_metrics"] = token_scores + else: + logging.info("No soft predictions detected, skipping rationale scoring") + + if _has_soft_sentence_predictions(results): + documents = load_documents(args.data_dir, docids) + paired_scoring = PositionScoredDocument.from_results( + results, annotations, documents, use_tokens=False + ) + sentence_scores = score_soft_tokens(paired_scoring) + scores["sentence_soft_metrics"] = sentence_scores + else: + logging.info( + "No sentence level predictions detected, skipping sentence-level diagnostic" + ) + + if has_final_predictions: + flattened_documents = load_flattened_documents(args.data_dir, docids) + class_results = score_classifications( + results, annotations, flattened_documents, args.aopc_thresholds + ) + scores["classification_scores"] = class_results + else: + logging.info("No classification scores detected, skipping classification") + + pprint.pprint(scores) + + if args.score_file: + with open(args.score_file, "w") as of: + json.dump(scores, of, indent=4, sort_keys=True) + + +if __name__ == "__main__": + main() diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/model_utils.py b/Transformer-Explainability/BERT_rationale_benchmark/models/model_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0b952eaaf77f81c91bd01d0d216407962a64de --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/models/model_utils.py @@ -0,0 +1,186 @@ +from dataclasses import dataclass +from typing import Dict, List, Set + +import numpy as np +import torch +from gensim.models import KeyedVectors +from torch import nn +from torch.nn.utils.rnn import (PackedSequence, pack_padded_sequence, + pad_packed_sequence, pad_sequence) + + +@dataclass(eq=True, frozen=True) +class PaddedSequence: + """A utility class for padding variable length sequences mean for RNN input + This class is in the style of PackedSequence from the PyTorch RNN Utils, + but is somewhat more manual in approach. It provides the ability to generate masks + for outputs of the same input dimensions. + The constructor should never be called directly and should only be called via + the autopad classmethod. + + We'd love to delete this, but we pad_sequence, pack_padded_sequence, and + pad_packed_sequence all require shuffling around tuples of information, and some + convenience methods using these are nice to have. + """ + + data: torch.Tensor + batch_sizes: torch.Tensor + batch_first: bool = False + + @classmethod + def autopad( + cls, data, batch_first: bool = False, padding_value=0, device=None + ) -> "PaddedSequence": + # handle tensors of size 0 (single item) + data_ = [] + for d in data: + if len(d.size()) == 0: + d = d.unsqueeze(0) + data_.append(d) + padded = pad_sequence( + data_, batch_first=batch_first, padding_value=padding_value + ) + if batch_first: + batch_lengths = torch.LongTensor([len(x) for x in data_]) + if any([x == 0 for x in batch_lengths]): + raise ValueError( + "Found a 0 length batch element, this can't possibly be right: {}".format( + batch_lengths + ) + ) + else: + # TODO actually test this codepath + batch_lengths = torch.LongTensor([len(x) for x in data]) + return PaddedSequence(padded, batch_lengths, batch_first).to(device=device) + + def pack_other(self, data: torch.Tensor): + return pack_padded_sequence( + data, self.batch_sizes, batch_first=self.batch_first, enforce_sorted=False + ) + + @classmethod + def from_packed_sequence( + cls, ps: PackedSequence, batch_first: bool, padding_value=0 + ) -> "PaddedSequence": + padded, batch_sizes = pad_packed_sequence(ps, batch_first, padding_value) + return PaddedSequence(padded, batch_sizes, batch_first) + + def cuda(self) -> "PaddedSequence": + return PaddedSequence( + self.data.cuda(), self.batch_sizes.cuda(), batch_first=self.batch_first + ) + + def to( + self, dtype=None, device=None, copy=False, non_blocking=False + ) -> "PaddedSequence": + # TODO make to() support all of the torch.Tensor to() variants + return PaddedSequence( + self.data.to( + dtype=dtype, device=device, copy=copy, non_blocking=non_blocking + ), + self.batch_sizes.to(device=device, copy=copy, non_blocking=non_blocking), + batch_first=self.batch_first, + ) + + def mask( + self, on=int(0), off=int(0), device="cpu", size=None, dtype=None + ) -> torch.Tensor: + if size is None: + size = self.data.size() + out_tensor = torch.zeros(*size, dtype=dtype) + # TODO this can be done more efficiently + out_tensor.fill_(off) + # note to self: these are probably less efficient than explicilty populating the off values instead of the on values. + if self.batch_first: + for i, bl in enumerate(self.batch_sizes): + out_tensor[i, :bl] = on + else: + for i, bl in enumerate(self.batch_sizes): + out_tensor[:bl, i] = on + return out_tensor.to(device) + + def unpad(self, other: torch.Tensor) -> List[torch.Tensor]: + out = [] + for o, bl in zip(other, self.batch_sizes): + out.append(o[:bl]) + return out + + def flip(self) -> "PaddedSequence": + return PaddedSequence( + self.data.transpose(0, 1), not self.batch_first, self.padding_value + ) + + +def extract_embeddings( + vocab: Set[str], embedding_file: str, unk_token: str = "UNK", pad_token: str = "PAD" +) -> (nn.Embedding, Dict[str, int], List[str]): + vocab = vocab | set([unk_token, pad_token]) + if embedding_file.endswith(".bin"): + WVs = KeyedVectors.load_word2vec_format(embedding_file, binary=True) + + word_to_vector = dict() + WV_matrix = np.matrix([WVs[v] for v in WVs.vocab.keys()]) + + if unk_token not in WVs: + mean_vector = np.mean(WV_matrix, axis=0) + word_to_vector[unk_token] = mean_vector + if pad_token not in WVs: + word_to_vector[pad_token] = np.zeros(WVs.vector_size) + + for v in vocab: + if v in WVs: + word_to_vector[v] = WVs[v] + + interner = dict() + deinterner = list() + vectors = [] + count = 0 + for word in [pad_token, unk_token] + sorted( + list(word_to_vector.keys() - {unk_token, pad_token}) + ): + vector = word_to_vector[word] + vectors.append(np.array(vector)) + interner[word] = count + deinterner.append(word) + count += 1 + vectors = torch.FloatTensor(np.array(vectors)) + embedding = nn.Embedding.from_pretrained( + vectors, padding_idx=interner[pad_token] + ) + embedding.weight.requires_grad = False + return embedding, interner, deinterner + elif embedding_file.endswith(".txt"): + word_to_vector = dict() + vector = [] + with open(embedding_file, "r") as inf: + for line in inf: + contents = line.strip().split() + word = contents[0] + vector = torch.tensor([float(v) for v in contents[1:]]).unsqueeze(0) + word_to_vector[word] = vector + embed_size = vector.size() + if unk_token not in word_to_vector: + mean_vector = torch.cat(list(word_to_vector.values()), dim=0).mean(dim=0) + word_to_vector[unk_token] = mean_vector.unsqueeze(0) + if pad_token not in word_to_vector: + word_to_vector[pad_token] = torch.zeros(embed_size) + interner = dict() + deinterner = list() + vectors = [] + count = 0 + for word in [pad_token, unk_token] + sorted( + list(word_to_vector.keys() - {unk_token, pad_token}) + ): + vector = word_to_vector[word] + vectors.append(vector) + interner[word] = count + deinterner.append(word) + count += 1 + vectors = torch.cat(vectors, dim=0) + embedding = nn.Embedding.from_pretrained( + vectors, padding_idx=interner[pad_token] + ) + embedding.weight.requires_grad = False + return embedding, interner, deinterner + else: + raise ValueError("Unable to open embeddings file {}".format(embedding_file)) diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/__init__.py b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/bert_pipeline.py b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/bert_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..c4d853c488dde86b243fd3ce3a6599c5c628b6e2 --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/bert_pipeline.py @@ -0,0 +1,852 @@ +# TODO consider if this can be collapsed back down into the pipeline_train.py +import argparse +import json +import logging +import os +import random +from collections import OrderedDict +from itertools import chain +from typing import List, Tuple + +import numpy as np +import torch +import torch.nn as nn +from BERT_explainability.modules.BERT.BERT_cls_lrp import \ + BertForSequenceClassification as BertForClsOrigLrp +from BERT_explainability.modules.BERT.BertForSequenceClassification import \ + BertForSequenceClassification as BertForSequenceClassificationTest +from BERT_explainability.modules.BERT.ExplanationGenerator import Generator +from BERT_rationale_benchmark.utils import (Annotation, Evidence, + load_datasets, load_documents, + write_jsonl) +from sklearn.metrics import accuracy_score +from transformers import BertForSequenceClassification, BertTokenizer + +logging.basicConfig( + level=logging.DEBUG, format="%(relativeCreated)6d %(threadName)s %(message)s" +) +logger = logging.getLogger(__name__) +# let's make this more or less deterministic (not resistent to restarts) +random.seed(12345) +np.random.seed(67890) +torch.manual_seed(10111213) +torch.backends.cudnn.deterministic = True +torch.backends.cudnn.benchmark = False + + +import numpy as np + +latex_special_token = ["!@#$%^&*()"] + + +def generate(text_list, attention_list, latex_file, color="red", rescale_value=False): + attention_list = attention_list[: len(text_list)] + if attention_list.max() == attention_list.min(): + attention_list = torch.zeros_like(attention_list) + else: + attention_list = ( + 100 + * (attention_list - attention_list.min()) + / (attention_list.max() - attention_list.min()) + ) + attention_list[attention_list < 1] = 0 + attention_list = attention_list.tolist() + text_list = [text_list[i].replace("$", "") for i in range(len(text_list))] + if rescale_value: + attention_list = rescale(attention_list) + word_num = len(text_list) + text_list = clean_word(text_list) + with open(latex_file, "w") as f: + f.write( + r"""\documentclass[varwidth=150mm]{standalone} +\special{papersize=210mm,297mm} +\usepackage{color} +\usepackage{tcolorbox} +\usepackage{CJK} +\usepackage{adjustbox} +\tcbset{width=0.9\textwidth,boxrule=0pt,colback=red,arc=0pt,auto outer arc,left=0pt,right=0pt,boxsep=5pt} +\begin{document} +\begin{CJK*}{UTF8}{gbsn}""" + + "\n" + ) + string = ( + r"""{\setlength{\fboxsep}{0pt}\colorbox{white!0}{\parbox{0.9\textwidth}{""" + + "\n" + ) + for idx in range(word_num): + # string += "\\colorbox{%s!%s}{"%(color, attention_list[idx])+"\\strut " + text_list[idx]+"} " + # print(text_list[idx]) + if "\#\#" in text_list[idx]: + token = text_list[idx].replace("\#\#", "") + string += ( + "\\colorbox{%s!%s}{" % (color, attention_list[idx]) + + "\\strut " + + token + + "}" + ) + else: + string += ( + " " + + "\\colorbox{%s!%s}{" % (color, attention_list[idx]) + + "\\strut " + + text_list[idx] + + "}" + ) + string += "\n}}}" + f.write(string + "\n") + f.write( + r"""\end{CJK*} +\end{document}""" + ) + + +def clean_word(word_list): + new_word_list = [] + for word in word_list: + for latex_sensitive in ["\\", "%", "&", "^", "#", "_", "{", "}"]: + if latex_sensitive in word: + word = word.replace(latex_sensitive, "\\" + latex_sensitive) + new_word_list.append(word) + return new_word_list + + +def scores_per_word_from_scores_per_token(input, tokenizer, input_ids, scores_per_id): + words = tokenizer.convert_ids_to_tokens(input_ids) + words = [word.replace("##", "") for word in words] + score_per_char = [] + + # TODO: DELETE + input_ids_chars = [] + for word in words: + if word in ["[CLS]", "[SEP]", "[UNK]", "[PAD]"]: + continue + input_ids_chars += list(word) + # TODO: DELETE + + for i in range(len(scores_per_id)): + if words[i] in ["[CLS]", "[SEP]", "[UNK]", "[PAD]"]: + continue + score_per_char += [scores_per_id[i]] * len(words[i]) + + score_per_word = [] + start_idx = 0 + end_idx = 0 + # TODO: DELETE + words_from_chars = [] + for inp in input: + if start_idx >= len(score_per_char): + break + end_idx = end_idx + len(inp) + score_per_word.append(np.max(score_per_char[start_idx:end_idx])) + + # TODO: DELETE + words_from_chars.append("".join(input_ids_chars[start_idx:end_idx])) + + start_idx = end_idx + + if words_from_chars[:-1] != input[: len(words_from_chars) - 1]: + print(words_from_chars) + print(input[: len(words_from_chars)]) + print(words) + print(tokenizer.convert_ids_to_tokens(input_ids)) + assert False + + return torch.tensor(score_per_word) + + +def get_input_words(input, tokenizer, input_ids): + words = tokenizer.convert_ids_to_tokens(input_ids) + words = [word.replace("##", "") for word in words] + + input_ids_chars = [] + for word in words: + if word in ["[CLS]", "[SEP]", "[UNK]", "[PAD]"]: + continue + input_ids_chars += list(word) + + start_idx = 0 + end_idx = 0 + words_from_chars = [] + for inp in input: + if start_idx >= len(input_ids_chars): + break + end_idx = end_idx + len(inp) + words_from_chars.append("".join(input_ids_chars[start_idx:end_idx])) + start_idx = end_idx + + if words_from_chars[:-1] != input[: len(words_from_chars) - 1]: + print(words_from_chars) + print(input[: len(words_from_chars)]) + print(words) + print(tokenizer.convert_ids_to_tokens(input_ids)) + assert False + return words_from_chars + + +def bert_tokenize_doc( + doc: List[List[str]], tokenizer, special_token_map +) -> Tuple[List[List[str]], List[List[Tuple[int, int]]]]: + """Tokenizes a document and returns [start, end) spans to map the wordpieces back to their source words""" + sents = [] + sent_token_spans = [] + for sent in doc: + tokens = [] + spans = [] + start = 0 + for w in sent: + if w in special_token_map: + tokens.append(w) + else: + tokens.extend(tokenizer.tokenize(w)) + end = len(tokens) + spans.append((start, end)) + start = end + sents.append(tokens) + sent_token_spans.append(spans) + return sents, sent_token_spans + + +def initialize_models(params: dict, batch_first: bool, use_half_precision=False): + assert batch_first + max_length = params["max_length"] + tokenizer = BertTokenizer.from_pretrained(params["bert_vocab"]) + pad_token_id = tokenizer.pad_token_id + cls_token_id = tokenizer.cls_token_id + sep_token_id = tokenizer.sep_token_id + bert_dir = params["bert_dir"] + evidence_classes = dict( + (y, x) for (x, y) in enumerate(params["evidence_classifier"]["classes"]) + ) + evidence_classifier = BertForSequenceClassification.from_pretrained( + bert_dir, num_labels=len(evidence_classes) + ) + word_interner = tokenizer.vocab + de_interner = tokenizer.ids_to_tokens + return evidence_classifier, word_interner, de_interner, evidence_classes, tokenizer + + +BATCH_FIRST = True + + +def extract_docid_from_dataset_element(element): + return next(iter(element.evidences))[0].docid + + +def extract_evidence_from_dataset_element(element): + return next(iter(element.evidences)) + + +def main(): + parser = argparse.ArgumentParser( + description="""Trains a pipeline model. + + Step 1 is evidence identification, that is identify if a given sentence is evidence or not + Step 2 is evidence classification, that is given an evidence sentence, classify the final outcome for the final task + (e.g. sentiment or significance). + + These models should be separated into two separate steps, but at the moment: + * prep data (load, intern documents, load json) + * convert data for evidence identification - in the case of training data we take all the positives and sample some + negatives + * side note: this sampling is *somewhat* configurable and is done on a per-batch/epoch basis in order to gain a + broader sampling of negative values. + * train evidence identification + * convert data for evidence classification - take all rationales + decisions and use this as input + * train evidence classification + * decode first the evidence, then run classification for each split + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + "--data_dir", + dest="data_dir", + required=True, + help="Which directory contains a {train,val,test}.jsonl file?", + ) + parser.add_argument( + "--output_dir", + dest="output_dir", + required=True, + help="Where shall we write intermediate models + final data to?", + ) + parser.add_argument( + "--model_params", + dest="model_params", + required=True, + help="JSoN file for loading arbitrary model parameters (e.g. optimizers, pre-saved files, etc.", + ) + args = parser.parse_args() + assert BATCH_FIRST + os.makedirs(args.output_dir, exist_ok=True) + + with open(args.model_params, "r") as fp: + logger.info(f"Loading model parameters from {args.model_params}") + model_params = json.load(fp) + logger.info(f"Params: {json.dumps(model_params, indent=2, sort_keys=True)}") + train, val, test = load_datasets(args.data_dir) + docids = set( + e.docid + for e in chain.from_iterable( + chain.from_iterable(map(lambda ann: ann.evidences, chain(train, val, test))) + ) + ) + documents = load_documents(args.data_dir, docids) + logger.info(f"Loaded {len(documents)} documents") + ( + evidence_classifier, + word_interner, + de_interner, + evidence_classes, + tokenizer, + ) = initialize_models(model_params, batch_first=BATCH_FIRST) + logger.info(f"We have {len(word_interner)} wordpieces") + cache = os.path.join(args.output_dir, "preprocessed.pkl") + if os.path.exists(cache): + logger.info(f"Loading interned documents from {cache}") + (interned_documents) = torch.load(cache) + else: + logger.info(f"Interning documents") + interned_documents = {} + for d, doc in documents.items(): + encoding = tokenizer.encode_plus( + doc, + add_special_tokens=True, + max_length=model_params["max_length"], + return_token_type_ids=False, + pad_to_max_length=False, + return_attention_mask=True, + return_tensors="pt", + truncation=True, + ) + interned_documents[d] = encoding + torch.save((interned_documents), cache) + + evidence_classifier = evidence_classifier.cuda() + optimizer = None + scheduler = None + + save_dir = args.output_dir + + logging.info(f"Beginning training classifier") + evidence_classifier_output_dir = os.path.join(save_dir, "classifier") + os.makedirs(save_dir, exist_ok=True) + os.makedirs(evidence_classifier_output_dir, exist_ok=True) + model_save_file = os.path.join(evidence_classifier_output_dir, "classifier.pt") + epoch_save_file = os.path.join( + evidence_classifier_output_dir, "classifier_epoch_data.pt" + ) + + device = next(evidence_classifier.parameters()).device + if optimizer is None: + optimizer = torch.optim.Adam( + evidence_classifier.parameters(), + lr=model_params["evidence_classifier"]["lr"], + ) + criterion = nn.CrossEntropyLoss(reduction="none") + batch_size = model_params["evidence_classifier"]["batch_size"] + epochs = model_params["evidence_classifier"]["epochs"] + patience = model_params["evidence_classifier"]["patience"] + max_grad_norm = model_params["evidence_classifier"].get("max_grad_norm", None) + + class_labels = [k for k, v in sorted(evidence_classes.items())] + + results = { + "train_loss": [], + "train_f1": [], + "train_acc": [], + "val_loss": [], + "val_f1": [], + "val_acc": [], + } + best_epoch = -1 + best_val_acc = 0 + best_val_loss = float("inf") + best_model_state_dict = None + start_epoch = 0 + epoch_data = {} + if os.path.exists(epoch_save_file): + logging.info(f"Restoring model from {model_save_file}") + evidence_classifier.load_state_dict(torch.load(model_save_file)) + epoch_data = torch.load(epoch_save_file) + start_epoch = epoch_data["epoch"] + 1 + # handle finishing because patience was exceeded or we didn't get the best final epoch + if bool(epoch_data.get("done", 0)): + start_epoch = epochs + results = epoch_data["results"] + best_epoch = start_epoch + best_model_state_dict = OrderedDict( + {k: v.cpu() for k, v in evidence_classifier.state_dict().items()} + ) + logging.info(f"Restoring training from epoch {start_epoch}") + logging.info( + f"Training evidence classifier from epoch {start_epoch} until epoch {epochs}" + ) + optimizer.zero_grad() + for epoch in range(start_epoch, epochs): + epoch_train_data = random.sample(train, k=len(train)) + epoch_train_loss = 0 + epoch_training_acc = 0 + evidence_classifier.train() + logging.info( + f"Training with {len(epoch_train_data) // batch_size} batches with {len(epoch_train_data)} examples" + ) + for batch_start in range(0, len(epoch_train_data), batch_size): + batch_elements = epoch_train_data[ + batch_start : min(batch_start + batch_size, len(epoch_train_data)) + ] + targets = [evidence_classes[s.classification] for s in batch_elements] + targets = torch.tensor(targets, dtype=torch.long, device=device) + samples_encoding = [ + interned_documents[extract_docid_from_dataset_element(s)] + for s in batch_elements + ] + input_ids = ( + torch.stack( + [ + samples_encoding[i]["input_ids"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + attention_masks = ( + torch.stack( + [ + samples_encoding[i]["attention_mask"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + preds = evidence_classifier( + input_ids=input_ids, attention_mask=attention_masks + )[0] + epoch_training_acc += accuracy_score( + preds.argmax(dim=1).cpu(), targets.cpu(), normalize=False + ) + loss = criterion(preds, targets.to(device=preds.device)).sum() + epoch_train_loss += loss.item() + loss.backward() + assert loss == loss # for nans + if max_grad_norm: + torch.nn.utils.clip_grad_norm_( + evidence_classifier.parameters(), max_grad_norm + ) + optimizer.step() + if scheduler: + scheduler.step() + optimizer.zero_grad() + epoch_train_loss /= len(epoch_train_data) + epoch_training_acc /= len(epoch_train_data) + assert epoch_train_loss == epoch_train_loss # for nans + results["train_loss"].append(epoch_train_loss) + logging.info(f"Epoch {epoch} training loss {epoch_train_loss}") + logging.info(f"Epoch {epoch} training accuracy {epoch_training_acc}") + + with torch.no_grad(): + epoch_val_loss = 0 + epoch_val_acc = 0 + epoch_val_data = random.sample(val, k=len(val)) + evidence_classifier.eval() + val_batch_size = 32 + logging.info( + f"Validating with {len(epoch_val_data) // val_batch_size} batches with {len(epoch_val_data)} examples" + ) + for batch_start in range(0, len(epoch_val_data), val_batch_size): + batch_elements = epoch_val_data[ + batch_start : min(batch_start + val_batch_size, len(epoch_val_data)) + ] + targets = [evidence_classes[s.classification] for s in batch_elements] + targets = torch.tensor(targets, dtype=torch.long, device=device) + samples_encoding = [ + interned_documents[extract_docid_from_dataset_element(s)] + for s in batch_elements + ] + input_ids = ( + torch.stack( + [ + samples_encoding[i]["input_ids"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + attention_masks = ( + torch.stack( + [ + samples_encoding[i]["attention_mask"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + preds = evidence_classifier( + input_ids=input_ids, attention_mask=attention_masks + )[0] + epoch_val_acc += accuracy_score( + preds.argmax(dim=1).cpu(), targets.cpu(), normalize=False + ) + loss = criterion(preds, targets.to(device=preds.device)).sum() + epoch_val_loss += loss.item() + + epoch_val_loss /= len(val) + epoch_val_acc /= len(val) + results["val_acc"].append(epoch_val_acc) + results["val_loss"] = epoch_val_loss + + logging.info(f"Epoch {epoch} val loss {epoch_val_loss}") + logging.info(f"Epoch {epoch} val acc {epoch_val_acc}") + + if epoch_val_acc > best_val_acc or ( + epoch_val_acc == best_val_acc and epoch_val_loss < best_val_loss + ): + best_model_state_dict = OrderedDict( + {k: v.cpu() for k, v in evidence_classifier.state_dict().items()} + ) + best_epoch = epoch + best_val_acc = epoch_val_acc + best_val_loss = epoch_val_loss + epoch_data = { + "epoch": epoch, + "results": results, + "best_val_acc": best_val_acc, + "done": 0, + } + torch.save(evidence_classifier.state_dict(), model_save_file) + torch.save(epoch_data, epoch_save_file) + logging.debug( + f"Epoch {epoch} new best model with val accuracy {epoch_val_acc}" + ) + if epoch - best_epoch > patience: + logging.info(f"Exiting after epoch {epoch} due to no improvement") + epoch_data["done"] = 1 + torch.save(epoch_data, epoch_save_file) + break + + epoch_data["done"] = 1 + epoch_data["results"] = results + torch.save(epoch_data, epoch_save_file) + evidence_classifier.load_state_dict(best_model_state_dict) + evidence_classifier = evidence_classifier.to(device=device) + evidence_classifier.eval() + + # test + + test_classifier = BertForSequenceClassificationTest.from_pretrained( + model_params["bert_dir"], num_labels=len(evidence_classes) + ).to(device) + orig_lrp_classifier = BertForClsOrigLrp.from_pretrained( + model_params["bert_dir"], num_labels=len(evidence_classes) + ).to(device) + if os.path.exists(epoch_save_file): + logging.info(f"Restoring model from {model_save_file}") + test_classifier.load_state_dict(torch.load(model_save_file)) + orig_lrp_classifier.load_state_dict(torch.load(model_save_file)) + test_classifier.eval() + orig_lrp_classifier.eval() + test_batch_size = 1 + logging.info( + f"Testing with {len(test) // test_batch_size} batches with {len(test)} examples" + ) + + # explainability + explanations = Generator(test_classifier) + explanations_orig_lrp = Generator(orig_lrp_classifier) + method = "transformer_attribution" + method_folder = { + "transformer_attribution": "ours", + "partial_lrp": "partial_lrp", + "last_attn": "last_attn", + "attn_gradcam": "attn_gradcam", + "lrp": "lrp", + "rollout": "rollout", + "ground_truth": "ground_truth", + "generate_all": "generate_all", + } + method_expl = { + "transformer_attribution": explanations.generate_LRP, + "partial_lrp": explanations_orig_lrp.generate_LRP_last_layer, + "last_attn": explanations_orig_lrp.generate_attn_last_layer, + "attn_gradcam": explanations_orig_lrp.generate_attn_gradcam, + "lrp": explanations_orig_lrp.generate_full_lrp, + "rollout": explanations_orig_lrp.generate_rollout, + } + + os.makedirs(os.path.join(args.output_dir, method_folder[method]), exist_ok=True) + + result_files = [] + for i in range(5, 85, 5): + result_files.append( + open( + os.path.join( + args.output_dir, "{0}/identifier_results_{1}.json" + ).format(method_folder[method], i), + "w", + ) + ) + + j = 0 + for batch_start in range(0, len(test), test_batch_size): + batch_elements = test[ + batch_start : min(batch_start + test_batch_size, len(test)) + ] + targets = [evidence_classes[s.classification] for s in batch_elements] + targets = torch.tensor(targets, dtype=torch.long, device=device) + samples_encoding = [ + interned_documents[extract_docid_from_dataset_element(s)] + for s in batch_elements + ] + input_ids = ( + torch.stack( + [ + samples_encoding[i]["input_ids"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + attention_masks = ( + torch.stack( + [ + samples_encoding[i]["attention_mask"] + for i in range(len(samples_encoding)) + ] + ) + .squeeze(1) + .to(device) + ) + preds = test_classifier( + input_ids=input_ids, attention_mask=attention_masks + )[0] + + for s in batch_elements: + doc_name = extract_docid_from_dataset_element(s) + inp = documents[doc_name].split() + classification = "neg" if targets.item() == 0 else "pos" + is_classification_correct = 1 if preds.argmax(dim=1) == targets else 0 + if method == "generate_all": + file_name = "{0}_{1}_{2}.tex".format( + j, classification, is_classification_correct + ) + GT_global = os.path.join( + args.output_dir, "{0}/visual_results_{1}.pdf" + ).format(method_folder["ground_truth"], j) + GT_ours = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["transformer_attribution"], + j, + classification, + is_classification_correct, + ) + CF_ours = os.path.join(args.output_dir, "{0}/{1}_CF.pdf").format( + method_folder["transformer_attribution"], j + ) + GT_partial = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["partial_lrp"], + j, + classification, + is_classification_correct, + ) + CF_partial = os.path.join(args.output_dir, "{0}/{1}_CF.pdf").format( + method_folder["partial_lrp"], j + ) + GT_gradcam = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["attn_gradcam"], + j, + classification, + is_classification_correct, + ) + CF_gradcam = os.path.join(args.output_dir, "{0}/{1}_CF.pdf").format( + method_folder["attn_gradcam"], j + ) + GT_lrp = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["lrp"], + j, + classification, + is_classification_correct, + ) + CF_lrp = os.path.join(args.output_dir, "{0}/{1}_CF.pdf").format( + method_folder["lrp"], j + ) + GT_lastattn = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["last_attn"], + j, + classification, + is_classification_correct, + ) + GT_rollout = os.path.join( + args.output_dir, "{0}/{1}_GT_{2}_{3}.pdf" + ).format( + method_folder["rollout"], + j, + classification, + is_classification_correct, + ) + with open(file_name, "w") as f: + f.write( + r"""\documentclass[varwidth]{standalone} +\usepackage{color} +\usepackage{tcolorbox} +\usepackage{CJK} +\tcbset{width=0.9\textwidth,boxrule=0pt,colback=red,arc=0pt,auto outer arc,left=0pt,right=0pt,boxsep=5pt} +\begin{document} +\begin{CJK*}{UTF8}{gbsn} +{\setlength{\fboxsep}{0pt}\colorbox{white!0}{\parbox{0.9\textwidth}{ + \setlength{\tabcolsep}{2pt} % Default value: 6pt + \begin{tabular}{ccc} + \includegraphics[width=0.32\linewidth]{""" + + GT_global + + """}& + \includegraphics[width=0.32\linewidth]{""" + + GT_ours + + """}& + \includegraphics[width=0.32\linewidth]{""" + + CF_ours + + """}\\\\ + (a) & (b) & (c)\\\\ + \includegraphics[width=0.32\linewidth]{""" + + GT_partial + + """}& + \includegraphics[width=0.32\linewidth]{""" + + CF_partial + + """}& + \includegraphics[width=0.32\linewidth]{""" + + GT_gradcam + + """}\\\\ + (d) & (e) & (f)\\\\ + \includegraphics[width=0.32\linewidth]{""" + + CF_gradcam + + """}& + \includegraphics[width=0.32\linewidth]{""" + + GT_lrp + + """}& + \includegraphics[width=0.32\linewidth]{""" + + CF_lrp + + """}\\\\ + (g) & (h) & (i)\\\\ + \includegraphics[width=0.32\linewidth]{""" + + GT_lastattn + + """}& + \includegraphics[width=0.32\linewidth]{""" + + GT_rollout + + """}&\\\\ + (j) & (k)&\\\\ + \end{tabular} +}}} +\end{CJK*} +\end{document} +)""" + ) + j += 1 + break + + if method == "ground_truth": + inp_cropped = get_input_words(inp, tokenizer, input_ids[0]) + cam = torch.zeros(len(inp_cropped)) + for evidence in extract_evidence_from_dataset_element(s): + start_idx = evidence.start_token + if start_idx >= len(cam): + break + end_idx = evidence.end_token + cam[start_idx:end_idx] = 1 + generate( + inp_cropped, + cam, + ( + os.path.join( + args.output_dir, "{0}/visual_results_{1}.tex" + ).format(method_folder[method], j) + ), + color="green", + ) + j = j + 1 + break + text = tokenizer.convert_ids_to_tokens(input_ids[0]) + classification = "neg" if targets.item() == 0 else "pos" + is_classification_correct = 1 if preds.argmax(dim=1) == targets else 0 + target_idx = targets.item() + cam_target = method_expl[method]( + input_ids=input_ids, + attention_mask=attention_masks, + index=target_idx, + )[0] + cam_target = cam_target.clamp(min=0) + generate( + text, + cam_target, + ( + os.path.join(args.output_dir, "{0}/{1}_GT_{2}_{3}.tex").format( + method_folder[method], + j, + classification, + is_classification_correct, + ) + ), + ) + if method in [ + "transformer_attribution", + "partial_lrp", + "attn_gradcam", + "lrp", + ]: + cam_false_class = method_expl[method]( + input_ids=input_ids, + attention_mask=attention_masks, + index=1 - target_idx, + )[0] + cam_false_class = cam_false_class.clamp(min=0) + generate( + text, + cam_false_class, + ( + os.path.join(args.output_dir, "{0}/{1}_CF.tex").format( + method_folder[method], j + ) + ), + ) + cam = cam_target + cam = scores_per_word_from_scores_per_token( + inp, tokenizer, input_ids[0], cam + ) + j = j + 1 + doc_name = extract_docid_from_dataset_element(s) + hard_rationales = [] + for res, i in enumerate(range(5, 85, 5)): + print("calculating top ", i) + _, indices = cam.topk(k=i) + for index in indices.tolist(): + hard_rationales.append( + {"start_token": index, "end_token": index + 1} + ) + result_dict = { + "annotation_id": doc_name, + "rationales": [ + { + "docid": doc_name, + "hard_rationale_predictions": hard_rationales, + } + ], + } + result_files[res].write(json.dumps(result_dict) + "\n") + + for i in range(len(result_files)): + result_files[i].close() + + +if __name__ == "__main__": + main() diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_train.py b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_train.py new file mode 100644 index 0000000000000000000000000000000000000000..caca3c2a2e09a861767302479bf5eb133d047533 --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_train.py @@ -0,0 +1,235 @@ +import argparse +import json +import logging +import os +import random +from itertools import chain +from typing import Set + +import numpy as np +import torch +from rationale_benchmark.models.mlp import (AttentiveClassifier, + BahadanauAttention, RNNEncoder, + WordEmbedder) +from rationale_benchmark.models.model_utils import extract_embeddings +from rationale_benchmark.models.pipeline.evidence_classifier import \ + train_evidence_classifier +from rationale_benchmark.models.pipeline.evidence_identifier import \ + train_evidence_identifier +from rationale_benchmark.models.pipeline.pipeline_utils import decode +from rationale_benchmark.utils import (intern_annotations, intern_documents, + load_datasets, load_documents, + write_jsonl) + +logging.basicConfig( + level=logging.DEBUG, format="%(relativeCreated)6d %(threadName)s %(message)s" +) +# let's make this more or less deterministic (not resistant to restarts) +random.seed(12345) +np.random.seed(67890) +torch.manual_seed(10111213) +torch.backends.cudnn.deterministic = True +torch.backends.cudnn.benchmark = False + + +def initialize_models( + params: dict, vocab: Set[str], batch_first: bool, unk_token="UNK" +): + # TODO this is obviously asking for some sort of dependency injection. implement if it saves me time. + if "embedding_file" in params["embeddings"]: + embeddings, word_interner, de_interner = extract_embeddings( + vocab, params["embeddings"]["embedding_file"], unk_token=unk_token + ) + if torch.cuda.is_available(): + embeddings = embeddings.cuda() + else: + raise ValueError("No 'embedding_file' found in params!") + word_embedder = WordEmbedder(embeddings, params["embeddings"]["dropout"]) + query_encoder = RNNEncoder( + word_embedder, + batch_first=batch_first, + condition=False, + attention_mechanism=BahadanauAttention(word_embedder.output_dimension), + ) + document_encoder = RNNEncoder( + word_embedder, + batch_first=batch_first, + condition=True, + attention_mechanism=BahadanauAttention( + word_embedder.output_dimension, query_size=query_encoder.output_dimension + ), + ) + evidence_identifier = AttentiveClassifier( + document_encoder, + query_encoder, + 2, + params["evidence_identifier"]["mlp_size"], + params["evidence_identifier"]["dropout"], + ) + query_encoder = RNNEncoder( + word_embedder, + batch_first=batch_first, + condition=False, + attention_mechanism=BahadanauAttention(word_embedder.output_dimension), + ) + document_encoder = RNNEncoder( + word_embedder, + batch_first=batch_first, + condition=True, + attention_mechanism=BahadanauAttention( + word_embedder.output_dimension, query_size=query_encoder.output_dimension + ), + ) + evidence_classes = dict( + (y, x) for (x, y) in enumerate(params["evidence_classifier"]["classes"]) + ) + evidence_classifier = AttentiveClassifier( + document_encoder, + query_encoder, + len(evidence_classes), + params["evidence_classifier"]["mlp_size"], + params["evidence_classifier"]["dropout"], + ) + return ( + evidence_identifier, + evidence_classifier, + word_interner, + de_interner, + evidence_classes, + ) + + +def main(): + parser = argparse.ArgumentParser( + description="""Trains a pipeline model. + + Step 1 is evidence identification, that is identify if a given sentence is evidence or not + Step 2 is evidence classification, that is given an evidence sentence, classify the final outcome for the final task (e.g. sentiment or significance). + + These models should be separated into two separate steps, but at the moment: + * prep data (load, intern documents, load json) + * convert data for evidence identification - in the case of training data we take all the positives and sample some negatives + * side note: this sampling is *somewhat* configurable and is done on a per-batch/epoch basis in order to gain a broader sampling of negative values. + * train evidence identification + * convert data for evidence classification - take all rationales + decisions and use this as input + * train evidence classification + * decode first the evidence, then run classification for each split + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + "--data_dir", + dest="data_dir", + required=True, + help="Which directory contains a {train,val,test}.jsonl file?", + ) + parser.add_argument( + "--output_dir", + dest="output_dir", + required=True, + help="Where shall we write intermediate models + final data to?", + ) + parser.add_argument( + "--model_params", + dest="model_params", + required=True, + help="JSoN file for loading arbitrary model parameters (e.g. optimizers, pre-saved files, etc.", + ) + args = parser.parse_args() + BATCH_FIRST = True + + with open(args.model_params, "r") as fp: + logging.debug(f"Loading model parameters from {args.model_params}") + model_params = json.load(fp) + train, val, test = load_datasets(args.data_dir) + docids = set( + e.docid + for e in chain.from_iterable( + chain.from_iterable(map(lambda ann: ann.evidences, chain(train, val, test))) + ) + ) + documents = load_documents(args.data_dir, docids) + document_vocab = set(chain.from_iterable(chain.from_iterable(documents.values()))) + annotation_vocab = set( + chain.from_iterable(e.query.split() for e in chain(train, val, test)) + ) + logging.debug( + f"Loaded {len(documents)} documents with {len(document_vocab)} unique words" + ) + # this ignores the case where annotations don't align perfectly with token boundaries, but this isn't that important + vocab = document_vocab | annotation_vocab + unk_token = "UNK" + ( + evidence_identifier, + evidence_classifier, + word_interner, + de_interner, + evidence_classes, + ) = initialize_models( + model_params, vocab, batch_first=BATCH_FIRST, unk_token=unk_token + ) + logging.debug( + f"Including annotations, we have {len(vocab)} total words in the data, with embeddings for {len(word_interner)}" + ) + interned_documents = intern_documents(documents, word_interner, unk_token) + interned_train = intern_annotations(train, word_interner, unk_token) + interned_val = intern_annotations(val, word_interner, unk_token) + interned_test = intern_annotations(test, word_interner, unk_token) + assert BATCH_FIRST # for correctness of the split dimension for DataParallel + evidence_identifier, evidence_ident_results = train_evidence_identifier( + evidence_identifier.cuda(), + args.output_dir, + interned_train, + interned_val, + interned_documents, + model_params, + tensorize_model_inputs=True, + ) + evidence_classifier, evidence_class_results = train_evidence_classifier( + evidence_classifier.cuda(), + args.output_dir, + interned_train, + interned_val, + interned_documents, + model_params, + class_interner=evidence_classes, + tensorize_model_inputs=True, + ) + pipeline_batch_size = min( + [ + model_params["evidence_classifier"]["batch_size"], + model_params["evidence_identifier"]["batch_size"], + ] + ) + pipeline_results, train_decoded, val_decoded, test_decoded = decode( + evidence_identifier, + evidence_classifier, + interned_train, + interned_val, + interned_test, + interned_documents, + evidence_classes, + pipeline_batch_size, + tensorize_model_inputs=True, + ) + write_jsonl(train_decoded, os.path.join(args.output_dir, "train_decoded.jsonl")) + write_jsonl(val_decoded, os.path.join(args.output_dir, "val_decoded.jsonl")) + write_jsonl(test_decoded, os.path.join(args.output_dir, "test_decoded.jsonl")) + with open( + os.path.join(args.output_dir, "identifier_results.json"), "w" + ) as ident_output, open( + os.path.join(args.output_dir, "classifier_results.json"), "w" + ) as class_output: + ident_output.write(json.dumps(evidence_ident_results)) + class_output.write(json.dumps(evidence_class_results)) + for k, v in pipeline_results.items(): + if type(v) is dict: + for k1, v1 in v.items(): + logging.info(f"Pipeline results for {k}, {k1}={v1}") + else: + logging.info(f"Pipeline results {k}\t={v}") + + +if __name__ == "__main__": + main() diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_utils.py b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b1a1baed57828a35bdf72401fc2eb824fb648436 --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/models/pipeline/pipeline_utils.py @@ -0,0 +1,1045 @@ +import itertools +import logging +from collections import defaultdict, namedtuple +from itertools import chain +from typing import Any, Dict, List, Tuple + +import numpy as np +import torch +import torch.nn as nn +from rationale_benchmark.metrics import (PositionScoredDocument, Rationale, + partial_match_score, + score_hard_rationale_predictions, + score_soft_tokens) +from rationale_benchmark.models.model_utils import PaddedSequence +from rationale_benchmark.utils import Annotation +from sklearn.metrics import accuracy_score, classification_report + +SentenceEvidence = namedtuple( + "SentenceEvidence", "kls ann_id query docid index sentence" +) + + +def token_annotations_to_evidence_classification( + annotations: List[Annotation], + documents: Dict[str, List[List[Any]]], + class_interner: Dict[str, int], +) -> List[SentenceEvidence]: + ret = [] + for ann in annotations: + docid_to_ev = defaultdict(list) + for evidence in ann.all_evidences(): + docid_to_ev[evidence.docid].append(evidence) + for docid, evidences in docid_to_ev.items(): + evidences = sorted(evidences, key=lambda ev: ev.start_token) + text = [] + covered_tokens = set() + doc = list(chain.from_iterable(documents[docid])) + for evidence in evidences: + assert ( + evidence.start_token >= 0 + and evidence.end_token > evidence.start_token + ) + assert evidence.start_token < len(doc) and evidence.end_token <= len( + doc + ) + text.extend(evidence.text) + new_tokens = set(range(evidence.start_token, evidence.end_token)) + if len(new_tokens & covered_tokens) > 0: + raise ValueError( + "Have overlapping token ranges covered in the evidence spans and the implementer was lazy; deal with it" + ) + covered_tokens |= new_tokens + assert len(text) > 0 + ret.append( + SentenceEvidence( + kls=class_interner[ann.classification], + query=ann.query, + ann_id=ann.annotation_id, + docid=docid, + index=-1, + sentence=tuple(text), + ) + ) + return ret + + +def annotations_to_evidence_classification( + annotations: List[Annotation], + documents: Dict[str, List[List[Any]]], + class_interner: Dict[str, int], + include_all: bool, +) -> List[SentenceEvidence]: + """Converts Corpus-Level annotations to Sentence Level relevance judgments. + + As this module is about a pipelined approach for evidence identification, + inputs to both an evidence identifier and evidence classifier need to be to + be on a sentence level, this module converts data to be that form. + + The return type is of the form + annotation id -> docid -> [sentence level annotations] + """ + ret = [] + for ann in annotations: + ann_id = ann.annotation_id + docids = set(ev.docid for ev in chain.from_iterable(ann.evidences)) + annotations_for_doc = defaultdict(list) + for d in docids: + for index, sent in enumerate(documents[d]): + annotations_for_doc[d].append( + SentenceEvidence( + kls=class_interner[ann.classification], + query=ann.query, + ann_id=ann.annotation_id, + docid=d, + index=index, + sentence=tuple(sent), + ) + ) + if include_all: + ret.extend(chain.from_iterable(annotations_for_doc.values())) + else: + contributes = set() + for ev in chain.from_iterable(ann.evidences): + for index in range(ev.start_sentence, ev.end_sentence): + contributes.add(annotations_for_doc[ev.docid][index]) + ret.extend(contributes) + assert len(ret) > 0 + return ret + + +def annotations_to_evidence_identification( + annotations: List[Annotation], documents: Dict[str, List[List[Any]]] +) -> Dict[str, Dict[str, List[SentenceEvidence]]]: + """Converts Corpus-Level annotations to Sentence Level relevance judgments. + + As this module is about a pipelined approach for evidence identification, + inputs to both an evidence identifier and evidence classifier need to be to + be on a sentence level, this module converts data to be that form. + + The return type is of the form + annotation id -> docid -> [sentence level annotations] + """ + ret = defaultdict(dict) # annotation id -> docid -> sentences + for ann in annotations: + ann_id = ann.annotation_id + for ev_group in ann.evidences: + for ev in ev_group: + if len(ev.text) == 0: + continue + if ev.docid not in ret[ann_id]: + ret[ann.annotation_id][ev.docid] = [] + # populate the document with "not evidence"; to be filled in later + for index, sent in enumerate(documents[ev.docid]): + ret[ann.annotation_id][ev.docid].append( + SentenceEvidence( + kls=0, + query=ann.query, + ann_id=ann.annotation_id, + docid=ev.docid, + index=index, + sentence=sent, + ) + ) + # define the evidence sections of the document + for s in range(ev.start_sentence, ev.end_sentence): + ret[ann.annotation_id][ev.docid][s] = SentenceEvidence( + kls=1, + ann_id=ann.annotation_id, + query=ann.query, + docid=ev.docid, + index=ret[ann.annotation_id][ev.docid][s].index, + sentence=ret[ann.annotation_id][ev.docid][s].sentence, + ) + return ret + + +def annotations_to_evidence_token_identification( + annotations: List[Annotation], + source_documents: Dict[str, List[List[str]]], + interned_documents: Dict[str, List[List[int]]], + token_mapping: Dict[str, List[List[Tuple[int, int]]]], +) -> Dict[str, Dict[str, List[SentenceEvidence]]]: + # TODO document + # TODO should we simplify to use only source text? + ret = defaultdict(lambda: defaultdict(list)) # annotation id -> docid -> sentences + positive_tokens = 0 + negative_tokens = 0 + for ann in annotations: + annid = ann.annotation_id + docids = set(ev.docid for ev in chain.from_iterable(ann.evidences)) + sentence_offsets = defaultdict(list) # docid -> [(start, end)] + classes = defaultdict(list) # docid -> [token is yea or nay] + for docid in docids: + start = 0 + assert len(source_documents[docid]) == len(interned_documents[docid]) + for whole_token_sent, wordpiece_sent in zip( + source_documents[docid], interned_documents[docid] + ): + classes[docid].extend([0 for _ in wordpiece_sent]) + end = start + len(wordpiece_sent) + sentence_offsets[docid].append((start, end)) + start = end + for ev in chain.from_iterable(ann.evidences): + if len(ev.text) == 0: + continue + flat_token_map = list(chain.from_iterable(token_mapping[ev.docid])) + if ev.start_token != -1: + # start, end = token_mapping[ev.docid][ev.start_token][0], token_mapping[ev.docid][ev.end_token][1] + start, end = ( + flat_token_map[ev.start_token][0], + flat_token_map[ev.end_token - 1][1], + ) + else: + start = flat_token_map[sentence_offsets[ev.start_sentence][0]][0] + end = flat_token_map[sentence_offsets[ev.end_sentence - 1][1]][1] + for i in range(start, end): + classes[ev.docid][i] = 1 + for docid, offsets in sentence_offsets.items(): + token_assignments = classes[docid] + positive_tokens += sum(token_assignments) + negative_tokens += len(token_assignments) - sum(token_assignments) + for s, (start, end) in enumerate(offsets): + sent = interned_documents[docid][s] + ret[annid][docid].append( + SentenceEvidence( + kls=tuple(token_assignments[start:end]), + query=ann.query, + ann_id=ann.annotation_id, + docid=docid, + index=s, + sentence=sent, + ) + ) + logging.info( + f"Have {positive_tokens} positive wordpiece tokens, {negative_tokens} negative wordpiece tokens" + ) + return ret + + +def make_preds_batch( + classifier: nn.Module, + batch_elements: List[SentenceEvidence], + device=None, + criterion: nn.Module = None, + tensorize_model_inputs: bool = True, +) -> Tuple[float, List[float], List[int], List[int]]: + """Batch predictions + + Args: + classifier: a module that looks like an AttentiveClassifier + batch_elements: a list of elements to make predictions over. These must be SentenceEvidence objects. + device: Optional; what compute device this should run on + criterion: Optional; a loss function + tensorize_model_inputs: should we convert our data to tensors before passing it to the model? Useful if we have a model that performs its own tokenization + """ + # delete any "None" padding, if any (imposed by the use of the "grouper") + batch_elements = filter(lambda x: x is not None, batch_elements) + targets, queries, sentences = zip( + *[(s.kls, s.query, s.sentence) for s in batch_elements] + ) + ids = [(s.ann_id, s.docid, s.index) for s in batch_elements] + targets = torch.tensor(targets, dtype=torch.long, device=device) + if tensorize_model_inputs: + queries = [torch.tensor(q, dtype=torch.long) for q in queries] + sentences = [torch.tensor(s, dtype=torch.long) for s in sentences] + preds = classifier(queries, ids, sentences) + targets = targets.to(device=preds.device) + if criterion: + loss = criterion(preds, targets) + else: + loss = None + # .float() because pytorch 1.3 introduces a bug where argmax is unsupported for float16 + hard_preds = torch.argmax(preds.float(), dim=-1) + return loss, preds, hard_preds, targets + + +def make_preds_epoch( + classifier: nn.Module, + data: List[SentenceEvidence], + batch_size: int, + device=None, + criterion: nn.Module = None, + tensorize_model_inputs: bool = True, +): + """Predictions for more than one batch. + + Args: + classifier: a module that looks like an AttentiveClassifier + data: a list of elements to make predictions over. These must be SentenceEvidence objects. + batch_size: the biggest chunk we can fit in one batch. + device: Optional; what compute device this should run on + criterion: Optional; a loss function + tensorize_model_inputs: should we convert our data to tensors before passing it to the model? Useful if we have a model that performs its own tokenization + """ + epoch_loss = 0 + epoch_soft_pred = [] + epoch_hard_pred = [] + epoch_truth = [] + batches = _grouper(data, batch_size) + classifier.eval() + for batch in batches: + loss, soft_preds, hard_preds, targets = make_preds_batch( + classifier, + batch, + device, + criterion=criterion, + tensorize_model_inputs=tensorize_model_inputs, + ) + if loss is not None: + epoch_loss += loss.sum().item() + epoch_hard_pred.extend(hard_preds) + epoch_soft_pred.extend(soft_preds.cpu()) + epoch_truth.extend(targets) + epoch_loss /= len(data) + epoch_hard_pred = [x.item() for x in epoch_hard_pred] + epoch_truth = [x.item() for x in epoch_truth] + return epoch_loss, epoch_soft_pred, epoch_hard_pred, epoch_truth + + +def make_token_preds_batch( + classifier: nn.Module, + batch_elements: List[SentenceEvidence], + token_mapping: Dict[str, List[List[Tuple[int, int]]]], + device=None, + criterion: nn.Module = None, + tensorize_model_inputs: bool = True, +) -> Tuple[float, List[float], List[int], List[int]]: + """Batch predictions + + Args: + classifier: a module that looks like an AttentiveClassifier + batch_elements: a list of elements to make predictions over. These must be SentenceEvidence objects. + device: Optional; what compute device this should run on + criterion: Optional; a loss function + tensorize_model_inputs: should we convert our data to tensors before passing it to the model? Useful if we have a model that performs its own tokenization + """ + # delete any "None" padding, if any (imposed by the use of the "grouper") + batch_elements = filter(lambda x: x is not None, batch_elements) + targets, queries, sentences = zip( + *[(s.kls, s.query, s.sentence) for s in batch_elements] + ) + ids = [(s.ann_id, s.docid, s.index) for s in batch_elements] + targets = PaddedSequence.autopad( + [torch.tensor(t, dtype=torch.long, device=device) for t in targets], + batch_first=True, + device=device, + ) + aggregate_spans = [token_mapping[s.docid][s.index] for s in batch_elements] + if tensorize_model_inputs: + queries = [torch.tensor(q, dtype=torch.long) for q in queries] + sentences = [torch.tensor(s, dtype=torch.long) for s in sentences] + preds = classifier(queries, ids, sentences, aggregate_spans) + targets = targets.to(device=preds.device) + mask = targets.mask(on=1, off=0, device=preds.device, dtype=torch.float) + if criterion: + loss = criterion( + preds, (targets.data.to(device=preds.device) * mask).squeeze() + ).sum() + else: + loss = None + hard_preds = [ + torch.round(x).to(dtype=torch.int).cpu() for x in targets.unpad(preds) + ] + targets = [[y.item() for y in x] for x in targets.unpad(targets.data.cpu())] + return loss, preds, hard_preds, targets # targets.unpad(targets.data.cpu()) + + +# TODO fix the arguments +def make_token_preds_epoch( + classifier: nn.Module, + data: List[SentenceEvidence], + token_mapping: Dict[str, List[List[Tuple[int, int]]]], + batch_size: int, + device=None, + criterion: nn.Module = None, + tensorize_model_inputs: bool = True, +): + """Predictions for more than one batch. + + Args: + classifier: a module that looks like an AttentiveClassifier + data: a list of elements to make predictions over. These must be SentenceEvidence objects. + batch_size: the biggest chunk we can fit in one batch. + device: Optional; what compute device this should run on + criterion: Optional; a loss function + tensorize_model_inputs: should we convert our data to tensors before passing it to the model? Useful if we have a model that performs its own tokenization + """ + epoch_loss = 0 + epoch_soft_pred = [] + epoch_hard_pred = [] + epoch_truth = [] + batches = _grouper(data, batch_size) + classifier.eval() + for batch in batches: + loss, soft_preds, hard_preds, targets = make_token_preds_batch( + classifier, + batch, + token_mapping, + device, + criterion=criterion, + tensorize_model_inputs=tensorize_model_inputs, + ) + if loss is not None: + epoch_loss += loss.sum().item() + epoch_hard_pred.extend(hard_preds) + epoch_soft_pred.extend(soft_preds.cpu().tolist()) + epoch_truth.extend(targets) + epoch_loss /= len(data) + return epoch_loss, epoch_soft_pred, epoch_hard_pred, epoch_truth + + +# copied from https://docs.python.org/3/library/itertools.html#itertools-recipes +def _grouper(iterable, n, fillvalue=None): + "Collect data into fixed-length chunks or blocks" + # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx" + args = [iter(iterable)] * n + return itertools.zip_longest(*args, fillvalue=fillvalue) + + +def score_rationales( + truth: List[Annotation], + documents: Dict[str, List[List[int]]], + input_data: List[SentenceEvidence], + scores: List[float], +) -> dict: + results = {} + doc_to_sent_scores = dict() # (annid, docid) -> [sentence scores] + for sent, score in zip(input_data, scores): + k = (sent.ann_id, sent.docid) + if k not in doc_to_sent_scores: + doc_to_sent_scores[k] = [0.0 for _ in range(len(documents[sent.docid]))] + if not isinstance(score[1], float): + score[1] = score[1].item() + doc_to_sent_scores[(sent.ann_id, sent.docid)][sent.index] = score[1] + # hard rationale scoring + best_sentence = {k: np.argmax(np.array(v)) for k, v in doc_to_sent_scores.items()} + predicted_rationales = [] + for (ann_id, docid), sent_idx in best_sentence.items(): + start_token = sum(len(s) for s in documents[docid][:sent_idx]) + end_token = start_token + len(documents[docid][sent_idx]) + predicted_rationales.append(Rationale(ann_id, docid, start_token, end_token)) + true_rationales = list( + chain.from_iterable(Rationale.from_annotation(rat) for rat in truth) + ) + + results["hard_rationale_scores"] = score_hard_rationale_predictions( + true_rationales, predicted_rationales + ) + results["hard_rationale_partial_match_scores"] = partial_match_score( + true_rationales, predicted_rationales, [0.5] + ) + + # soft rationale scoring + instance_format = [] + for (ann_id, docid), sentences in doc_to_sent_scores.items(): + soft_token_predictions = [] + for sent_score, sent_text in zip(sentences, documents[docid]): + soft_token_predictions.extend(sent_score for _ in range(len(sent_text))) + instance_format.append( + { + "annotation_id": ann_id, + "rationales": [ + { + "docid": docid, + "soft_rationale_predictions": soft_token_predictions, + "soft_sentence_predictions": sentences, + } + ], + } + ) + flattened_documents = { + k: list(chain.from_iterable(v)) for k, v in documents.items() + } + token_scoring_format = PositionScoredDocument.from_results( + instance_format, truth, flattened_documents, use_tokens=True + ) + results["soft_token_scores"] = score_soft_tokens(token_scoring_format) + sentence_scoring_format = PositionScoredDocument.from_results( + instance_format, truth, documents, use_tokens=False + ) + results["soft_sentence_scores"] = score_soft_tokens(sentence_scoring_format) + return results + + +def decode( + evidence_identifier: nn.Module, + evidence_classifier: nn.Module, + train: List[Annotation], + val: List[Annotation], + test: List[Annotation], + docs: Dict[str, List[List[int]]], + class_interner: Dict[str, int], + batch_size: int, + tensorize_model_inputs: bool, + decoding_docs: Dict[str, List[Any]] = None, +) -> dict: + """Identifies and then classifies evidence + + Args: + evidence_identifier: a module for identifying evidence statements + evidence_classifier: a module for making a classification based on evidence statements + train: A List of interned Annotations + val: A List of interned Annotations + test: A List of interned Annotations + docs: A Dict of Documents, which are interned sentences. + class_interner: Converts an Annotation's final class into ints + batch_size: how big should our batches be? + tensorize_model_inputs: should we convert our data to tensors before passing it to the model? Useful if we have a model that performs its own tokenization + """ + device = None + class_labels = [k for k, v in sorted(class_interner.items(), key=lambda x: x[1])] + if decoding_docs is None: + decoding_docs = docs + + def prep(data: List[Annotation]) -> List[Tuple[SentenceEvidence, SentenceEvidence]]: + """Prepares data for evidence identification and classification. + + Creates paired evaluation data, wherein each (annotation, docid, sentence, kls) + tuplet appears first as the kls determining if the sentence is evidence, and + secondarily what the overall classification for the (annotation/docid) pair is. + This allows selection based on model scores of the evidence_identifier for + input to the evidence_classifier. + """ + identification_data = annotations_to_evidence_identification(data, docs) + classification_data = annotations_to_evidence_classification( + data, docs, class_interner, include_all=True + ) + ann_doc_sents = defaultdict( + lambda: defaultdict(dict) + ) # ann id -> docid -> sent idx -> sent data + ret = [] + for sent_ev in classification_data: + id_data = identification_data[sent_ev.ann_id][sent_ev.docid][sent_ev.index] + ret.append((id_data, sent_ev)) + assert id_data.ann_id == sent_ev.ann_id + assert id_data.docid == sent_ev.docid + assert id_data.index == sent_ev.index + assert len(ret) == len(classification_data) + return ret + + def decode_batch( + data: List[Tuple[SentenceEvidence, SentenceEvidence]], + name: str, + score: bool = False, + annotations: List[Annotation] = None, + ) -> dict: + """Identifies evidence statements and then makes classifications based on it. + + Args: + data: a paired list of SentenceEvidences, differing only in the kls field. + The first corresponds to whether or not something is evidence, and the second corresponds to an evidence class + name: a name for a results dict + """ + + num_uniques = len(set((x.ann_id, x.docid) for x, _ in data)) + logging.info( + f"Decoding dataset {name} with {len(data)} sentences, {num_uniques} annotations" + ) + identifier_data, classifier_data = zip(*data) + results = dict() + IdentificationClassificationResult = namedtuple( + "IdentificationClassificationResult", + "identification_data classification_data soft_identification hard_identification soft_classification hard_classification", + ) + with torch.no_grad(): + # make predictions for the evidence_identifier + evidence_identifier.eval() + evidence_classifier.eval() + + ( + _, + soft_identification_preds, + hard_identification_preds, + _, + ) = make_preds_epoch( + evidence_identifier, + identifier_data, + batch_size, + device, + tensorize_model_inputs=tensorize_model_inputs, + ) + assert len(soft_identification_preds) == len(data) + identification_results = defaultdict(list) + for id_data, cls_data, soft_id_pred, hard_id_pred in zip( + identifier_data, + classifier_data, + soft_identification_preds, + hard_identification_preds, + ): + res = IdentificationClassificationResult( + identification_data=id_data, + classification_data=cls_data, + # 1 is p(evidence|sent,query) + soft_identification=soft_id_pred[1].float().item(), + hard_identification=hard_id_pred, + soft_classification=None, + hard_classification=False, + ) + identification_results[(id_data.ann_id, id_data.docid)].append(res) + + best_identification_results = { + key: max(value, key=lambda x: x.soft_identification) + for key, value in identification_results.items() + } + logging.info( + f"Selected the best sentence for {len(identification_results)} examples from a total of {len(soft_identification_preds)} sentences" + ) + ids, classification_data = zip( + *[ + (k, v.classification_data) + for k, v in best_identification_results.items() + ] + ) + ( + _, + soft_classification_preds, + hard_classification_preds, + classification_truth, + ) = make_preds_epoch( + evidence_classifier, + classification_data, + batch_size, + device, + tensorize_model_inputs=tensorize_model_inputs, + ) + classification_results = dict() + for eyeD, soft_class, hard_class in zip( + ids, soft_classification_preds, hard_classification_preds + ): + input_id_result = best_identification_results[eyeD] + res = IdentificationClassificationResult( + identification_data=input_id_result.identification_data, + classification_data=input_id_result.classification_data, + soft_identification=input_id_result.soft_identification, + hard_identification=input_id_result.hard_identification, + soft_classification=soft_class, + hard_classification=hard_class, + ) + classification_results[eyeD] = res + + if score: + truth = [] + pred = [] + for res in classification_results.values(): + truth.append(res.classification_data.kls) + pred.append(res.hard_classification) + # results[f'{name}_f1'] = classification_report(classification_truth, pred, target_names=class_labels, output_dict=True) + results[f"{name}_f1"] = classification_report( + classification_truth, + hard_classification_preds, + target_names=class_labels, + output_dict=True, + ) + results[f"{name}_acc"] = accuracy_score( + classification_truth, hard_classification_preds + ) + results[f"{name}_rationale"] = score_rationales( + annotations, + decoding_docs, + identifier_data, + soft_identification_preds, + ) + + # turn the above results into a format suitable for scoring via the rationale scorer + # n.b. the sentence-level evidence predictions (hard and soft) are + # broadcast to the token level for scoring. The comprehensiveness class + # score is also a lie since the pipeline model above is faithful by + # design. + decoded = dict() + decoded_scores = defaultdict(list) + for (ann_id, docid), pred in classification_results.items(): + sentence_prediction_scores = [ + x.soft_identification + for x in identification_results[(ann_id, docid)] + ] + sentence_start_token = sum( + len(s) + for s in decoding_docs[docid][: pred.identification_data.index] + ) + sentence_end_token = sentence_start_token + len( + decoding_docs[docid][pred.classification_data.index] + ) + hard_rationale_predictions = [ + { + "start_token": sentence_start_token, + "end_token": sentence_end_token, + } + ] + soft_rationale_predictions = [] + for sent_result in sorted( + identification_results[(ann_id, docid)], + key=lambda x: x.identification_data.index, + ): + soft_rationale_predictions.extend( + sent_result.soft_identification + for _ in range( + len( + decoding_docs[sent_result.identification_data.docid][ + sent_result.identification_data.index + ] + ) + ) + ) + if ann_id not in decoded: + decoded[ann_id] = { + "annotation_id": ann_id, + "rationales": [], + "classification": class_labels[pred.hard_classification], + "classification_scores": { + class_labels[i]: s.item() + for i, s in enumerate(pred.soft_classification) + }, + # TODO this should turn into the data distribution for the predicted class + # "comprehensiveness_classification_scores": 0.0, + "truth": pred.classification_data.kls, + } + decoded[ann_id]["rationales"].append( + { + "docid": docid, + "hard_rationale_predictions": hard_rationale_predictions, + "soft_rationale_predictions": soft_rationale_predictions, + "soft_sentence_predictions": sentence_prediction_scores, + } + ) + decoded_scores[ann_id].append(pred.soft_classification) + + # in practice, this is always a single element operation: + # in evidence inference (prompt is really a prompt + document), fever (we split documents into two classifications), movies (you only have one opinion about a movie), or boolQ (single document prompts) + # this exists to support weird models we *might* implement for cose/esnli + for ann_id, scores_list in decoded_scores.items(): + scores = torch.stack(scores_list) + score_avg = torch.mean(scores, dim=0) + # .float() because pytorch 1.3 introduces a bug where argmax is unsupported for float16 + hard_pred = torch.argmax(score_avg.float()).item() + decoded[ann_id]["classification"] = class_labels[hard_pred] + decoded[ann_id]["classification_scores"] = { + class_labels[i]: s.item() for i, s in enumerate(score_avg) + } + return results, list(decoded.values()) + + test_results, test_decoded = decode_batch(prep(test), "test", score=False) + val_results, val_decoded = dict(), [] + train_results, train_decoded = dict(), [] + # val_results, val_decoded = decode_batch(prep(val), 'val', score=True, annotations=val) + # train_results, train_decoded = decode_batch(prep(train), 'train', score=True, annotations=train) + return ( + dict(**train_results, **val_results, **test_results), + train_decoded, + val_decoded, + test_decoded, + ) + + +def decode_evidence_tokens_and_classify( + evidence_token_identifier: nn.Module, + evidence_classifier: nn.Module, + train: List[Annotation], + val: List[Annotation], + test: List[Annotation], + docs: Dict[str, List[List[int]]], + source_documents: Dict[str, List[List[str]]], + token_mapping: Dict[str, List[List[Tuple[int, int]]]], + class_interner: Dict[str, int], + batch_size: int, + decoding_docs: Dict[str, List[Any]], + use_cose_hack: bool = False, +) -> dict: + """Identifies and then classifies evidence + + Args: + evidence_token_identifier: a module for identifying evidence statements + evidence_classifier: a module for making a classification based on evidence statements + train: A List of interned Annotations + val: A List of interned Annotations + test: A List of interned Annotations + docs: A Dict of Documents, which are interned sentences. + class_interner: Converts an Annotation's final class into ints + batch_size: how big should our batches be? + """ + device = None + class_labels = [k for k, v in sorted(class_interner.items(), key=lambda x: x[1])] + if decoding_docs is None: + decoding_docs = docs + + def prep(data: List[Annotation]) -> List[Tuple[SentenceEvidence, SentenceEvidence]]: + """Prepares data for evidence identification and classification. + + Creates paired evaluation data, wherein each (annotation, docid, sentence, kls) + tuplet appears first as the kls determining if the sentence is evidence, and + secondarily what the overall classification for the (annotation/docid) pair is. + This allows selection based on model scores of the evidence_token_identifier for + input to the evidence_classifier. + """ + # identification_data = annotations_to_evidence_identification(data, docs) + classification_data = token_annotations_to_evidence_classification( + data, docs, class_interner + ) + # annotation id -> docid -> [SentenceEvidence]) + identification_data = annotations_to_evidence_token_identification( + data, + source_documents=decoding_docs, + interned_documents=docs, + token_mapping=token_mapping, + ) + ann_doc_sents = defaultdict( + lambda: defaultdict(dict) + ) # ann id -> docid -> sent idx -> sent data + ret = [] + for sent_ev in classification_data: + id_data = identification_data[sent_ev.ann_id][sent_ev.docid][sent_ev.index] + ret.append((id_data, sent_ev)) + assert id_data.ann_id == sent_ev.ann_id + assert id_data.docid == sent_ev.docid + # assert id_data.index == sent_ev.index + assert len(ret) == len(classification_data) + return ret + + def decode_batch( + data: List[Tuple[SentenceEvidence, SentenceEvidence]], + name: str, + score: bool = False, + annotations: List[Annotation] = None, + class_labels: dict = class_labels, + ) -> dict: + """Identifies evidence statements and then makes classifications based on it. + + Args: + data: a paired list of SentenceEvidences, differing only in the kls field. + The first corresponds to whether or not something is evidence, and the second corresponds to an evidence class + name: a name for a results dict + """ + + num_uniques = len(set((x.ann_id, x.docid) for x, _ in data)) + logging.info( + f"Decoding dataset {name} with {len(data)} sentences, {num_uniques} annotations" + ) + identifier_data, classifier_data = zip(*data) + results = dict() + with torch.no_grad(): + # make predictions for the evidence_token_identifier + evidence_token_identifier.eval() + evidence_classifier.eval() + + ( + _, + soft_identification_preds, + hard_identification_preds, + id_preds_truth, + ) = make_token_preds_epoch( + evidence_token_identifier, + identifier_data, + token_mapping, + batch_size, + device, + tensorize_model_inputs=True, + ) + assert len(soft_identification_preds) == len(data) + evidence_only_cls = [] + for id_data, cls_data, soft_id_pred, hard_id_pred in zip( + identifier_data, + classifier_data, + soft_identification_preds, + hard_identification_preds, + ): + assert cls_data.ann_id == id_data.ann_id + sent = [] + for start, end in token_mapping[cls_data.docid][0]: + if bool(hard_id_pred[start]): + sent.extend(id_data.sentence[start:end]) + # assert len(sent) > 0 + new_cls_data = SentenceEvidence( + cls_data.kls, + cls_data.ann_id, + cls_data.query, + cls_data.docid, + cls_data.index, + tuple(sent), + ) + evidence_only_cls.append(new_cls_data) + ( + _, + soft_classification_preds, + hard_classification_preds, + classification_truth, + ) = make_preds_epoch( + evidence_classifier, + evidence_only_cls, + batch_size, + device, + tensorize_model_inputs=True, + ) + + if use_cose_hack: + logging.info( + "Reformatting identification and classification results to fit COS-E" + ) + grouping = 5 + new_soft_identification_preds = [] + new_hard_identification_preds = [] + new_id_preds_truth = [] + new_soft_classification_preds = [] + new_hard_classification_preds = [] + new_classification_truth = [] + new_identifier_data = [] + class_labels = [] + + # TODO fix the labels for COS-E + for i in range(0, len(soft_identification_preds), grouping): + cls_scores = torch.stack( + soft_classification_preds[i : i + grouping] + ) + cls_scores = nn.functional.softmax(cls_scores, dim=-1) + cls_scores = cls_scores[:, 1] + choice = torch.argmax(cls_scores) + cls_labels = [ + x.ann_id.split("_")[-1] + for x in evidence_only_cls[i : i + grouping] + ] + class_labels = cls_labels # we need to update the class labels because of the terrible hackery used to train this + cls_truths = [x.kls for x in evidence_only_cls[i : i + grouping]] + # cls_choice = evidence_only_cls[i + choice].ann_id.split('_')[-1] + cls_truth = np.argmax(cls_truths) + new_soft_identification_preds.append( + soft_identification_preds[i + choice] + ) + new_hard_identification_preds.append( + hard_identification_preds[i + choice] + ) + new_id_preds_truth.append(id_preds_truth[i + choice]) + new_soft_classification_preds.append( + soft_classification_preds[i + choice] + ) + new_hard_classification_preds.append(choice) + new_identifier_data.append(identifier_data[i + choice]) + # new_hard_classification_preds.append(hard_classification_preds[i + choice]) + # new_classification_truth.append(classification_truth[i + choice]) + new_classification_truth.append(cls_truth) + + soft_identification_preds = new_soft_identification_preds + hard_identification_preds = new_hard_identification_preds + id_preds_truth = new_id_preds_truth + soft_classification_preds = new_soft_classification_preds + hard_classification_preds = new_hard_classification_preds + classification_truth = new_classification_truth + identifier_data = new_identifier_data + if score: + results[f"{name}_f1"] = classification_report( + classification_truth, + hard_classification_preds, + target_names=class_labels, + output_dict=True, + ) + results[f"{name}_acc"] = accuracy_score( + classification_truth, hard_classification_preds + ) + results[f"{name}_token_pred_acc"] = accuracy_score( + list(chain.from_iterable(id_preds_truth)), + list(chain.from_iterable(hard_identification_preds)), + ) + results[f"{name}_token_pred_f1"] = classification_report( + list(chain.from_iterable(id_preds_truth)), + list(chain.from_iterable(hard_identification_preds)), + output_dict=True, + ) + # TODO for token level stuff! + soft_id_scores = [ + [1 - x, x] for x in chain.from_iterable(soft_identification_preds) + ] + results[f"{name}_rationale"] = score_rationales( + annotations, decoding_docs, identifier_data, soft_id_scores + ) + logging.info(f"Results: {results}") + + # turn the above results into a format suitable for scoring via the rationale scorer + # n.b. the sentence-level evidence predictions (hard and soft) are + # broadcast to the token level for scoring. The comprehensiveness class + # score is also a lie since the pipeline model above is faithful by + # design. + decoded = dict() + scores = [] + assert len(identifier_data) == len(soft_identification_preds) + for ( + id_data, + soft_id_pred, + hard_id_pred, + soft_cls_preds, + hard_cls_pred, + ) in zip( + identifier_data, + soft_identification_preds, + hard_identification_preds, + soft_classification_preds, + hard_classification_preds, + ): + docid = id_data.docid + if use_cose_hack: + docid = "_".join(docid.split("_")[0:-1]) + assert len(docid) > 0 + rationales = { + "docid": docid, + "hard_rationale_predictions": [], + # token level classifications, a value must be provided per-token + # in an ideal world, these correspond to the hard-decoding above. + "soft_rationale_predictions": [], + # sentence level classifications, a value must be provided for every + # sentence in each document, or not at all + "soft_sentence_predictions": [1.0], + } + last = -1 + start_span = -1 + for pos, (start, _) in enumerate(token_mapping[id_data.docid][0]): + rationales["soft_rationale_predictions"].append(soft_id_pred[start]) + if bool(hard_id_pred[start]): + if start_span == -1: + start_span = pos + last = pos + else: + if start_span != -1: + rationales["hard_rationale_predictions"].append( + { + "start_token": start_span, + "end_token": last + 1, + } + ) + last = -1 + start_span = -1 + if start_span != -1: + rationales["hard_rationale_predictions"].append( + { + "start_token": start_span, + "end_token": last + 1, + } + ) + + ann_id = id_data.ann_id + if use_cose_hack: + ann_id = "_".join(ann_id.split("_")[0:-1]) + soft_cls_preds = nn.functional.softmax(soft_cls_preds) + decoded[id_data.ann_id] = { + "annotation_id": ann_id, + "rationales": [rationales], + "classification": class_labels[hard_cls_pred], + "classification_scores": { + class_labels[i]: score.item() + for i, score in enumerate(soft_cls_preds) + }, + } + return results, list(decoded.values()) + + # test_results, test_decoded = dict(), [] + # val_results, val_decoded = dict(), [] + train_results, train_decoded = dict(), [] + val_results, val_decoded = decode_batch( + prep(val), "val", score=True, annotations=val, class_labels=class_labels + ) + test_results, test_decoded = decode_batch( + prep(test), "test", score=False, class_labels=class_labels + ) + # train_results, train_decoded = decode_batch(prep(train), 'train', score=True, annotations=train, class_labels=class_labels) + return ( + dict(**train_results, **val_results, **test_results), + train_decoded, + val_decoded, + test_decoded, + ) diff --git a/Transformer-Explainability/BERT_rationale_benchmark/models/sequence_taggers.py b/Transformer-Explainability/BERT_rationale_benchmark/models/sequence_taggers.py new file mode 100644 index 0000000000000000000000000000000000000000..c4f39981cf1092c7bba961bad665d2b718fff1b5 --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/models/sequence_taggers.py @@ -0,0 +1,78 @@ +from typing import Any, List, Tuple + +import torch +import torch.nn as nn +from rationale_benchmark.models.model_utils import PaddedSequence +from transformers import BertModel + + +class BertTagger(nn.Module): + def __init__( + self, + bert_dir: str, + pad_token_id: int, + cls_token_id: int, + sep_token_id: int, + max_length: int = 512, + use_half_precision=True, + ): + super(BertTagger, self).__init__() + self.sep_token_id = sep_token_id + self.cls_token_id = cls_token_id + self.pad_token_id = pad_token_id + self.max_length = max_length + bert = BertModel.from_pretrained(bert_dir) + if use_half_precision: + import apex + + bert = bert.half() + self.bert = bert + self.relevance_tagger = nn.Sequential( + nn.Linear(self.bert.config.hidden_size, 1), nn.Sigmoid() + ) + + def forward( + self, + query: List[torch.tensor], + docids: List[Any], + document_batch: List[torch.tensor], + aggregate_spans: List[Tuple[int, int]], + ): + assert len(query) == len(document_batch) + # note about device management: since distributed training is enabled, the inputs to this module can be on + # *any* device (preferably cpu, since we wrap and unwrap the module) we want to keep these params on the + # input device (assuming CPU) for as long as possible for cheap memory access + target_device = next(self.parameters()).device + # cls_token = torch.tensor([self.cls_token_id]).to(device=document_batch[0].device) + sep_token = torch.tensor([self.sep_token_id]).to( + device=document_batch[0].device + ) + input_tensors = [] + query_lengths = [] + for q, d in zip(query, document_batch): + if len(q) + len(d) + 1 > self.max_length: + d = d[: (self.max_length - len(q) - 1)] + input_tensors.append(torch.cat([q, sep_token, d])) + query_lengths.append(q.size()[0]) + bert_input = PaddedSequence.autopad( + input_tensors, + batch_first=True, + padding_value=self.pad_token_id, + device=target_device, + ) + outputs = self.bert( + bert_input.data, + attention_mask=bert_input.mask( + on=0.0, off=float("-inf"), dtype=torch.float, device=target_device + ), + ) + hidden = outputs[0] + classes = self.relevance_tagger(hidden) + ret = [] + for ql, cls, doc in zip(query_lengths, classes, document_batch): + start = ql + 1 + end = start + len(doc) + ret.append(cls[ql + 1 : end]) + return PaddedSequence.autopad( + ret, batch_first=True, padding_value=0, device=target_device + ).data.squeeze(dim=-1) diff --git a/Transformer-Explainability/BERT_rationale_benchmark/utils.py b/Transformer-Explainability/BERT_rationale_benchmark/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..84e35a2ec1c5310fb433b1278626f438cfc4a94d --- /dev/null +++ b/Transformer-Explainability/BERT_rationale_benchmark/utils.py @@ -0,0 +1,251 @@ +import json +import os +from dataclasses import asdict, dataclass, is_dataclass +from itertools import chain +from typing import Dict, FrozenSet, List, Set, Tuple, Union + + +@dataclass(eq=True, frozen=True) +class Evidence: + """ + (docid, start_token, end_token) form the only official Evidence; sentence level annotations are for convenience. + Args: + text: Some representation of the evidence text + docid: Some identifier for the document + start_token: The canonical start token, inclusive + end_token: The canonical end token, exclusive + start_sentence: Best guess start sentence, inclusive + end_sentence: Best guess end sentence, exclusive + """ + + text: Union[str, Tuple[int], Tuple[str]] + docid: str + start_token: int = -1 + end_token: int = -1 + start_sentence: int = -1 + end_sentence: int = -1 + + +@dataclass(eq=True, frozen=True) +class Annotation: + """ + Args: + annotation_id: unique ID for this annotation element + query: some representation of a query string + evidences: a set of "evidence groups". + Each evidence group is: + * sufficient to respond to the query (or justify an answer) + * composed of one or more Evidences + * may have multiple documents in it (depending on the dataset) + - e-snli has multiple documents + - other datasets do not + classification: str + query_type: Optional str, additional information about the query + docids: a set of docids in which one may find evidence. + """ + + annotation_id: str + query: Union[str, Tuple[int]] + evidences: Union[Set[Tuple[Evidence]], FrozenSet[Tuple[Evidence]]] + classification: str + query_type: str = None + docids: Set[str] = None + + def all_evidences(self) -> Tuple[Evidence]: + return tuple(list(chain.from_iterable(self.evidences))) + + +def annotations_to_jsonl(annotations, output_file): + with open(output_file, "w") as of: + for ann in sorted(annotations, key=lambda x: x.annotation_id): + as_json = _annotation_to_dict(ann) + as_str = json.dumps(as_json, sort_keys=True) + of.write(as_str) + of.write("\n") + + +def _annotation_to_dict(dc): + # convenience method + if is_dataclass(dc): + d = asdict(dc) + ret = dict() + for k, v in d.items(): + ret[k] = _annotation_to_dict(v) + return ret + elif isinstance(dc, dict): + ret = dict() + for k, v in dc.items(): + k = _annotation_to_dict(k) + v = _annotation_to_dict(v) + ret[k] = v + return ret + elif isinstance(dc, str): + return dc + elif isinstance(dc, (set, frozenset, list, tuple)): + ret = [] + for x in dc: + ret.append(_annotation_to_dict(x)) + return tuple(ret) + else: + return dc + + +def load_jsonl(fp: str) -> List[dict]: + ret = [] + with open(fp, "r") as inf: + for line in inf: + content = json.loads(line) + ret.append(content) + return ret + + +def write_jsonl(jsonl, output_file): + with open(output_file, "w") as of: + for js in jsonl: + as_str = json.dumps(js, sort_keys=True) + of.write(as_str) + of.write("\n") + + +def annotations_from_jsonl(fp: str) -> List[Annotation]: + ret = [] + with open(fp, "r") as inf: + for line in inf: + content = json.loads(line) + ev_groups = [] + for ev_group in content["evidences"]: + ev_group = tuple([Evidence(**ev) for ev in ev_group]) + ev_groups.append(ev_group) + content["evidences"] = frozenset(ev_groups) + ret.append(Annotation(**content)) + return ret + + +def load_datasets( + data_dir: str, +) -> Tuple[List[Annotation], List[Annotation], List[Annotation]]: + """Loads a training, validation, and test dataset + + Each dataset is assumed to have been serialized by annotations_to_jsonl, + that is it is a list of json-serialized Annotation instances. + """ + train_data = annotations_from_jsonl(os.path.join(data_dir, "train.jsonl")) + val_data = annotations_from_jsonl(os.path.join(data_dir, "val.jsonl")) + test_data = annotations_from_jsonl(os.path.join(data_dir, "test.jsonl")) + return train_data, val_data, test_data + + +def load_documents( + data_dir: str, docids: Set[str] = None +) -> Dict[str, List[List[str]]]: + """Loads a subset of available documents from disk. + + Each document is assumed to be serialized as newline ('\n') separated sentences. + Each sentence is assumed to be space (' ') joined tokens. + """ + if os.path.exists(os.path.join(data_dir, "docs.jsonl")): + assert not os.path.exists(os.path.join(data_dir, "docs")) + return load_documents_from_file(data_dir, docids) + + docs_dir = os.path.join(data_dir, "docs") + res = dict() + if docids is None: + docids = sorted(os.listdir(docs_dir)) + else: + docids = sorted(set(str(d) for d in docids)) + for d in docids: + with open(os.path.join(docs_dir, d), "r") as inf: + res[d] = inf.read() + return res + + +def load_flattened_documents(data_dir: str, docids: Set[str]) -> Dict[str, List[str]]: + """Loads a subset of available documents from disk. + + Returns a tokenized version of the document. + """ + unflattened_docs = load_documents(data_dir, docids) + flattened_docs = dict() + for doc, unflattened in unflattened_docs.items(): + flattened_docs[doc] = list(chain.from_iterable(unflattened)) + return flattened_docs + + +def intern_documents( + documents: Dict[str, List[List[str]]], word_interner: Dict[str, int], unk_token: str +): + """ + Replaces every word with its index in an embeddings file. + + If a word is not found, uses the unk_token instead + """ + ret = dict() + unk = word_interner[unk_token] + for docid, sentences in documents.items(): + ret[docid] = [[word_interner.get(w, unk) for w in s] for s in sentences] + return ret + + +def intern_annotations( + annotations: List[Annotation], word_interner: Dict[str, int], unk_token: str +): + ret = [] + for ann in annotations: + ev_groups = [] + for ev_group in ann.evidences: + evs = [] + for ev in ev_group: + evs.append( + Evidence( + text=tuple( + [ + word_interner.get(t, word_interner[unk_token]) + for t in ev.text.split() + ] + ), + docid=ev.docid, + start_token=ev.start_token, + end_token=ev.end_token, + start_sentence=ev.start_sentence, + end_sentence=ev.end_sentence, + ) + ) + ev_groups.append(tuple(evs)) + ret.append( + Annotation( + annotation_id=ann.annotation_id, + query=tuple( + [ + word_interner.get(t, word_interner[unk_token]) + for t in ann.query.split() + ] + ), + evidences=frozenset(ev_groups), + classification=ann.classification, + query_type=ann.query_type, + ) + ) + return ret + + +def load_documents_from_file( + data_dir: str, docids: Set[str] = None +) -> Dict[str, List[List[str]]]: + """Loads a subset of available documents from 'docs.jsonl' file on disk. + + Each document is assumed to be serialized as newline ('\n') separated sentences. + Each sentence is assumed to be space (' ') joined tokens. + """ + docs_file = os.path.join(data_dir, "docs.jsonl") + documents = load_jsonl(docs_file) + documents = {doc["docid"]: doc["document"] for doc in documents} + # res = dict() + # if docids is None: + # docids = sorted(list(documents.keys())) + # else: + # docids = sorted(set(str(d) for d in docids)) + # for d in docids: + # lines = documents[d].split('\n') + # tokenized = [line.strip().split(' ') for line in lines] + # res[d] = tokenized + return documents diff --git a/Transformer-Explainability/DeiT.PNG b/Transformer-Explainability/DeiT.PNG new file mode 100644 index 0000000000000000000000000000000000000000..92e796de840bfc44dc536c6ad5020d35c3495d15 Binary files /dev/null and b/Transformer-Explainability/DeiT.PNG differ diff --git a/Transformer-Explainability/DeiT_example.ipynb b/Transformer-Explainability/DeiT_example.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4ec611a6a8f6ba6e0ae38c4324fb37a45726abe3 --- /dev/null +++ b/Transformer-Explainability/DeiT_example.ipynb @@ -0,0 +1,345 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import numpy as np\n", + "import cv2\n", + "from samples.CLS2IDX import CLS2IDX" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auxiliary Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from baselines.ViT.ViT_LRP import deit_base_patch16_224 as vit_LRP\n", + "from baselines.ViT.ViT_explanation_generator import LRP\n", + "\n", + "normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " normalize,\n", + "])\n", + "\n", + "# create heatmap from mask on image\n", + "def show_cam_on_image(img, mask):\n", + " heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)\n", + " heatmap = np.float32(heatmap) / 255\n", + " cam = heatmap + np.float32(img)\n", + " cam = cam / np.max(cam)\n", + " return cam\n", + "\n", + "# initialize ViT pretrained with DeiT\n", + "model = vit_LRP(pretrained=True).cuda()\n", + "model.eval()\n", + "attribution_generator = LRP(model)\n", + "\n", + "def generate_visualization(original_image, class_index=None):\n", + " transformer_attribution = attribution_generator.generate_LRP(original_image.unsqueeze(0).cuda(), method=\"transformer_attribution\", index=class_index).detach()\n", + " transformer_attribution = transformer_attribution.reshape(1, 1, 14, 14)\n", + " transformer_attribution = torch.nn.functional.interpolate(transformer_attribution, scale_factor=16, mode='bilinear')\n", + " transformer_attribution = transformer_attribution.reshape(224, 224).cuda().data.cpu().numpy()\n", + " transformer_attribution = (transformer_attribution - transformer_attribution.min()) / (transformer_attribution.max() - transformer_attribution.min())\n", + " image_transformer_attribution = original_image.permute(1, 2, 0).data.cpu().numpy()\n", + " image_transformer_attribution = (image_transformer_attribution - image_transformer_attribution.min()) / (image_transformer_attribution.max() - image_transformer_attribution.min())\n", + " vis = show_cam_on_image(image_transformer_attribution, transformer_attribution)\n", + " vis = np.uint8(255 * vis)\n", + " vis = cv2.cvtColor(np.array(vis), cv2.COLOR_RGB2BGR)\n", + " return vis\n", + "\n", + "\n", + "def print_top_classes(predictions, **kwargs): \n", + " # Print Top-5 predictions\n", + " prob = torch.softmax(predictions, dim=1)\n", + " class_indices = predictions.data.topk(5, dim=1)[1][0].tolist()\n", + " max_str_len = 0\n", + " class_names = []\n", + " for cls_idx in class_indices:\n", + " class_names.append(CLS2IDX[cls_idx])\n", + " if len(CLS2IDX[cls_idx]) > max_str_len:\n", + " max_str_len = len(CLS2IDX[cls_idx])\n", + " \n", + " print('Top 5 classes:')\n", + " for cls_idx in class_indices:\n", + " output_string = '\\t{} : {}'.format(cls_idx, CLS2IDX[cls_idx])\n", + " output_string += ' ' * (max_str_len - len(CLS2IDX[cls_idx])) + '\\t\\t'\n", + " output_string += 'value = {:.3f}\\t prob = {:.1f}%'.format(predictions[0, cls_idx], 100 * prob[0, cls_idx])\n", + " print(output_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t243 : bull mastiff \t\tvalue = 5.992\t prob = 19.0%\n", + "\t282 : tiger cat \t\tvalue = 5.175\t prob = 8.4%\n", + "\t285 : Egyptian cat \t\tvalue = 4.781\t prob = 5.7%\n", + "\t281 : tabby, tabby cat\t\tvalue = 4.690\t prob = 5.2%\n", + "\t245 : French bulldog \t\tvalue = 2.991\t prob = 0.9%\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hila/anaconda3/envs/torch1.7/lib/python3.7/site-packages/torch/nn/functional.py:3063: UserWarning: Default upsampling behavior when mode=bilinear is changed to align_corners=False since 0.4.0. Please specify align_corners=True if the old behavior is desired. See the documentation of nn.Upsample for details.\n", + " \"See the documentation of nn.Upsample for details.\".format(mode))\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/catdog.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# dog \n", + "# generate visualization for class 243: 'bull mastiff' - the predicted class\n", + "dog = generate_visualization(dog_cat_image)\n", + "\n", + "# cat - generate visualization for class 282 : 'tiger cat'\n", + "cat = generate_visualization(dog_cat_image, class_index=282)\n", + "\n", + "\n", + "axs[1].imshow(dog);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(cat);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t161 : basset, basset hound \t\tvalue = 6.327\t prob = 26.5%\n", + "\t90 : lorikeet \t\tvalue = 4.394\t prob = 3.8%\n", + "\t88 : macaw \t\tvalue = 4.055\t prob = 2.7%\n", + "\t166 : Walker hound, Walker foxhound\t\tvalue = 3.394\t prob = 1.4%\n", + "\t163 : bloodhound, sleuthhound \t\tvalue = 3.352\t prob = 1.4%\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/dogbird.png')\n", + "dog_bird_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_bird_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# basset - the predicted class\n", + "basset = generate_visualization(dog_bird_image, class_index=161)\n", + "\n", + "# generate visualization for class 90: 'lorikeet'\n", + "parrot = generate_visualization(dog_bird_image, class_index=90)\n", + "\n", + "\n", + "axs[1].imshow(basset);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(parrot);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t340 : zebra \t\tvalue = 6.759\t prob = 32.7%\n", + "\t101 : tusker \t\tvalue = 5.557\t prob = 9.8%\n", + "\t386 : African elephant, Loxodonta africana\t\tvalue = 5.477\t prob = 9.1%\n", + "\t385 : Indian elephant, Elephas maximus \t\tvalue = 4.774\t prob = 4.5%\n", + "\t925 : consomme \t\tvalue = 2.237\t prob = 0.4%\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/el2.png')\n", + "tusker_zebra_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(tusker_zebra_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# zebra \n", + "# zebra- the predicted class\n", + "zebra = generate_visualization(tusker_zebra_image, class_index=340)\n", + "\n", + "# generate visualization for class 101: 'tusker'\n", + "tusker = generate_visualization(tusker_zebra_image, class_index=101)\n", + "\n", + "axs[1].imshow(zebra);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(tusker);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t207 : golden retriever \t\tvalue = 6.523\t prob = 35.7%\n", + "\t208 : Labrador retriever\t\tvalue = 4.288\t prob = 3.8%\n", + "\t285 : Egyptian cat \t\tvalue = 3.641\t prob = 2.0%\n", + "\t222 : kuvasz \t\tvalue = 3.422\t prob = 1.6%\n", + "\t281 : tabby, tabby cat \t\tvalue = 2.778\t prob = 0.8%\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/dogcat2.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# golden retriever - the predicted class\n", + "dog = generate_visualization(dog_cat_image)\n", + "\n", + "# generate visualization for class 285: 'Egyptian cat'\n", + "cat = generate_visualization(dog_cat_image, class_index=285)\n", + "\n", + "\n", + "axs[1].imshow(dog);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(cat);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch1.7", + "language": "python", + "name": "torch1.7" + }, + "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.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Transformer-Explainability/LICENSE b/Transformer-Explainability/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1ec1e3354606277df5cfda282968cd76b0f1844c --- /dev/null +++ b/Transformer-Explainability/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 Hila Chefer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Transformer-Explainability/README.md b/Transformer-Explainability/README.md new file mode 100644 index 0000000000000000000000000000000000000000..671f89c25351dc5b1b77edeca285f35d14a4fa0b --- /dev/null +++ b/Transformer-Explainability/README.md @@ -0,0 +1,153 @@ +# PyTorch Implementation of [Transformer Interpretability Beyond Attention Visualization](https://arxiv.org/abs/2012.09838) [CVPR 2021] + +#### Check out our new advancements- [Generic Attention-model Explainability for Interpreting Bi-Modal and Encoder-Decoder Transformers](https://github.com/hila-chefer/Transformer-MM-Explainability)! +Faster, more general, and can be applied to *any* type of attention! +Among the features: +* We remove LRP for a simple and quick solution, and prove that the great results from our first paper still hold! +* We expand our work to *any* type of Transformer- not just self-attention based encoders, but also co-attention encoders and encoder-decoders! +* We show that VQA models can actually understand both image and text and make connections! +* We use a DETR object detector and create segmentation masks from our explanations! +* We provide a colab notebook with all the examples. You can very easily add images and questions of your own! + +

+ +

+ +--- +## ViT explainability notebook: +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hila-chefer/Transformer-Explainability/blob/main/Transformer_explainability.ipynb) + +## BERT explainability notebook: +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hila-chefer/Transformer-Explainability/blob/main/BERT_explainability.ipynb) +--- + +## Updates +April 5 2021: Check out this new [post](https://analyticsindiamag.com/compute-relevancy-of-transformer-networks-via-novel-interpretable-transformer/) about our paper! A great resource for understanding the main concepts behind our work. + +March 15 2021: [A Colab notebook for BERT for sentiment analysis added!](https://colab.research.google.com/github/hila-chefer/Transformer-Explainability/blob/main/BERT_explainability.ipynb) + +Feb 28 2021: Our paper was accepted to CVPR 2021! + +Feb 17 2021: [A Colab notebook with all examples added!](https://github.com/hila-chefer/Transformer-Explainability/blob/main/Transformer_explainability.ipynb) + +Jan 5 2021: [A Jupyter notebook for DeiT added!](https://github.com/hila-chefer/Transformer-Explainability/blob/main/DeiT_example.ipynb) + + +

+ +

+ + +## Introduction +Official implementation of [Transformer Interpretability Beyond Attention Visualization](https://arxiv.org/abs/2012.09838). + +We introduce a novel method which allows to visualize classifications made by a Transformer based model for both vision and NLP tasks. +Our method also allows to visualize explanations per class. + +

+ +

+Method consists of 3 phases: + +1. Calculating relevance for each attention matrix using our novel formulation of LRP. + +2. Backpropagation of gradients for each attention matrix w.r.t. the visualized class. Gradients are used to average attention heads. + +3. Layer aggregation with rollout. + +Please notice our [Jupyter notebook](https://github.com/hila-chefer/Transformer-Explainability/blob/main/example.ipynb) where you can run the two class specific examples from the paper. + + +![alt text](https://github.com/hila-chefer/Transformer-Explainability/blob/main/example.PNG) + +To add another input image, simply add the image to the [samples folder](https://github.com/hila-chefer/Transformer-Explainability/tree/main/samples), and use the `generate_visualization` function for your selected class of interest (using the `class_index={class_idx}`), not specifying the index will visualize the top class. + +## Credits +ViT implementation is based on: +- https://github.com/rwightman/pytorch-image-models +- https://github.com/lucidrains/vit-pytorch +- pretrained weights from: https://github.com/google-research/vision_transformer + +BERT implementation is taken from the huggingface Transformers library: +https://huggingface.co/transformers/ + +ERASER benchmark code adapted from the ERASER GitHub implementation: https://github.com/jayded/eraserbenchmark + +Text visualizations in supplementary were created using TAHV heatmap generator for text: https://github.com/jiesutd/Text-Attention-Heatmap-Visualization + +## Reproducing results on ViT + +### Section A. Segmentation Results + +Example: +``` +CUDA_VISIBLE_DEVICES=0 PYTHONPATH=./:$PYTHONPATH python3 baselines/ViT/imagenet_seg_eval.py --method transformer_attribution --imagenet-seg-path /path/to/gtsegs_ijcv.mat + +``` +[Link to download dataset](http://calvin-vision.net/bigstuff/proj-imagenet/data/gtsegs_ijcv.mat). + +In the exmaple above we run a segmentation test with our method. Notice you can choose which method you wish to run using the `--method` argument. +You must provide a path to imagenet segmentation data in `--imagenet-seg-path`. + +### Section B. Perturbation Results + +Example: +``` +CUDA_VISIBLE_DEVICES=0 PYTHONPATH=./:$PYTHONPATH python3 baselines/ViT/generate_visualizations.py --method transformer_attribution --imagenet-validation-path /path/to/imagenet_validation_directory +``` + +Notice that you can choose to visualize by target or top class by using the `--vis-cls` argument. + +Now to run the perturbation test run the following command: +``` +CUDA_VISIBLE_DEVICES=0 PYTHONPATH=./:$PYTHONPATH python3 baselines/ViT/pertubation_eval_from_hdf5.py --method transformer_attribution +``` + +Notice that you can use the `--neg` argument to run either positive or negative perturbation. + +## Reproducing results on BERT + +1. Download the pretrained weights: + +- Download `classifier.zip` from https://drive.google.com/file/d/1kGMTr69UWWe70i-o2_JfjmWDQjT66xwQ/view?usp=sharing +- mkdir -p `./bert_models/movies` +- unzip classifier.zip -d ./bert_models/movies/ + +2. Download the dataset pkl file: + +- Download `preprocessed.pkl` from https://drive.google.com/file/d/1-gfbTj6D87KIm_u1QMHGLKSL3e93hxBH/view?usp=sharing +- mv preprocessed.pkl ./bert_models/movies + +3. Download the dataset: + +- Download `movies.zip` from https://drive.google.com/file/d/11faFLGkc0hkw3wrGTYJBr1nIvkRb189F/view?usp=sharing +- unzip movies.zip -d ./data/ + +4. Now you can run the model. + +Example: +``` +CUDA_VISIBLE_DEVICES=0 PYTHONPATH=./:$PYTHONPATH python3 BERT_rationale_benchmark/models/pipeline/bert_pipeline.py --data_dir data/movies/ --output_dir bert_models/movies/ --model_params BERT_params/movies_bert.json +``` +To control which algorithm to use for explanations change the `method` variable in `BERT_rationale_benchmark/models/pipeline/bert_pipeline.py` (Defaults to 'transformer_attribution' which is our method). +Running this command will create a directory for the method in `bert_models/movies/`. + +In order to run f1 test with k, run the following command: +``` +PYTHONPATH=./:$PYTHONPATH python3 BERT_rationale_benchmark/metrics.py --data_dir data/movies/ --split test --results bert_models/movies//identifier_results_k.json +``` + +Also, in the method directory there will be created `.tex` files containing the explanations extracted for each example. This corresponds to our visualizations in the supplementary. + +## Citing our paper +If you make use of our work, please cite our paper: +``` +@InProceedings{Chefer_2021_CVPR, + author = {Chefer, Hila and Gur, Shir and Wolf, Lior}, + title = {Transformer Interpretability Beyond Attention Visualization}, + booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {June}, + year = {2021}, + pages = {782-791} +} +``` diff --git a/Transformer-Explainability/Transformer_explainability.ipynb b/Transformer-Explainability/Transformer_explainability.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..921890a5e423d96dfe5aacd540df5af6653c7964 --- /dev/null +++ b/Transformer-Explainability/Transformer_explainability.ipynb @@ -0,0 +1,1661 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Transformer-explainability.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyOZAljZCH9K62jPH5tqgQlf", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zj6EnzRyAY5q" + }, + "source": [ + "# **Transformer Interpretability Beyond Attention Visualization**" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ej3H_oMmAx3C", + "outputId": "859266b9-ae95-4dc1-dfd9-44853e43855a" + }, + "source": [ + "!git clone https://github.com/hila-chefer/Transformer-Explainability.git\n", + "\n", + "import os\n", + "os.chdir(f'./Transformer-Explainability')\n", + "\n", + "!pip install einops" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fatal: destination path 'Transformer-Explainability' already exists and is not an empty directory.\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: einops in /usr/local/lib/python3.7/dist-packages (0.6.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IdJ4YOiTBtAz" + }, + "source": [ + "from PIL import Image\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import numpy as np\n", + "import cv2" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "cellView": "form", + "id": "TtqMdXdTEKAP" + }, + "source": [ + "#@title Imagenet class indices to names\n", + "%%capture\n", + "CLS2IDX = {0: 'tench, Tinca tinca',\n", + " 1: 'goldfish, Carassius auratus',\n", + " 2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias',\n", + " 3: 'tiger shark, Galeocerdo cuvieri',\n", + " 4: 'hammerhead, hammerhead shark',\n", + " 5: 'electric ray, crampfish, numbfish, torpedo',\n", + " 6: 'stingray',\n", + " 7: 'cock',\n", + " 8: 'hen',\n", + " 9: 'ostrich, Struthio camelus',\n", + " 10: 'brambling, Fringilla montifringilla',\n", + " 11: 'goldfinch, Carduelis carduelis',\n", + " 12: 'house finch, linnet, Carpodacus mexicanus',\n", + " 13: 'junco, snowbird',\n", + " 14: 'indigo bunting, indigo finch, indigo bird, Passerina cyanea',\n", + " 15: 'robin, American robin, Turdus migratorius',\n", + " 16: 'bulbul',\n", + " 17: 'jay',\n", + " 18: 'magpie',\n", + " 19: 'chickadee',\n", + " 20: 'water ouzel, dipper',\n", + " 21: 'kite',\n", + " 22: 'bald eagle, American eagle, Haliaeetus leucocephalus',\n", + " 23: 'vulture',\n", + " 24: 'great grey owl, great gray owl, Strix nebulosa',\n", + " 25: 'European fire salamander, Salamandra salamandra',\n", + " 26: 'common newt, Triturus vulgaris',\n", + " 27: 'eft',\n", + " 28: 'spotted salamander, Ambystoma maculatum',\n", + " 29: 'axolotl, mud puppy, Ambystoma mexicanum',\n", + " 30: 'bullfrog, Rana catesbeiana',\n", + " 31: 'tree frog, tree-frog',\n", + " 32: 'tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui',\n", + " 33: 'loggerhead, loggerhead turtle, Caretta caretta',\n", + " 34: 'leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea',\n", + " 35: 'mud turtle',\n", + " 36: 'terrapin',\n", + " 37: 'box turtle, box tortoise',\n", + " 38: 'banded gecko',\n", + " 39: 'common iguana, iguana, Iguana iguana',\n", + " 40: 'American chameleon, anole, Anolis carolinensis',\n", + " 41: 'whiptail, whiptail lizard',\n", + " 42: 'agama',\n", + " 43: 'frilled lizard, Chlamydosaurus kingi',\n", + " 44: 'alligator lizard',\n", + " 45: 'Gila monster, Heloderma suspectum',\n", + " 46: 'green lizard, Lacerta viridis',\n", + " 47: 'African chameleon, Chamaeleo chamaeleon',\n", + " 48: 'Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis',\n", + " 49: 'African crocodile, Nile crocodile, Crocodylus niloticus',\n", + " 50: 'American alligator, Alligator mississipiensis',\n", + " 51: 'triceratops',\n", + " 52: 'thunder snake, worm snake, Carphophis amoenus',\n", + " 53: 'ringneck snake, ring-necked snake, ring snake',\n", + " 54: 'hognose snake, puff adder, sand viper',\n", + " 55: 'green snake, grass snake',\n", + " 56: 'king snake, kingsnake',\n", + " 57: 'garter snake, grass snake',\n", + " 58: 'water snake',\n", + " 59: 'vine snake',\n", + " 60: 'night snake, Hypsiglena torquata',\n", + " 61: 'boa constrictor, Constrictor constrictor',\n", + " 62: 'rock python, rock snake, Python sebae',\n", + " 63: 'Indian cobra, Naja naja',\n", + " 64: 'green mamba',\n", + " 65: 'sea snake',\n", + " 66: 'horned viper, cerastes, sand viper, horned asp, Cerastes cornutus',\n", + " 67: 'diamondback, diamondback rattlesnake, Crotalus adamanteus',\n", + " 68: 'sidewinder, horned rattlesnake, Crotalus cerastes',\n", + " 69: 'trilobite',\n", + " 70: 'harvestman, daddy longlegs, Phalangium opilio',\n", + " 71: 'scorpion',\n", + " 72: 'black and gold garden spider, Argiope aurantia',\n", + " 73: 'barn spider, Araneus cavaticus',\n", + " 74: 'garden spider, Aranea diademata',\n", + " 75: 'black widow, Latrodectus mactans',\n", + " 76: 'tarantula',\n", + " 77: 'wolf spider, hunting spider',\n", + " 78: 'tick',\n", + " 79: 'centipede',\n", + " 80: 'black grouse',\n", + " 81: 'ptarmigan',\n", + " 82: 'ruffed grouse, partridge, Bonasa umbellus',\n", + " 83: 'prairie chicken, prairie grouse, prairie fowl',\n", + " 84: 'peacock',\n", + " 85: 'quail',\n", + " 86: 'partridge',\n", + " 87: 'African grey, African gray, Psittacus erithacus',\n", + " 88: 'macaw',\n", + " 89: 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita',\n", + " 90: 'lorikeet',\n", + " 91: 'coucal',\n", + " 92: 'bee eater',\n", + " 93: 'hornbill',\n", + " 94: 'hummingbird',\n", + " 95: 'jacamar',\n", + " 96: 'toucan',\n", + " 97: 'drake',\n", + " 98: 'red-breasted merganser, Mergus serrator',\n", + " 99: 'goose',\n", + " 100: 'black swan, Cygnus atratus',\n", + " 101: 'tusker',\n", + " 102: 'echidna, spiny anteater, anteater',\n", + " 103: 'platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus',\n", + " 104: 'wallaby, brush kangaroo',\n", + " 105: 'koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus',\n", + " 106: 'wombat',\n", + " 107: 'jellyfish',\n", + " 108: 'sea anemone, anemone',\n", + " 109: 'brain coral',\n", + " 110: 'flatworm, platyhelminth',\n", + " 111: 'nematode, nematode worm, roundworm',\n", + " 112: 'conch',\n", + " 113: 'snail',\n", + " 114: 'slug',\n", + " 115: 'sea slug, nudibranch',\n", + " 116: 'chiton, coat-of-mail shell, sea cradle, polyplacophore',\n", + " 117: 'chambered nautilus, pearly nautilus, nautilus',\n", + " 118: 'Dungeness crab, Cancer magister',\n", + " 119: 'rock crab, Cancer irroratus',\n", + " 120: 'fiddler crab',\n", + " 121: 'king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica',\n", + " 122: 'American lobster, Northern lobster, Maine lobster, Homarus americanus',\n", + " 123: 'spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish',\n", + " 124: 'crayfish, crawfish, crawdad, crawdaddy',\n", + " 125: 'hermit crab',\n", + " 126: 'isopod',\n", + " 127: 'white stork, Ciconia ciconia',\n", + " 128: 'black stork, Ciconia nigra',\n", + " 129: 'spoonbill',\n", + " 130: 'flamingo',\n", + " 131: 'little blue heron, Egretta caerulea',\n", + " 132: 'American egret, great white heron, Egretta albus',\n", + " 133: 'bittern',\n", + " 134: 'crane',\n", + " 135: 'limpkin, Aramus pictus',\n", + " 136: 'European gallinule, Porphyrio porphyrio',\n", + " 137: 'American coot, marsh hen, mud hen, water hen, Fulica americana',\n", + " 138: 'bustard',\n", + " 139: 'ruddy turnstone, Arenaria interpres',\n", + " 140: 'red-backed sandpiper, dunlin, Erolia alpina',\n", + " 141: 'redshank, Tringa totanus',\n", + " 142: 'dowitcher',\n", + " 143: 'oystercatcher, oyster catcher',\n", + " 144: 'pelican',\n", + " 145: 'king penguin, Aptenodytes patagonica',\n", + " 146: 'albatross, mollymawk',\n", + " 147: 'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus',\n", + " 148: 'killer whale, killer, orca, grampus, sea wolf, Orcinus orca',\n", + " 149: 'dugong, Dugong dugon',\n", + " 150: 'sea lion',\n", + " 151: 'Chihuahua',\n", + " 152: 'Japanese spaniel',\n", + " 153: 'Maltese dog, Maltese terrier, Maltese',\n", + " 154: 'Pekinese, Pekingese, Peke',\n", + " 155: 'Shih-Tzu',\n", + " 156: 'Blenheim spaniel',\n", + " 157: 'papillon',\n", + " 158: 'toy terrier',\n", + " 159: 'Rhodesian ridgeback',\n", + " 160: 'Afghan hound, Afghan',\n", + " 161: 'basset, basset hound',\n", + " 162: 'beagle',\n", + " 163: 'bloodhound, sleuthhound',\n", + " 164: 'bluetick',\n", + " 165: 'black-and-tan coonhound',\n", + " 166: 'Walker hound, Walker foxhound',\n", + " 167: 'English foxhound',\n", + " 168: 'redbone',\n", + " 169: 'borzoi, Russian wolfhound',\n", + " 170: 'Irish wolfhound',\n", + " 171: 'Italian greyhound',\n", + " 172: 'whippet',\n", + " 173: 'Ibizan hound, Ibizan Podenco',\n", + " 174: 'Norwegian elkhound, elkhound',\n", + " 175: 'otterhound, otter hound',\n", + " 176: 'Saluki, gazelle hound',\n", + " 177: 'Scottish deerhound, deerhound',\n", + " 178: 'Weimaraner',\n", + " 179: 'Staffordshire bullterrier, Staffordshire bull terrier',\n", + " 180: 'American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier',\n", + " 181: 'Bedlington terrier',\n", + " 182: 'Border terrier',\n", + " 183: 'Kerry blue terrier',\n", + " 184: 'Irish terrier',\n", + " 185: 'Norfolk terrier',\n", + " 186: 'Norwich terrier',\n", + " 187: 'Yorkshire terrier',\n", + " 188: 'wire-haired fox terrier',\n", + " 189: 'Lakeland terrier',\n", + " 190: 'Sealyham terrier, Sealyham',\n", + " 191: 'Airedale, Airedale terrier',\n", + " 192: 'cairn, cairn terrier',\n", + " 193: 'Australian terrier',\n", + " 194: 'Dandie Dinmont, Dandie Dinmont terrier',\n", + " 195: 'Boston bull, Boston terrier',\n", + " 196: 'miniature schnauzer',\n", + " 197: 'giant schnauzer',\n", + " 198: 'standard schnauzer',\n", + " 199: 'Scotch terrier, Scottish terrier, Scottie',\n", + " 200: 'Tibetan terrier, chrysanthemum dog',\n", + " 201: 'silky terrier, Sydney silky',\n", + " 202: 'soft-coated wheaten terrier',\n", + " 203: 'West Highland white terrier',\n", + " 204: 'Lhasa, Lhasa apso',\n", + " 205: 'flat-coated retriever',\n", + " 206: 'curly-coated retriever',\n", + " 207: 'golden retriever',\n", + " 208: 'Labrador retriever',\n", + " 209: 'Chesapeake Bay retriever',\n", + " 210: 'German short-haired pointer',\n", + " 211: 'vizsla, Hungarian pointer',\n", + " 212: 'English setter',\n", + " 213: 'Irish setter, red setter',\n", + " 214: 'Gordon setter',\n", + " 215: 'Brittany spaniel',\n", + " 216: 'clumber, clumber spaniel',\n", + " 217: 'English springer, English springer spaniel',\n", + " 218: 'Welsh springer spaniel',\n", + " 219: 'cocker spaniel, English cocker spaniel, cocker',\n", + " 220: 'Sussex spaniel',\n", + " 221: 'Irish water spaniel',\n", + " 222: 'kuvasz',\n", + " 223: 'schipperke',\n", + " 224: 'groenendael',\n", + " 225: 'malinois',\n", + " 226: 'briard',\n", + " 227: 'kelpie',\n", + " 228: 'komondor',\n", + " 229: 'Old English sheepdog, bobtail',\n", + " 230: 'Shetland sheepdog, Shetland sheep dog, Shetland',\n", + " 231: 'collie',\n", + " 232: 'Border collie',\n", + " 233: 'Bouvier des Flandres, Bouviers des Flandres',\n", + " 234: 'Rottweiler',\n", + " 235: 'German shepherd, German shepherd dog, German police dog, alsatian',\n", + " 236: 'Doberman, Doberman pinscher',\n", + " 237: 'miniature pinscher',\n", + " 238: 'Greater Swiss Mountain dog',\n", + " 239: 'Bernese mountain dog',\n", + " 240: 'Appenzeller',\n", + " 241: 'EntleBucher',\n", + " 242: 'boxer',\n", + " 243: 'bull mastiff',\n", + " 244: 'Tibetan mastiff',\n", + " 245: 'French bulldog',\n", + " 246: 'Great Dane',\n", + " 247: 'Saint Bernard, St Bernard',\n", + " 248: 'Eskimo dog, husky',\n", + " 249: 'malamute, malemute, Alaskan malamute',\n", + " 250: 'Siberian husky',\n", + " 251: 'dalmatian, coach dog, carriage dog',\n", + " 252: 'affenpinscher, monkey pinscher, monkey dog',\n", + " 253: 'basenji',\n", + " 254: 'pug, pug-dog',\n", + " 255: 'Leonberg',\n", + " 256: 'Newfoundland, Newfoundland dog',\n", + " 257: 'Great Pyrenees',\n", + " 258: 'Samoyed, Samoyede',\n", + " 259: 'Pomeranian',\n", + " 260: 'chow, chow chow',\n", + " 261: 'keeshond',\n", + " 262: 'Brabancon griffon',\n", + " 263: 'Pembroke, Pembroke Welsh corgi',\n", + " 264: 'Cardigan, Cardigan Welsh corgi',\n", + " 265: 'toy poodle',\n", + " 266: 'miniature poodle',\n", + " 267: 'standard poodle',\n", + " 268: 'Mexican hairless',\n", + " 269: 'timber wolf, grey wolf, gray wolf, Canis lupus',\n", + " 270: 'white wolf, Arctic wolf, Canis lupus tundrarum',\n", + " 271: 'red wolf, maned wolf, Canis rufus, Canis niger',\n", + " 272: 'coyote, prairie wolf, brush wolf, Canis latrans',\n", + " 273: 'dingo, warrigal, warragal, Canis dingo',\n", + " 274: 'dhole, Cuon alpinus',\n", + " 275: 'African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus',\n", + " 276: 'hyena, hyaena',\n", + " 277: 'red fox, Vulpes vulpes',\n", + " 278: 'kit fox, Vulpes macrotis',\n", + " 279: 'Arctic fox, white fox, Alopex lagopus',\n", + " 280: 'grey fox, gray fox, Urocyon cinereoargenteus',\n", + " 281: 'tabby, tabby cat',\n", + " 282: 'tiger cat',\n", + " 283: 'Persian cat',\n", + " 284: 'Siamese cat, Siamese',\n", + " 285: 'Egyptian cat',\n", + " 286: 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor',\n", + " 287: 'lynx, catamount',\n", + " 288: 'leopard, Panthera pardus',\n", + " 289: 'snow leopard, ounce, Panthera uncia',\n", + " 290: 'jaguar, panther, Panthera onca, Felis onca',\n", + " 291: 'lion, king of beasts, Panthera leo',\n", + " 292: 'tiger, Panthera tigris',\n", + " 293: 'cheetah, chetah, Acinonyx jubatus',\n", + " 294: 'brown bear, bruin, Ursus arctos',\n", + " 295: 'American black bear, black bear, Ursus americanus, Euarctos americanus',\n", + " 296: 'ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus',\n", + " 297: 'sloth bear, Melursus ursinus, Ursus ursinus',\n", + " 298: 'mongoose',\n", + " 299: 'meerkat, mierkat',\n", + " 300: 'tiger beetle',\n", + " 301: 'ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle',\n", + " 302: 'ground beetle, carabid beetle',\n", + " 303: 'long-horned beetle, longicorn, longicorn beetle',\n", + " 304: 'leaf beetle, chrysomelid',\n", + " 305: 'dung beetle',\n", + " 306: 'rhinoceros beetle',\n", + " 307: 'weevil',\n", + " 308: 'fly',\n", + " 309: 'bee',\n", + " 310: 'ant, emmet, pismire',\n", + " 311: 'grasshopper, hopper',\n", + " 312: 'cricket',\n", + " 313: 'walking stick, walkingstick, stick insect',\n", + " 314: 'cockroach, roach',\n", + " 315: 'mantis, mantid',\n", + " 316: 'cicada, cicala',\n", + " 317: 'leafhopper',\n", + " 318: 'lacewing, lacewing fly',\n", + " 319: \"dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk\",\n", + " 320: 'damselfly',\n", + " 321: 'admiral',\n", + " 322: 'ringlet, ringlet butterfly',\n", + " 323: 'monarch, monarch butterfly, milkweed butterfly, Danaus plexippus',\n", + " 324: 'cabbage butterfly',\n", + " 325: 'sulphur butterfly, sulfur butterfly',\n", + " 326: 'lycaenid, lycaenid butterfly',\n", + " 327: 'starfish, sea star',\n", + " 328: 'sea urchin',\n", + " 329: 'sea cucumber, holothurian',\n", + " 330: 'wood rabbit, cottontail, cottontail rabbit',\n", + " 331: 'hare',\n", + " 332: 'Angora, Angora rabbit',\n", + " 333: 'hamster',\n", + " 334: 'porcupine, hedgehog',\n", + " 335: 'fox squirrel, eastern fox squirrel, Sciurus niger',\n", + " 336: 'marmot',\n", + " 337: 'beaver',\n", + " 338: 'guinea pig, Cavia cobaya',\n", + " 339: 'sorrel',\n", + " 340: 'zebra',\n", + " 341: 'hog, pig, grunter, squealer, Sus scrofa',\n", + " 342: 'wild boar, boar, Sus scrofa',\n", + " 343: 'warthog',\n", + " 344: 'hippopotamus, hippo, river horse, Hippopotamus amphibius',\n", + " 345: 'ox',\n", + " 346: 'water buffalo, water ox, Asiatic buffalo, Bubalus bubalis',\n", + " 347: 'bison',\n", + " 348: 'ram, tup',\n", + " 349: 'bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis',\n", + " 350: 'ibex, Capra ibex',\n", + " 351: 'hartebeest',\n", + " 352: 'impala, Aepyceros melampus',\n", + " 353: 'gazelle',\n", + " 354: 'Arabian camel, dromedary, Camelus dromedarius',\n", + " 355: 'llama',\n", + " 356: 'weasel',\n", + " 357: 'mink',\n", + " 358: 'polecat, fitch, foulmart, foumart, Mustela putorius',\n", + " 359: 'black-footed ferret, ferret, Mustela nigripes',\n", + " 360: 'otter',\n", + " 361: 'skunk, polecat, wood pussy',\n", + " 362: 'badger',\n", + " 363: 'armadillo',\n", + " 364: 'three-toed sloth, ai, Bradypus tridactylus',\n", + " 365: 'orangutan, orang, orangutang, Pongo pygmaeus',\n", + " 366: 'gorilla, Gorilla gorilla',\n", + " 367: 'chimpanzee, chimp, Pan troglodytes',\n", + " 368: 'gibbon, Hylobates lar',\n", + " 369: 'siamang, Hylobates syndactylus, Symphalangus syndactylus',\n", + " 370: 'guenon, guenon monkey',\n", + " 371: 'patas, hussar monkey, Erythrocebus patas',\n", + " 372: 'baboon',\n", + " 373: 'macaque',\n", + " 374: 'langur',\n", + " 375: 'colobus, colobus monkey',\n", + " 376: 'proboscis monkey, Nasalis larvatus',\n", + " 377: 'marmoset',\n", + " 378: 'capuchin, ringtail, Cebus capucinus',\n", + " 379: 'howler monkey, howler',\n", + " 380: 'titi, titi monkey',\n", + " 381: 'spider monkey, Ateles geoffroyi',\n", + " 382: 'squirrel monkey, Saimiri sciureus',\n", + " 383: 'Madagascar cat, ring-tailed lemur, Lemur catta',\n", + " 384: 'indri, indris, Indri indri, Indri brevicaudatus',\n", + " 385: 'Indian elephant, Elephas maximus',\n", + " 386: 'African elephant, Loxodonta africana',\n", + " 387: 'lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens',\n", + " 388: 'giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca',\n", + " 389: 'barracouta, snoek',\n", + " 390: 'eel',\n", + " 391: 'coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch',\n", + " 392: 'rock beauty, Holocanthus tricolor',\n", + " 393: 'anemone fish',\n", + " 394: 'sturgeon',\n", + " 395: 'gar, garfish, garpike, billfish, Lepisosteus osseus',\n", + " 396: 'lionfish',\n", + " 397: 'puffer, pufferfish, blowfish, globefish',\n", + " 398: 'abacus',\n", + " 399: 'abaya',\n", + " 400: \"academic gown, academic robe, judge's robe\",\n", + " 401: 'accordion, piano accordion, squeeze box',\n", + " 402: 'acoustic guitar',\n", + " 403: 'aircraft carrier, carrier, flattop, attack aircraft carrier',\n", + " 404: 'airliner',\n", + " 405: 'airship, dirigible',\n", + " 406: 'altar',\n", + " 407: 'ambulance',\n", + " 408: 'amphibian, amphibious vehicle',\n", + " 409: 'analog clock',\n", + " 410: 'apiary, bee house',\n", + " 411: 'apron',\n", + " 412: 'ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin',\n", + " 413: 'assault rifle, assault gun',\n", + " 414: 'backpack, back pack, knapsack, packsack, rucksack, haversack',\n", + " 415: 'bakery, bakeshop, bakehouse',\n", + " 416: 'balance beam, beam',\n", + " 417: 'balloon',\n", + " 418: 'ballpoint, ballpoint pen, ballpen, Biro',\n", + " 419: 'Band Aid',\n", + " 420: 'banjo',\n", + " 421: 'bannister, banister, balustrade, balusters, handrail',\n", + " 422: 'barbell',\n", + " 423: 'barber chair',\n", + " 424: 'barbershop',\n", + " 425: 'barn',\n", + " 426: 'barometer',\n", + " 427: 'barrel, cask',\n", + " 428: 'barrow, garden cart, lawn cart, wheelbarrow',\n", + " 429: 'baseball',\n", + " 430: 'basketball',\n", + " 431: 'bassinet',\n", + " 432: 'bassoon',\n", + " 433: 'bathing cap, swimming cap',\n", + " 434: 'bath towel',\n", + " 435: 'bathtub, bathing tub, bath, tub',\n", + " 436: 'beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon',\n", + " 437: 'beacon, lighthouse, beacon light, pharos',\n", + " 438: 'beaker',\n", + " 439: 'bearskin, busby, shako',\n", + " 440: 'beer bottle',\n", + " 441: 'beer glass',\n", + " 442: 'bell cote, bell cot',\n", + " 443: 'bib',\n", + " 444: 'bicycle-built-for-two, tandem bicycle, tandem',\n", + " 445: 'bikini, two-piece',\n", + " 446: 'binder, ring-binder',\n", + " 447: 'binoculars, field glasses, opera glasses',\n", + " 448: 'birdhouse',\n", + " 449: 'boathouse',\n", + " 450: 'bobsled, bobsleigh, bob',\n", + " 451: 'bolo tie, bolo, bola tie, bola',\n", + " 452: 'bonnet, poke bonnet',\n", + " 453: 'bookcase',\n", + " 454: 'bookshop, bookstore, bookstall',\n", + " 455: 'bottlecap',\n", + " 456: 'bow',\n", + " 457: 'bow tie, bow-tie, bowtie',\n", + " 458: 'brass, memorial tablet, plaque',\n", + " 459: 'brassiere, bra, bandeau',\n", + " 460: 'breakwater, groin, groyne, mole, bulwark, seawall, jetty',\n", + " 461: 'breastplate, aegis, egis',\n", + " 462: 'broom',\n", + " 463: 'bucket, pail',\n", + " 464: 'buckle',\n", + " 465: 'bulletproof vest',\n", + " 466: 'bullet train, bullet',\n", + " 467: 'butcher shop, meat market',\n", + " 468: 'cab, hack, taxi, taxicab',\n", + " 469: 'caldron, cauldron',\n", + " 470: 'candle, taper, wax light',\n", + " 471: 'cannon',\n", + " 472: 'canoe',\n", + " 473: 'can opener, tin opener',\n", + " 474: 'cardigan',\n", + " 475: 'car mirror',\n", + " 476: 'carousel, carrousel, merry-go-round, roundabout, whirligig',\n", + " 477: \"carpenter's kit, tool kit\",\n", + " 478: 'carton',\n", + " 479: 'car wheel',\n", + " 480: 'cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM',\n", + " 481: 'cassette',\n", + " 482: 'cassette player',\n", + " 483: 'castle',\n", + " 484: 'catamaran',\n", + " 485: 'CD player',\n", + " 486: 'cello, violoncello',\n", + " 487: 'cellular telephone, cellular phone, cellphone, cell, mobile phone',\n", + " 488: 'chain',\n", + " 489: 'chainlink fence',\n", + " 490: 'chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour',\n", + " 491: 'chain saw, chainsaw',\n", + " 492: 'chest',\n", + " 493: 'chiffonier, commode',\n", + " 494: 'chime, bell, gong',\n", + " 495: 'china cabinet, china closet',\n", + " 496: 'Christmas stocking',\n", + " 497: 'church, church building',\n", + " 498: 'cinema, movie theater, movie theatre, movie house, picture palace',\n", + " 499: 'cleaver, meat cleaver, chopper',\n", + " 500: 'cliff dwelling',\n", + " 501: 'cloak',\n", + " 502: 'clog, geta, patten, sabot',\n", + " 503: 'cocktail shaker',\n", + " 504: 'coffee mug',\n", + " 505: 'coffeepot',\n", + " 506: 'coil, spiral, volute, whorl, helix',\n", + " 507: 'combination lock',\n", + " 508: 'computer keyboard, keypad',\n", + " 509: 'confectionery, confectionary, candy store',\n", + " 510: 'container ship, containership, container vessel',\n", + " 511: 'convertible',\n", + " 512: 'corkscrew, bottle screw',\n", + " 513: 'cornet, horn, trumpet, trump',\n", + " 514: 'cowboy boot',\n", + " 515: 'cowboy hat, ten-gallon hat',\n", + " 516: 'cradle',\n", + " 517: 'crane',\n", + " 518: 'crash helmet',\n", + " 519: 'crate',\n", + " 520: 'crib, cot',\n", + " 521: 'Crock Pot',\n", + " 522: 'croquet ball',\n", + " 523: 'crutch',\n", + " 524: 'cuirass',\n", + " 525: 'dam, dike, dyke',\n", + " 526: 'desk',\n", + " 527: 'desktop computer',\n", + " 528: 'dial telephone, dial phone',\n", + " 529: 'diaper, nappy, napkin',\n", + " 530: 'digital clock',\n", + " 531: 'digital watch',\n", + " 532: 'dining table, board',\n", + " 533: 'dishrag, dishcloth',\n", + " 534: 'dishwasher, dish washer, dishwashing machine',\n", + " 535: 'disk brake, disc brake',\n", + " 536: 'dock, dockage, docking facility',\n", + " 537: 'dogsled, dog sled, dog sleigh',\n", + " 538: 'dome',\n", + " 539: 'doormat, welcome mat',\n", + " 540: 'drilling platform, offshore rig',\n", + " 541: 'drum, membranophone, tympan',\n", + " 542: 'drumstick',\n", + " 543: 'dumbbell',\n", + " 544: 'Dutch oven',\n", + " 545: 'electric fan, blower',\n", + " 546: 'electric guitar',\n", + " 547: 'electric locomotive',\n", + " 548: 'entertainment center',\n", + " 549: 'envelope',\n", + " 550: 'espresso maker',\n", + " 551: 'face powder',\n", + " 552: 'feather boa, boa',\n", + " 553: 'file, file cabinet, filing cabinet',\n", + " 554: 'fireboat',\n", + " 555: 'fire engine, fire truck',\n", + " 556: 'fire screen, fireguard',\n", + " 557: 'flagpole, flagstaff',\n", + " 558: 'flute, transverse flute',\n", + " 559: 'folding chair',\n", + " 560: 'football helmet',\n", + " 561: 'forklift',\n", + " 562: 'fountain',\n", + " 563: 'fountain pen',\n", + " 564: 'four-poster',\n", + " 565: 'freight car',\n", + " 566: 'French horn, horn',\n", + " 567: 'frying pan, frypan, skillet',\n", + " 568: 'fur coat',\n", + " 569: 'garbage truck, dustcart',\n", + " 570: 'gasmask, respirator, gas helmet',\n", + " 571: 'gas pump, gasoline pump, petrol pump, island dispenser',\n", + " 572: 'goblet',\n", + " 573: 'go-kart',\n", + " 574: 'golf ball',\n", + " 575: 'golfcart, golf cart',\n", + " 576: 'gondola',\n", + " 577: 'gong, tam-tam',\n", + " 578: 'gown',\n", + " 579: 'grand piano, grand',\n", + " 580: 'greenhouse, nursery, glasshouse',\n", + " 581: 'grille, radiator grille',\n", + " 582: 'grocery store, grocery, food market, market',\n", + " 583: 'guillotine',\n", + " 584: 'hair slide',\n", + " 585: 'hair spray',\n", + " 586: 'half track',\n", + " 587: 'hammer',\n", + " 588: 'hamper',\n", + " 589: 'hand blower, blow dryer, blow drier, hair dryer, hair drier',\n", + " 590: 'hand-held computer, hand-held microcomputer',\n", + " 591: 'handkerchief, hankie, hanky, hankey',\n", + " 592: 'hard disc, hard disk, fixed disk',\n", + " 593: 'harmonica, mouth organ, harp, mouth harp',\n", + " 594: 'harp',\n", + " 595: 'harvester, reaper',\n", + " 596: 'hatchet',\n", + " 597: 'holster',\n", + " 598: 'home theater, home theatre',\n", + " 599: 'honeycomb',\n", + " 600: 'hook, claw',\n", + " 601: 'hoopskirt, crinoline',\n", + " 602: 'horizontal bar, high bar',\n", + " 603: 'horse cart, horse-cart',\n", + " 604: 'hourglass',\n", + " 605: 'iPod',\n", + " 606: 'iron, smoothing iron',\n", + " 607: \"jack-o'-lantern\",\n", + " 608: 'jean, blue jean, denim',\n", + " 609: 'jeep, landrover',\n", + " 610: 'jersey, T-shirt, tee shirt',\n", + " 611: 'jigsaw puzzle',\n", + " 612: 'jinrikisha, ricksha, rickshaw',\n", + " 613: 'joystick',\n", + " 614: 'kimono',\n", + " 615: 'knee pad',\n", + " 616: 'knot',\n", + " 617: 'lab coat, laboratory coat',\n", + " 618: 'ladle',\n", + " 619: 'lampshade, lamp shade',\n", + " 620: 'laptop, laptop computer',\n", + " 621: 'lawn mower, mower',\n", + " 622: 'lens cap, lens cover',\n", + " 623: 'letter opener, paper knife, paperknife',\n", + " 624: 'library',\n", + " 625: 'lifeboat',\n", + " 626: 'lighter, light, igniter, ignitor',\n", + " 627: 'limousine, limo',\n", + " 628: 'liner, ocean liner',\n", + " 629: 'lipstick, lip rouge',\n", + " 630: 'Loafer',\n", + " 631: 'lotion',\n", + " 632: 'loudspeaker, speaker, speaker unit, loudspeaker system, speaker system',\n", + " 633: \"loupe, jeweler's loupe\",\n", + " 634: 'lumbermill, sawmill',\n", + " 635: 'magnetic compass',\n", + " 636: 'mailbag, postbag',\n", + " 637: 'mailbox, letter box',\n", + " 638: 'maillot',\n", + " 639: 'maillot, tank suit',\n", + " 640: 'manhole cover',\n", + " 641: 'maraca',\n", + " 642: 'marimba, xylophone',\n", + " 643: 'mask',\n", + " 644: 'matchstick',\n", + " 645: 'maypole',\n", + " 646: 'maze, labyrinth',\n", + " 647: 'measuring cup',\n", + " 648: 'medicine chest, medicine cabinet',\n", + " 649: 'megalith, megalithic structure',\n", + " 650: 'microphone, mike',\n", + " 651: 'microwave, microwave oven',\n", + " 652: 'military uniform',\n", + " 653: 'milk can',\n", + " 654: 'minibus',\n", + " 655: 'miniskirt, mini',\n", + " 656: 'minivan',\n", + " 657: 'missile',\n", + " 658: 'mitten',\n", + " 659: 'mixing bowl',\n", + " 660: 'mobile home, manufactured home',\n", + " 661: 'Model T',\n", + " 662: 'modem',\n", + " 663: 'monastery',\n", + " 664: 'monitor',\n", + " 665: 'moped',\n", + " 666: 'mortar',\n", + " 667: 'mortarboard',\n", + " 668: 'mosque',\n", + " 669: 'mosquito net',\n", + " 670: 'motor scooter, scooter',\n", + " 671: 'mountain bike, all-terrain bike, off-roader',\n", + " 672: 'mountain tent',\n", + " 673: 'mouse, computer mouse',\n", + " 674: 'mousetrap',\n", + " 675: 'moving van',\n", + " 676: 'muzzle',\n", + " 677: 'nail',\n", + " 678: 'neck brace',\n", + " 679: 'necklace',\n", + " 680: 'nipple',\n", + " 681: 'notebook, notebook computer',\n", + " 682: 'obelisk',\n", + " 683: 'oboe, hautboy, hautbois',\n", + " 684: 'ocarina, sweet potato',\n", + " 685: 'odometer, hodometer, mileometer, milometer',\n", + " 686: 'oil filter',\n", + " 687: 'organ, pipe organ',\n", + " 688: 'oscilloscope, scope, cathode-ray oscilloscope, CRO',\n", + " 689: 'overskirt',\n", + " 690: 'oxcart',\n", + " 691: 'oxygen mask',\n", + " 692: 'packet',\n", + " 693: 'paddle, boat paddle',\n", + " 694: 'paddlewheel, paddle wheel',\n", + " 695: 'padlock',\n", + " 696: 'paintbrush',\n", + " 697: \"pajama, pyjama, pj's, jammies\",\n", + " 698: 'palace',\n", + " 699: 'panpipe, pandean pipe, syrinx',\n", + " 700: 'paper towel',\n", + " 701: 'parachute, chute',\n", + " 702: 'parallel bars, bars',\n", + " 703: 'park bench',\n", + " 704: 'parking meter',\n", + " 705: 'passenger car, coach, carriage',\n", + " 706: 'patio, terrace',\n", + " 707: 'pay-phone, pay-station',\n", + " 708: 'pedestal, plinth, footstall',\n", + " 709: 'pencil box, pencil case',\n", + " 710: 'pencil sharpener',\n", + " 711: 'perfume, essence',\n", + " 712: 'Petri dish',\n", + " 713: 'photocopier',\n", + " 714: 'pick, plectrum, plectron',\n", + " 715: 'pickelhaube',\n", + " 716: 'picket fence, paling',\n", + " 717: 'pickup, pickup truck',\n", + " 718: 'pier',\n", + " 719: 'piggy bank, penny bank',\n", + " 720: 'pill bottle',\n", + " 721: 'pillow',\n", + " 722: 'ping-pong ball',\n", + " 723: 'pinwheel',\n", + " 724: 'pirate, pirate ship',\n", + " 725: 'pitcher, ewer',\n", + " 726: \"plane, carpenter's plane, woodworking plane\",\n", + " 727: 'planetarium',\n", + " 728: 'plastic bag',\n", + " 729: 'plate rack',\n", + " 730: 'plow, plough',\n", + " 731: \"plunger, plumber's helper\",\n", + " 732: 'Polaroid camera, Polaroid Land camera',\n", + " 733: 'pole',\n", + " 734: 'police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria',\n", + " 735: 'poncho',\n", + " 736: 'pool table, billiard table, snooker table',\n", + " 737: 'pop bottle, soda bottle',\n", + " 738: 'pot, flowerpot',\n", + " 739: \"potter's wheel\",\n", + " 740: 'power drill',\n", + " 741: 'prayer rug, prayer mat',\n", + " 742: 'printer',\n", + " 743: 'prison, prison house',\n", + " 744: 'projectile, missile',\n", + " 745: 'projector',\n", + " 746: 'puck, hockey puck',\n", + " 747: 'punching bag, punch bag, punching ball, punchball',\n", + " 748: 'purse',\n", + " 749: 'quill, quill pen',\n", + " 750: 'quilt, comforter, comfort, puff',\n", + " 751: 'racer, race car, racing car',\n", + " 752: 'racket, racquet',\n", + " 753: 'radiator',\n", + " 754: 'radio, wireless',\n", + " 755: 'radio telescope, radio reflector',\n", + " 756: 'rain barrel',\n", + " 757: 'recreational vehicle, RV, R.V.',\n", + " 758: 'reel',\n", + " 759: 'reflex camera',\n", + " 760: 'refrigerator, icebox',\n", + " 761: 'remote control, remote',\n", + " 762: 'restaurant, eating house, eating place, eatery',\n", + " 763: 'revolver, six-gun, six-shooter',\n", + " 764: 'rifle',\n", + " 765: 'rocking chair, rocker',\n", + " 766: 'rotisserie',\n", + " 767: 'rubber eraser, rubber, pencil eraser',\n", + " 768: 'rugby ball',\n", + " 769: 'rule, ruler',\n", + " 770: 'running shoe',\n", + " 771: 'safe',\n", + " 772: 'safety pin',\n", + " 773: 'saltshaker, salt shaker',\n", + " 774: 'sandal',\n", + " 775: 'sarong',\n", + " 776: 'sax, saxophone',\n", + " 777: 'scabbard',\n", + " 778: 'scale, weighing machine',\n", + " 779: 'school bus',\n", + " 780: 'schooner',\n", + " 781: 'scoreboard',\n", + " 782: 'screen, CRT screen',\n", + " 783: 'screw',\n", + " 784: 'screwdriver',\n", + " 785: 'seat belt, seatbelt',\n", + " 786: 'sewing machine',\n", + " 787: 'shield, buckler',\n", + " 788: 'shoe shop, shoe-shop, shoe store',\n", + " 789: 'shoji',\n", + " 790: 'shopping basket',\n", + " 791: 'shopping cart',\n", + " 792: 'shovel',\n", + " 793: 'shower cap',\n", + " 794: 'shower curtain',\n", + " 795: 'ski',\n", + " 796: 'ski mask',\n", + " 797: 'sleeping bag',\n", + " 798: 'slide rule, slipstick',\n", + " 799: 'sliding door',\n", + " 800: 'slot, one-armed bandit',\n", + " 801: 'snorkel',\n", + " 802: 'snowmobile',\n", + " 803: 'snowplow, snowplough',\n", + " 804: 'soap dispenser',\n", + " 805: 'soccer ball',\n", + " 806: 'sock',\n", + " 807: 'solar dish, solar collector, solar furnace',\n", + " 808: 'sombrero',\n", + " 809: 'soup bowl',\n", + " 810: 'space bar',\n", + " 811: 'space heater',\n", + " 812: 'space shuttle',\n", + " 813: 'spatula',\n", + " 814: 'speedboat',\n", + " 815: \"spider web, spider's web\",\n", + " 816: 'spindle',\n", + " 817: 'sports car, sport car',\n", + " 818: 'spotlight, spot',\n", + " 819: 'stage',\n", + " 820: 'steam locomotive',\n", + " 821: 'steel arch bridge',\n", + " 822: 'steel drum',\n", + " 823: 'stethoscope',\n", + " 824: 'stole',\n", + " 825: 'stone wall',\n", + " 826: 'stopwatch, stop watch',\n", + " 827: 'stove',\n", + " 828: 'strainer',\n", + " 829: 'streetcar, tram, tramcar, trolley, trolley car',\n", + " 830: 'stretcher',\n", + " 831: 'studio couch, day bed',\n", + " 832: 'stupa, tope',\n", + " 833: 'submarine, pigboat, sub, U-boat',\n", + " 834: 'suit, suit of clothes',\n", + " 835: 'sundial',\n", + " 836: 'sunglass',\n", + " 837: 'sunglasses, dark glasses, shades',\n", + " 838: 'sunscreen, sunblock, sun blocker',\n", + " 839: 'suspension bridge',\n", + " 840: 'swab, swob, mop',\n", + " 841: 'sweatshirt',\n", + " 842: 'swimming trunks, bathing trunks',\n", + " 843: 'swing',\n", + " 844: 'switch, electric switch, electrical switch',\n", + " 845: 'syringe',\n", + " 846: 'table lamp',\n", + " 847: 'tank, army tank, armored combat vehicle, armoured combat vehicle',\n", + " 848: 'tape player',\n", + " 849: 'teapot',\n", + " 850: 'teddy, teddy bear',\n", + " 851: 'television, television system',\n", + " 852: 'tennis ball',\n", + " 853: 'thatch, thatched roof',\n", + " 854: 'theater curtain, theatre curtain',\n", + " 855: 'thimble',\n", + " 856: 'thresher, thrasher, threshing machine',\n", + " 857: 'throne',\n", + " 858: 'tile roof',\n", + " 859: 'toaster',\n", + " 860: 'tobacco shop, tobacconist shop, tobacconist',\n", + " 861: 'toilet seat',\n", + " 862: 'torch',\n", + " 863: 'totem pole',\n", + " 864: 'tow truck, tow car, wrecker',\n", + " 865: 'toyshop',\n", + " 866: 'tractor',\n", + " 867: 'trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi',\n", + " 868: 'tray',\n", + " 869: 'trench coat',\n", + " 870: 'tricycle, trike, velocipede',\n", + " 871: 'trimaran',\n", + " 872: 'tripod',\n", + " 873: 'triumphal arch',\n", + " 874: 'trolleybus, trolley coach, trackless trolley',\n", + " 875: 'trombone',\n", + " 876: 'tub, vat',\n", + " 877: 'turnstile',\n", + " 878: 'typewriter keyboard',\n", + " 879: 'umbrella',\n", + " 880: 'unicycle, monocycle',\n", + " 881: 'upright, upright piano',\n", + " 882: 'vacuum, vacuum cleaner',\n", + " 883: 'vase',\n", + " 884: 'vault',\n", + " 885: 'velvet',\n", + " 886: 'vending machine',\n", + " 887: 'vestment',\n", + " 888: 'viaduct',\n", + " 889: 'violin, fiddle',\n", + " 890: 'volleyball',\n", + " 891: 'waffle iron',\n", + " 892: 'wall clock',\n", + " 893: 'wallet, billfold, notecase, pocketbook',\n", + " 894: 'wardrobe, closet, press',\n", + " 895: 'warplane, military plane',\n", + " 896: 'washbasin, handbasin, washbowl, lavabo, wash-hand basin',\n", + " 897: 'washer, automatic washer, washing machine',\n", + " 898: 'water bottle',\n", + " 899: 'water jug',\n", + " 900: 'water tower',\n", + " 901: 'whiskey jug',\n", + " 902: 'whistle',\n", + " 903: 'wig',\n", + " 904: 'window screen',\n", + " 905: 'window shade',\n", + " 906: 'Windsor tie',\n", + " 907: 'wine bottle',\n", + " 908: 'wing',\n", + " 909: 'wok',\n", + " 910: 'wooden spoon',\n", + " 911: 'wool, woolen, woollen',\n", + " 912: 'worm fence, snake fence, snake-rail fence, Virginia fence',\n", + " 913: 'wreck',\n", + " 914: 'yawl',\n", + " 915: 'yurt',\n", + " 916: 'web site, website, internet site, site',\n", + " 917: 'comic book',\n", + " 918: 'crossword puzzle, crossword',\n", + " 919: 'street sign',\n", + " 920: 'traffic light, traffic signal, stoplight',\n", + " 921: 'book jacket, dust cover, dust jacket, dust wrapper',\n", + " 922: 'menu',\n", + " 923: 'plate',\n", + " 924: 'guacamole',\n", + " 925: 'consomme',\n", + " 926: 'hot pot, hotpot',\n", + " 927: 'trifle',\n", + " 928: 'ice cream, icecream',\n", + " 929: 'ice lolly, lolly, lollipop, popsicle',\n", + " 930: 'French loaf',\n", + " 931: 'bagel, beigel',\n", + " 932: 'pretzel',\n", + " 933: 'cheeseburger',\n", + " 934: 'hotdog, hot dog, red hot',\n", + " 935: 'mashed potato',\n", + " 936: 'head cabbage',\n", + " 937: 'broccoli',\n", + " 938: 'cauliflower',\n", + " 939: 'zucchini, courgette',\n", + " 940: 'spaghetti squash',\n", + " 941: 'acorn squash',\n", + " 942: 'butternut squash',\n", + " 943: 'cucumber, cuke',\n", + " 944: 'artichoke, globe artichoke',\n", + " 945: 'bell pepper',\n", + " 946: 'cardoon',\n", + " 947: 'mushroom',\n", + " 948: 'Granny Smith',\n", + " 949: 'strawberry',\n", + " 950: 'orange',\n", + " 951: 'lemon',\n", + " 952: 'fig',\n", + " 953: 'pineapple, ananas',\n", + " 954: 'banana',\n", + " 955: 'jackfruit, jak, jack',\n", + " 956: 'custard apple',\n", + " 957: 'pomegranate',\n", + " 958: 'hay',\n", + " 959: 'carbonara',\n", + " 960: 'chocolate sauce, chocolate syrup',\n", + " 961: 'dough',\n", + " 962: 'meat loaf, meatloaf',\n", + " 963: 'pizza, pizza pie',\n", + " 964: 'potpie',\n", + " 965: 'burrito',\n", + " 966: 'red wine',\n", + " 967: 'espresso',\n", + " 968: 'cup',\n", + " 969: 'eggnog',\n", + " 970: 'alp',\n", + " 971: 'bubble',\n", + " 972: 'cliff, drop, drop-off',\n", + " 973: 'coral reef',\n", + " 974: 'geyser',\n", + " 975: 'lakeside, lakeshore',\n", + " 976: 'promontory, headland, head, foreland',\n", + " 977: 'sandbar, sand bar',\n", + " 978: 'seashore, coast, seacoast, sea-coast',\n", + " 979: 'valley, vale',\n", + " 980: 'volcano',\n", + " 981: 'ballplayer, baseball player',\n", + " 982: 'groom, bridegroom',\n", + " 983: 'scuba diver',\n", + " 984: 'rapeseed',\n", + " 985: 'daisy',\n", + " 986: \"yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum\",\n", + " 987: 'corn',\n", + " 988: 'acorn',\n", + " 989: 'hip, rose hip, rosehip',\n", + " 990: 'buckeye, horse chestnut, conker',\n", + " 991: 'coral fungus',\n", + " 992: 'agaric',\n", + " 993: 'gyromitra',\n", + " 994: 'stinkhorn, carrion fungus',\n", + " 995: 'earthstar',\n", + " 996: 'hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa',\n", + " 997: 'bolete',\n", + " 998: 'ear, spike, capitulum',\n", + " 999: 'toilet tissue, toilet paper, bathroom tissue'}" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Perform thresholding on the relevance (using Otsu's method)\n", + "#@title Number of layers for image Transformer\n", + "use_thresholding = False#@param {type:\"boolean\"}" + ], + "metadata": { + "cellView": "form", + "id": "IDKqZyCG3rmS" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2jXDQpLLFJBP" + }, + "source": [ + "# **ViT examples**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "UtHosD9lCgAA" + }, + "source": [ + "from baselines.ViT.ViT_LRP import vit_base_patch16_224 as vit_LRP\n", + "from baselines.ViT.ViT_explanation_generator import LRP\n", + "\n", + "normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n", + "transform = transforms.Compose([\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " normalize,\n", + "])\n", + "\n", + "# create heatmap from mask on image\n", + "def show_cam_on_image(img, mask):\n", + " heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)\n", + " heatmap = np.float32(heatmap) / 255\n", + " cam = heatmap + np.float32(img)\n", + " cam = cam / np.max(cam)\n", + " return cam\n", + "\n", + "# initialize ViT pretrained\n", + "model = vit_LRP(pretrained=True).cuda()\n", + "model.eval()\n", + "attribution_generator = LRP(model)\n", + "\n", + "def generate_visualization(original_image, class_index=None):\n", + " transformer_attribution = attribution_generator.generate_LRP(original_image.unsqueeze(0).cuda(), method=\"transformer_attribution\", index=class_index).detach()\n", + " transformer_attribution = transformer_attribution.reshape(1, 1, 14, 14)\n", + " transformer_attribution = torch.nn.functional.interpolate(transformer_attribution, scale_factor=16, mode='bilinear')\n", + " transformer_attribution = transformer_attribution.reshape(224, 224).data.cpu().numpy()\n", + " transformer_attribution = (transformer_attribution - transformer_attribution.min()) / (transformer_attribution.max() - transformer_attribution.min())\n", + "\n", + " if use_thresholding:\n", + " transformer_attribution = transformer_attribution * 255\n", + " transformer_attribution = transformer_attribution.astype(np.uint8)\n", + " ret, transformer_attribution = cv2.threshold(transformer_attribution, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n", + " transformer_attribution[transformer_attribution == 255] = 1\n", + "\n", + " image_transformer_attribution = original_image.permute(1, 2, 0).data.cpu().numpy()\n", + " image_transformer_attribution = (image_transformer_attribution - image_transformer_attribution.min()) / (image_transformer_attribution.max() - image_transformer_attribution.min())\n", + " vis = show_cam_on_image(image_transformer_attribution, transformer_attribution)\n", + " vis = np.uint8(255 * vis)\n", + " vis = cv2.cvtColor(np.array(vis), cv2.COLOR_RGB2BGR)\n", + " return vis\n", + "\n", + "def print_top_classes(predictions, **kwargs): \n", + " # Print Top-5 predictions\n", + " prob = torch.softmax(predictions, dim=1)\n", + " class_indices = predictions.data.topk(5, dim=1)[1][0].tolist()\n", + " max_str_len = 0\n", + " class_names = []\n", + " for cls_idx in class_indices:\n", + " class_names.append(CLS2IDX[cls_idx])\n", + " if len(CLS2IDX[cls_idx]) > max_str_len:\n", + " max_str_len = len(CLS2IDX[cls_idx])\n", + " \n", + " print('Top 5 classes:')\n", + " for cls_idx in class_indices:\n", + " output_string = '\\t{} : {}'.format(cls_idx, CLS2IDX[cls_idx])\n", + " output_string += ' ' * (max_str_len - len(CLS2IDX[cls_idx])) + '\\t\\t'\n", + " output_string += 'value = {:.3f}\\t prob = {:.1f}%'.format(predictions[0, cls_idx], 100 * prob[0, cls_idx])\n", + " print(output_string)" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "ZPbx6CIHEl08", + "outputId": "d42b5ff4-8206-4588-971f-ac7d0ed6fa89" + }, + "source": [ + "image = Image.open('samples/catdog.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# cat - the predicted class\n", + "cat = generate_visualization(dog_cat_image)\n", + "\n", + "# dog \n", + "# generate visualization for class 243: 'bull mastiff'\n", + "dog = generate_visualization(dog_cat_image, class_index=243)\n", + "\n", + "\n", + "axs[1].imshow(cat);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(dog);\n", + "axs[2].axis('off');" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t282 : tiger cat \t\tvalue = 10.559\t prob = 68.6%\n", + "\t281 : tabby, tabby cat\t\tvalue = 9.059\t prob = 15.3%\n", + "\t285 : Egyptian cat \t\tvalue = 8.414\t prob = 8.0%\n", + "\t243 : bull mastiff \t\tvalue = 7.425\t prob = 3.0%\n", + "\t811 : space heater \t\tvalue = 5.152\t prob = 0.3%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "#@title Perform thresholding on the relevance (using Otsu's method)\n", + "prev_use_thresholding = use_thresholding\n", + "if not use_thresholding:\n", + " use_thresholding = True\n", + "image = Image.open('samples/catdog.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# cat - the predicted class\n", + "cat = generate_visualization(dog_cat_image)\n", + "\n", + "# dog \n", + "# generate visualization for class 243: 'bull mastiff'\n", + "dog = generate_visualization(dog_cat_image, class_index=243)\n", + "\n", + "if not prev_use_thresholding:\n", + " use_thresholding = False\n", + "\n", + "axs[1].imshow(cat);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(dog);\n", + "axs[2].axis('off');" + ], + "metadata": { + "id": "K_8Bjn0O47uG", + "outputId": "c50ca3b3-348b-460b-e762-b81c63cf7ac3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + } + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t282 : tiger cat \t\tvalue = 10.559\t prob = 68.6%\n", + "\t281 : tabby, tabby cat\t\tvalue = 9.059\t prob = 15.3%\n", + "\t285 : Egyptian cat \t\tvalue = 8.414\t prob = 8.0%\n", + "\t243 : bull mastiff \t\tvalue = 7.425\t prob = 3.0%\n", + "\t811 : space heater \t\tvalue = 5.152\t prob = 0.3%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "8lyV6PiIEspF", + "outputId": "6eafedab-d6a7-4514-dea6-356557f920fa" + }, + "source": [ + "image = Image.open('samples/el2.png')\n", + "tusker_zebra_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(tusker_zebra_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# tusker - the predicted class\n", + "tusker = generate_visualization(tusker_zebra_image)\n", + "\n", + "# zebra \n", + "# generate visualization for class 340: 'zebra'\n", + "zebra = generate_visualization(tusker_zebra_image, class_index=340)\n", + "\n", + "\n", + "axs[1].imshow(tusker);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(zebra);\n", + "axs[2].axis('off');" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t101 : tusker \t\tvalue = 11.216\t prob = 37.9%\n", + "\t340 : zebra \t\tvalue = 10.973\t prob = 29.7%\n", + "\t386 : African elephant, Loxodonta africana\t\tvalue = 10.747\t prob = 23.7%\n", + "\t385 : Indian elephant, Elephas maximus \t\tvalue = 9.547\t prob = 7.2%\n", + "\t343 : warthog \t\tvalue = 5.566\t prob = 0.1%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "2o_lqvaZEzwR", + "outputId": "5e5c69d7-6792-4e44-f9f5-fed31ecd98a4" + }, + "source": [ + "image = Image.open('samples/dogbird.png')\n", + "dog_bird_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_bird_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# basset - the predicted class\n", + "basset = generate_visualization(dog_bird_image, class_index=161)\n", + "\n", + "# generate visualization for class 87: 'African grey, African gray, Psittacus erithacus (grey parrot)'\n", + "parrot = generate_visualization(dog_bird_image, class_index=87)\n", + "\n", + "\n", + "axs[1].imshow(basset);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(parrot);\n", + "axs[2].axis('off');" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t161 : basset, basset hound \t\tvalue = 10.514\t prob = 78.8%\n", + "\t163 : bloodhound, sleuthhound \t\tvalue = 8.604\t prob = 11.7%\n", + "\t166 : Walker hound, Walker foxhound\t\tvalue = 7.446\t prob = 3.7%\n", + "\t162 : beagle \t\tvalue = 5.561\t prob = 0.6%\n", + "\t168 : redbone \t\tvalue = 5.249\t prob = 0.4%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xy-S7B3HFRDS" + }, + "source": [ + "# **DeiT examples**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hoM9_BRUFV96" + }, + "source": [ + "from baselines.ViT.ViT_LRP import deit_base_patch16_224 as vit_LRP\n", + "from baselines.ViT.ViT_explanation_generator import LRP\n", + "\n", + "# initialize ViT pretrained with DeiT\n", + "model = vit_LRP(pretrained=True).cuda()\n", + "model.eval()\n", + "attribution_generator = LRP(model)\n", + "\n", + "normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " normalize,\n", + "])" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "vJaPkTZYFv0T", + "outputId": "e96ae43f-0ae3-4b11-a7f0-2ace3a1f1fdb" + }, + "source": [ + "image = Image.open('samples/catdog.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# dog \n", + "# generate visualization for class 243: 'bull mastiff' - the predicted class\n", + "dog = generate_visualization(dog_cat_image)\n", + "\n", + "# cat - generate visualization for class 282 : 'tiger cat'\n", + "cat = generate_visualization(dog_cat_image, class_index=282)\n", + "\n", + "\n", + "axs[1].imshow(dog);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(cat);\n", + "axs[2].axis('off');" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t243 : bull mastiff \t\tvalue = 5.992\t prob = 19.0%\n", + "\t282 : tiger cat \t\tvalue = 5.175\t prob = 8.4%\n", + "\t285 : Egyptian cat \t\tvalue = 4.781\t prob = 5.7%\n", + "\t281 : tabby, tabby cat\t\tvalue = 4.690\t prob = 5.2%\n", + "\t245 : French bulldog \t\tvalue = 2.991\t prob = 0.9%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "Mfei_PQJGGrT", + "outputId": "2a6bfa8f-063c-4a92-f71c-52f8d87f056a" + }, + "source": [ + "image = Image.open('samples/el2.png')\n", + "tusker_zebra_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(tusker_zebra_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# zebra \n", + "# zebra- the predicted class\n", + "zebra = generate_visualization(tusker_zebra_image, class_index=340)\n", + "\n", + "# generate visualization for class 101: 'tusker'\n", + "tusker = generate_visualization(tusker_zebra_image, class_index=101)\n", + "\n", + "axs[1].imshow(zebra);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(tusker);\n", + "axs[2].axis('off');" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t340 : zebra \t\tvalue = 6.759\t prob = 32.7%\n", + "\t101 : tusker \t\tvalue = 5.557\t prob = 9.8%\n", + "\t386 : African elephant, Loxodonta africana\t\tvalue = 5.477\t prob = 9.1%\n", + "\t385 : Indian elephant, Elephas maximus \t\tvalue = 4.774\t prob = 4.5%\n", + "\t925 : consomme \t\tvalue = 2.237\t prob = 0.4%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "wdiHgvFgGLlJ", + "outputId": "e800323c-ff3f-4611-f348-6a0be8e8d90f" + }, + "source": [ + "image = Image.open('samples/dogbird.png')\n", + "dog_bird_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_bird_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# basset - the predicted class\n", + "basset = generate_visualization(dog_bird_image, class_index=161)\n", + "\n", + "# generate visualization for class 90: 'lorikeet'\n", + "parrot = generate_visualization(dog_bird_image, class_index=90)\n", + "\n", + "\n", + "axs[1].imshow(basset);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(parrot);\n", + "axs[2].axis('off');" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Top 5 classes:\n", + "\t161 : basset, basset hound \t\tvalue = 6.327\t prob = 26.5%\n", + "\t90 : lorikeet \t\tvalue = 4.394\t prob = 3.8%\n", + "\t88 : macaw \t\tvalue = 4.055\t prob = 2.7%\n", + "\t166 : Walker hound, Walker foxhound\t\tvalue = 3.394\t prob = 1.4%\n", + "\t163 : bloodhound, sleuthhound \t\tvalue = 3.352\t prob = 1.4%\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Transformer-Explainability/baselines/ViT/ViT_LRP.py b/Transformer-Explainability/baselines/ViT/ViT_LRP.py new file mode 100644 index 0000000000000000000000000000000000000000..9a98714138b0552c965c7ccf6a9275ea9a3846a0 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/ViT_LRP.py @@ -0,0 +1,535 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +import torch +import torch.nn as nn +from baselines.ViT.helpers import load_pretrained +from baselines.ViT.layer_helpers import to_2tuple +from baselines.ViT.weight_init import trunc_normal_ +from einops import rearrange +from modules.layers_ours import * + + +def _cfg(url="", **kwargs): + return { + "url": url, + "num_classes": 1000, + "input_size": (3, 224, 224), + "pool_size": None, + "crop_pct": 0.9, + "interpolation": "bicubic", + "first_conv": "patch_embed.proj", + "classifier": "head", + **kwargs, + } + + +default_cfgs = { + # patch models + "vit_small_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth", + ), + "vit_base_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), + "vit_large_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), +} + + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + # all_layer_matrices = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + # for i in range(len(all_layer_matrices))] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer + 1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, drop=0.0): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = Linear(in_features, hidden_features) + self.act = GELU() + self.fc2 = Linear(hidden_features, out_features) + self.drop = Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + def relprop(self, cam, **kwargs): + cam = self.drop.relprop(cam, **kwargs) + cam = self.fc2.relprop(cam, **kwargs) + cam = self.act.relprop(cam, **kwargs) + cam = self.fc1.relprop(cam, **kwargs) + return cam + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim**-0.5 + + # A = Q*K^T + self.matmul1 = einsum("bhid,bhjd->bhij") + # attn = A*V + self.matmul2 = einsum("bhij,bhjd->bhid") + + self.qkv = Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = Dropout(attn_drop) + self.proj = Linear(dim, dim) + self.proj_drop = Dropout(proj_drop) + self.softmax = Softmax(dim=-1) + + self.attn_cam = None + self.attn = None + self.v = None + self.v_cam = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def get_v(self): + return self.v + + def save_v(self, v): + self.v = v + + def save_v_cam(self, cam): + self.v_cam = cam + + def get_v_cam(self): + return self.v_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def forward(self, x): + b, n, _, h = *x.shape, self.num_heads + qkv = self.qkv(x) + q, k, v = rearrange(qkv, "b n (qkv h d) -> qkv b h n d", qkv=3, h=h) + + self.save_v(v) + + dots = self.matmul1([q, k]) * self.scale + + attn = self.softmax(dots) + attn = self.attn_drop(attn) + + self.save_attn(attn) + attn.register_hook(self.save_attn_gradients) + + out = self.matmul2([attn, v]) + out = rearrange(out, "b h n d -> b n (h d)") + + out = self.proj(out) + out = self.proj_drop(out) + return out + + def relprop(self, cam, **kwargs): + cam = self.proj_drop.relprop(cam, **kwargs) + cam = self.proj.relprop(cam, **kwargs) + cam = rearrange(cam, "b n (h d) -> b h n d", h=self.num_heads) + + # attn = A*V + (cam1, cam_v) = self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam_v /= 2 + + self.save_v_cam(cam_v) + self.save_attn_cam(cam1) + + cam1 = self.attn_drop.relprop(cam1, **kwargs) + cam1 = self.softmax.relprop(cam1, **kwargs) + + # A = Q*K^T + (cam_q, cam_k) = self.matmul1.relprop(cam1, **kwargs) + cam_q /= 2 + cam_k /= 2 + + cam_qkv = rearrange( + [cam_q, cam_k, cam_v], + "qkv b h n d -> b n (qkv h d)", + qkv=3, + h=self.num_heads, + ) + + return self.qkv.relprop(cam_qkv, **kwargs) + + +class Block(nn.Module): + def __init__( + self, dim, num_heads, mlp_ratio=4.0, qkv_bias=False, drop=0.0, attn_drop=0.0 + ): + super().__init__() + self.norm1 = LayerNorm(dim, eps=1e-6) + self.attn = Attention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + attn_drop=attn_drop, + proj_drop=drop, + ) + self.norm2 = LayerNorm(dim, eps=1e-6) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, drop=drop) + + self.add1 = Add() + self.add2 = Add() + self.clone1 = Clone() + self.clone2 = Clone() + + def forward(self, x): + x1, x2 = self.clone1(x, 2) + x = self.add1([x1, self.attn(self.norm1(x2))]) + x1, x2 = self.clone2(x, 2) + x = self.add2([x1, self.mlp(self.norm2(x2))]) + return x + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.add2.relprop(cam, **kwargs) + cam2 = self.mlp.relprop(cam2, **kwargs) + cam2 = self.norm2.relprop(cam2, **kwargs) + cam = self.clone2.relprop((cam1, cam2), **kwargs) + + (cam1, cam2) = self.add1.relprop(cam, **kwargs) + cam2 = self.attn.relprop(cam2, **kwargs) + cam2 = self.norm1.relprop(cam2, **kwargs) + cam = self.clone1.relprop((cam1, cam2), **kwargs) + return cam + + +class PatchEmbed(nn.Module): + """Image to Patch Embedding""" + + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = Conv2d( + in_chans, embed_dim, kernel_size=patch_size, stride=patch_size + ) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert ( + H == self.img_size[0] and W == self.img_size[1] + ), f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + def relprop(self, cam, **kwargs): + cam = cam.transpose(1, 2) + cam = cam.reshape( + cam.shape[0], + cam.shape[1], + (self.img_size[0] // self.patch_size[0]), + (self.img_size[1] // self.patch_size[1]), + ) + return self.proj.relprop(cam, **kwargs) + + +class VisionTransformer(nn.Module): + """Vision Transformer with support for patch or hybrid CNN input stage""" + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=False, + mlp_head=False, + drop_rate=0.0, + attn_drop_rate=0.0, + ): + super().__init__() + self.num_classes = num_classes + self.num_features = ( + self.embed_dim + ) = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, + patch_size=patch_size, + in_chans=in_chans, + embed_dim=embed_dim, + ) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + + self.blocks = nn.ModuleList( + [ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + drop=drop_rate, + attn_drop=attn_drop_rate, + ) + for i in range(depth) + ] + ) + + self.norm = LayerNorm(embed_dim) + if mlp_head: + # paper diagram suggests 'MLP head', but results in 4M extra parameters vs paper + self.head = Mlp(embed_dim, int(embed_dim * mlp_ratio), num_classes) + else: + # with a single Linear layer as head, the param count within rounding of paper + self.head = Linear(embed_dim, num_classes) + + # FIXME not quite sure what the proper weight init is supposed to be, + # normal / trunc normal w/ std == .02 similar to other Bert like transformers + trunc_normal_(self.pos_embed, std=0.02) # embeddings same as weights? + trunc_normal_(self.cls_token, std=0.02) + self.apply(self._init_weights) + + self.pool = IndexSelect() + self.add = Add() + + self.inp_grad = None + + def save_inp_grad(self, grad): + self.inp_grad = grad + + def get_inp_grad(self): + return self.inp_grad + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @property + def no_weight_decay(self): + return {"pos_embed", "cls_token"} + + def forward(self, x): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = self.add([x, self.pos_embed]) + + x.register_hook(self.save_inp_grad) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + x = self.pool(x, dim=1, indices=torch.tensor(0, device=x.device)) + x = x.squeeze(1) + x = self.head(x) + return x + + def relprop( + self, + cam=None, + method="transformer_attribution", + is_ablation=False, + start_layer=0, + **kwargs, + ): + # print(kwargs) + # print("conservation 1", cam.sum()) + cam = self.head.relprop(cam, **kwargs) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + cam = self.norm.relprop(cam, **kwargs) + for blk in reversed(self.blocks): + cam = blk.relprop(cam, **kwargs) + + # print("conservation 2", cam.sum()) + # print("min", cam.min()) + + if method == "full": + (cam, _) = self.add.relprop(cam, **kwargs) + cam = cam[:, 1:] + cam = self.patch_embed.relprop(cam, **kwargs) + # sum on channels + cam = cam.sum(dim=1) + return cam + + elif method == "rollout": + # cam rollout + attn_cams = [] + for blk in self.blocks: + attn_heads = blk.attn.get_attn_cam().clamp(min=0) + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + attn_cams.append(avg_heads) + cam = compute_rollout_attention(attn_cams, start_layer=start_layer) + cam = cam[:, 0, 1:] + return cam + + # our method, method name grad is legacy + elif method == "transformer_attribution" or method == "grad": + cams = [] + for blk in self.blocks: + grad = blk.attn.get_attn_gradients() + cam = blk.attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cams.append(cam.unsqueeze(0)) + rollout = compute_rollout_attention(cams, start_layer=start_layer) + cam = rollout[:, 0, 1:] + return cam + + elif method == "last_layer": + cam = self.blocks[-1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[-1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "last_layer_attn": + cam = self.blocks[-1].attn.get_attn() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "second_layer": + cam = self.blocks[1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + +def _conv_filter(state_dict, patch_size=16): + """convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if "patch_embed.proj.weight" in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + qkv_bias=True, + **kwargs, + ) + model.default_cfg = default_cfgs["vit_base_patch16_224"] + if pretrained: + load_pretrained( + model, + num_classes=model.num_classes, + in_chans=kwargs.get("in_chans", 3), + filter_fn=_conv_filter, + ) + return model + + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=1024, + depth=24, + num_heads=16, + mlp_ratio=4, + qkv_bias=True, + **kwargs, + ) + model.default_cfg = default_cfgs["vit_large_patch16_224"] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get("in_chans", 3) + ) + return model + + +def deit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + qkv_bias=True, + **kwargs, + ) + model.default_cfg = _cfg() + if pretrained: + checkpoint = torch.hub.load_state_dict_from_url( + url="https://dl.fbaipublicfiles.com/deit/deit_base_patch16_224-b5f2ef4d.pth", + map_location="cpu", + check_hash=True, + ) + model.load_state_dict(checkpoint["model"]) + return model diff --git a/Transformer-Explainability/baselines/ViT/ViT_explanation_generator.py b/Transformer-Explainability/baselines/ViT/ViT_explanation_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..27ce86a4bda44e66658620603e7394666aef9252 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/ViT_explanation_generator.py @@ -0,0 +1,107 @@ +import argparse + +import numpy as np +import torch +from numpy import * + + +# compute rollout between attention layers +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration- code adapted from https://github.com/samiraabnar/attention_flow + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + matrices_aug = [ + all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + for i in range(len(all_layer_matrices)) + ] + joint_attention = matrices_aug[start_layer] + for i in range(start_layer + 1, len(matrices_aug)): + joint_attention = matrices_aug[i].bmm(joint_attention) + return joint_attention + + +class LRP: + def __init__(self, model): + self.model = model + self.model.eval() + + def generate_LRP( + self, + input, + index=None, + method="transformer_attribution", + is_ablation=False, + start_layer=0, + ): + output = self.model(input) + kwargs = {"alpha": 1} + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + return self.model.relprop( + torch.tensor(one_hot_vector).to(input.device), + method=method, + is_ablation=is_ablation, + start_layer=start_layer, + **kwargs + ) + + +class Baselines: + def __init__(self, model): + self.model = model + self.model.eval() + + def generate_cam_attn(self, input, index=None): + output = self.model(input.cuda(), register_hook=True) + if index == None: + index = np.argmax(output.cpu().data.numpy()) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0][index] = 1 + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.cuda() * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + #################### attn + grad = self.model.blocks[-1].attn.get_attn_gradients() + cam = self.model.blocks[-1].attn.get_attention_map() + cam = cam[0, :, 0, 1:].reshape(-1, 14, 14) + grad = grad[0, :, 0, 1:].reshape(-1, 14, 14) + grad = grad.mean(dim=[1, 2], keepdim=True) + cam = (cam * grad).mean(0).clamp(min=0) + cam = (cam - cam.min()) / (cam.max() - cam.min()) + + return cam + #################### attn + + def generate_rollout(self, input, start_layer=0): + self.model(input) + blocks = self.model.blocks + all_layer_attentions = [] + for blk in blocks: + attn_heads = blk.attn.get_attention_map() + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + all_layer_attentions.append(avg_heads) + rollout = compute_rollout_attention( + all_layer_attentions, start_layer=start_layer + ) + return rollout[:, 0, 1:] diff --git a/Transformer-Explainability/baselines/ViT/ViT_new.py b/Transformer-Explainability/baselines/ViT/ViT_new.py new file mode 100644 index 0000000000000000000000000000000000000000..a706639fa4ca7dc4d1c92651d96e8dc96a8d222f --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/ViT_new.py @@ -0,0 +1,329 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +from functools import partial + +import torch +import torch.nn as nn +from baselines.ViT.helpers import load_pretrained +from baselines.ViT.layer_helpers import to_2tuple +from baselines.ViT.weight_init import trunc_normal_ +from einops import rearrange + + +def _cfg(url="", **kwargs): + return { + "url": url, + "num_classes": 1000, + "input_size": (3, 224, 224), + "pool_size": None, + "crop_pct": 0.9, + "interpolation": "bicubic", + "first_conv": "patch_embed.proj", + "classifier": "head", + **kwargs, + } + + +default_cfgs = { + # patch models + "vit_small_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth", + ), + "vit_base_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), + "vit_large_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), +} + + +class Mlp(nn.Module): + def __init__( + self, + in_features, + hidden_features=None, + out_features=None, + act_layer=nn.GELU, + drop=0.0, + ): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + self.attn_gradients = None + self.attention_map = None + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def save_attention_map(self, attention_map): + self.attention_map = attention_map + + def get_attention_map(self): + return self.attention_map + + def forward(self, x, register_hook=False): + b, n, _, h = *x.shape, self.num_heads + + # self.save_output(x) + # x.register_hook(self.save_output_grad) + + qkv = self.qkv(x) + q, k, v = rearrange(qkv, "b n (qkv h d) -> qkv b h n d", qkv=3, h=h) + + dots = torch.einsum("bhid,bhjd->bhij", q, k) * self.scale + + attn = dots.softmax(dim=-1) + attn = self.attn_drop(attn) + + out = torch.einsum("bhij,bhjd->bhid", attn, v) + + self.save_attention_map(attn) + if register_hook: + attn.register_hook(self.save_attn_gradients) + + out = rearrange(out, "b h n d -> b n (h d)") + out = self.proj(out) + out = self.proj_drop(out) + return out + + +class Block(nn.Module): + def __init__( + self, + dim, + num_heads, + mlp_ratio=4.0, + qkv_bias=False, + drop=0.0, + attn_drop=0.0, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + ): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + attn_drop=attn_drop, + proj_drop=drop, + ) + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp( + in_features=dim, + hidden_features=mlp_hidden_dim, + act_layer=act_layer, + drop=drop, + ) + + def forward(self, x, register_hook=False): + x = x + self.attn(self.norm1(x), register_hook=register_hook) + x = x + self.mlp(self.norm2(x)) + return x + + +class PatchEmbed(nn.Module): + """Image to Patch Embedding""" + + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d( + in_chans, embed_dim, kernel_size=patch_size, stride=patch_size + ) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert ( + H == self.img_size[0] and W == self.img_size[1] + ), f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + +class VisionTransformer(nn.Module): + """Vision Transformer""" + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=False, + drop_rate=0.0, + attn_drop_rate=0.0, + norm_layer=nn.LayerNorm, + ): + super().__init__() + self.num_classes = num_classes + self.num_features = ( + self.embed_dim + ) = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, + patch_size=patch_size, + in_chans=in_chans, + embed_dim=embed_dim, + ) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.pos_drop = nn.Dropout(p=drop_rate) + + self.blocks = nn.ModuleList( + [ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + drop=drop_rate, + attn_drop=attn_drop_rate, + norm_layer=norm_layer, + ) + for i in range(depth) + ] + ) + self.norm = norm_layer(embed_dim) + + # Classifier head + self.head = ( + nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + ) + + trunc_normal_(self.pos_embed, std=0.02) + trunc_normal_(self.cls_token, std=0.02) + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @torch.jit.ignore + def no_weight_decay(self): + return {"pos_embed", "cls_token"} + + def forward(self, x, register_hook=False): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = x + self.pos_embed + x = self.pos_drop(x) + + for blk in self.blocks: + x = blk(x, register_hook=register_hook) + + x = self.norm(x) + x = x[:, 0] + x = self.head(x) + return x + + +def _conv_filter(state_dict, patch_size=16): + """convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if "patch_embed.proj.weight" in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + qkv_bias=True, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + **kwargs, + ) + model.default_cfg = default_cfgs["vit_base_patch16_224"] + if pretrained: + load_pretrained( + model, + num_classes=model.num_classes, + in_chans=kwargs.get("in_chans", 3), + filter_fn=_conv_filter, + ) + return model + + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=1024, + depth=24, + num_heads=16, + mlp_ratio=4, + qkv_bias=True, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + **kwargs, + ) + model.default_cfg = default_cfgs["vit_large_patch16_224"] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get("in_chans", 3) + ) + return model diff --git a/Transformer-Explainability/baselines/ViT/ViT_orig_LRP.py b/Transformer-Explainability/baselines/ViT/ViT_orig_LRP.py new file mode 100644 index 0000000000000000000000000000000000000000..a585191f72c64ed7b75a3a57cea972d47ec28d61 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/ViT_orig_LRP.py @@ -0,0 +1,508 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +import torch +import torch.nn as nn +from baselines.ViT.helpers import load_pretrained +from baselines.ViT.layer_helpers import to_2tuple +from baselines.ViT.weight_init import trunc_normal_ +from einops import rearrange +from modules.layers_lrp import * + + +def _cfg(url="", **kwargs): + return { + "url": url, + "num_classes": 1000, + "input_size": (3, 224, 224), + "pool_size": None, + "crop_pct": 0.9, + "interpolation": "bicubic", + "first_conv": "patch_embed.proj", + "classifier": "head", + **kwargs, + } + + +default_cfgs = { + # patch models + "vit_small_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth", + ), + "vit_base_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), + "vit_large_patch16_224": _cfg( + url="https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth", + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5), + ), +} + + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = ( + torch.eye(num_tokens) + .expand(batch_size, num_tokens, num_tokens) + .to(all_layer_matrices[0].device) + ) + all_layer_matrices = [ + all_layer_matrices[i] + eye for i in range(len(all_layer_matrices)) + ] + # all_layer_matrices = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + # for i in range(len(all_layer_matrices))] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer + 1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, drop=0.0): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = Linear(in_features, hidden_features) + self.act = GELU() + self.fc2 = Linear(hidden_features, out_features) + self.drop = Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + def relprop(self, cam, **kwargs): + cam = self.drop.relprop(cam, **kwargs) + cam = self.fc2.relprop(cam, **kwargs) + cam = self.act.relprop(cam, **kwargs) + cam = self.fc1.relprop(cam, **kwargs) + return cam + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim**-0.5 + + # A = Q*K^T + self.matmul1 = einsum("bhid,bhjd->bhij") + # attn = A*V + self.matmul2 = einsum("bhij,bhjd->bhid") + + self.qkv = Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = Dropout(attn_drop) + self.proj = Linear(dim, dim) + self.proj_drop = Dropout(proj_drop) + self.softmax = Softmax(dim=-1) + + self.attn_cam = None + self.attn = None + self.v = None + self.v_cam = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def get_v(self): + return self.v + + def save_v(self, v): + self.v = v + + def save_v_cam(self, cam): + self.v_cam = cam + + def get_v_cam(self): + return self.v_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def forward(self, x): + b, n, _, h = *x.shape, self.num_heads + qkv = self.qkv(x) + q, k, v = rearrange(qkv, "b n (qkv h d) -> qkv b h n d", qkv=3, h=h) + + self.save_v(v) + + dots = self.matmul1([q, k]) * self.scale + + attn = self.softmax(dots) + attn = self.attn_drop(attn) + + self.save_attn(attn) + attn.register_hook(self.save_attn_gradients) + + out = self.matmul2([attn, v]) + out = rearrange(out, "b h n d -> b n (h d)") + + out = self.proj(out) + out = self.proj_drop(out) + return out + + def relprop(self, cam, **kwargs): + cam = self.proj_drop.relprop(cam, **kwargs) + cam = self.proj.relprop(cam, **kwargs) + cam = rearrange(cam, "b n (h d) -> b h n d", h=self.num_heads) + + # attn = A*V + (cam1, cam_v) = self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam_v /= 2 + + self.save_v_cam(cam_v) + self.save_attn_cam(cam1) + + cam1 = self.attn_drop.relprop(cam1, **kwargs) + cam1 = self.softmax.relprop(cam1, **kwargs) + + # A = Q*K^T + (cam_q, cam_k) = self.matmul1.relprop(cam1, **kwargs) + cam_q /= 2 + cam_k /= 2 + + cam_qkv = rearrange( + [cam_q, cam_k, cam_v], + "qkv b h n d -> b n (qkv h d)", + qkv=3, + h=self.num_heads, + ) + + return self.qkv.relprop(cam_qkv, **kwargs) + + +class Block(nn.Module): + def __init__( + self, dim, num_heads, mlp_ratio=4.0, qkv_bias=False, drop=0.0, attn_drop=0.0 + ): + super().__init__() + self.norm1 = LayerNorm(dim, eps=1e-6) + self.attn = Attention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + attn_drop=attn_drop, + proj_drop=drop, + ) + self.norm2 = LayerNorm(dim, eps=1e-6) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, drop=drop) + + self.add1 = Add() + self.add2 = Add() + self.clone1 = Clone() + self.clone2 = Clone() + + def forward(self, x): + x1, x2 = self.clone1(x, 2) + x = self.add1([x1, self.attn(self.norm1(x2))]) + x1, x2 = self.clone2(x, 2) + x = self.add2([x1, self.mlp(self.norm2(x2))]) + return x + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.add2.relprop(cam, **kwargs) + cam2 = self.mlp.relprop(cam2, **kwargs) + cam2 = self.norm2.relprop(cam2, **kwargs) + cam = self.clone2.relprop((cam1, cam2), **kwargs) + + (cam1, cam2) = self.add1.relprop(cam, **kwargs) + cam2 = self.attn.relprop(cam2, **kwargs) + cam2 = self.norm1.relprop(cam2, **kwargs) + cam = self.clone1.relprop((cam1, cam2), **kwargs) + return cam + + +class PatchEmbed(nn.Module): + """Image to Patch Embedding""" + + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = Conv2d( + in_chans, embed_dim, kernel_size=patch_size, stride=patch_size + ) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert ( + H == self.img_size[0] and W == self.img_size[1] + ), f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + def relprop(self, cam, **kwargs): + cam = cam.transpose(1, 2) + cam = cam.reshape( + cam.shape[0], + cam.shape[1], + (self.img_size[0] // self.patch_size[0]), + (self.img_size[1] // self.patch_size[1]), + ) + return self.proj.relprop(cam, **kwargs) + + +class VisionTransformer(nn.Module): + """Vision Transformer with support for patch or hybrid CNN input stage""" + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=False, + mlp_head=False, + drop_rate=0.0, + attn_drop_rate=0.0, + ): + super().__init__() + self.num_classes = num_classes + self.num_features = ( + self.embed_dim + ) = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, + patch_size=patch_size, + in_chans=in_chans, + embed_dim=embed_dim, + ) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + + self.blocks = nn.ModuleList( + [ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + drop=drop_rate, + attn_drop=attn_drop_rate, + ) + for i in range(depth) + ] + ) + + self.norm = LayerNorm(embed_dim) + if mlp_head: + # paper diagram suggests 'MLP head', but results in 4M extra parameters vs paper + self.head = Mlp(embed_dim, int(embed_dim * mlp_ratio), num_classes) + else: + # with a single Linear layer as head, the param count within rounding of paper + self.head = Linear(embed_dim, num_classes) + + # FIXME not quite sure what the proper weight init is supposed to be, + # normal / trunc normal w/ std == .02 similar to other Bert like transformers + trunc_normal_(self.pos_embed, std=0.02) # embeddings same as weights? + trunc_normal_(self.cls_token, std=0.02) + self.apply(self._init_weights) + + self.pool = IndexSelect() + self.add = Add() + + self.inp_grad = None + + def save_inp_grad(self, grad): + self.inp_grad = grad + + def get_inp_grad(self): + return self.inp_grad + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @property + def no_weight_decay(self): + return {"pos_embed", "cls_token"} + + def forward(self, x): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = self.add([x, self.pos_embed]) + + x.register_hook(self.save_inp_grad) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + x = self.pool(x, dim=1, indices=torch.tensor(0, device=x.device)) + x = x.squeeze(1) + x = self.head(x) + return x + + def relprop( + self, cam=None, method="grad", is_ablation=False, start_layer=0, **kwargs + ): + # print(kwargs) + # print("conservation 1", cam.sum()) + cam = self.head.relprop(cam, **kwargs) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + cam = self.norm.relprop(cam, **kwargs) + for blk in reversed(self.blocks): + cam = blk.relprop(cam, **kwargs) + + # print("conservation 2", cam.sum()) + # print("min", cam.min()) + + if method == "full": + (cam, _) = self.add.relprop(cam, **kwargs) + cam = cam[:, 1:] + cam = self.patch_embed.relprop(cam, **kwargs) + # sum on channels + cam = cam.sum(dim=1) + return cam + + elif method == "rollout": + # cam rollout + attn_cams = [] + for blk in self.blocks: + attn_heads = blk.attn.get_attn_cam().clamp(min=0) + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + attn_cams.append(avg_heads) + cam = compute_rollout_attention(attn_cams, start_layer=start_layer) + cam = cam[:, 0, 1:] + return cam + + elif method == "grad": + cams = [] + for blk in self.blocks: + grad = blk.attn.get_attn_gradients() + cam = blk.attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cams.append(cam.unsqueeze(0)) + rollout = compute_rollout_attention(cams, start_layer=start_layer) + cam = rollout[:, 0, 1:] + return cam + + elif method == "last_layer": + cam = self.blocks[-1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[-1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "last_layer_attn": + cam = self.blocks[-1].attn.get_attn() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "second_layer": + cam = self.blocks[1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + +def _conv_filter(state_dict, patch_size=16): + """convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if "patch_embed.proj.weight" in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + qkv_bias=True, + **kwargs, + ) + model.default_cfg = default_cfgs["vit_base_patch16_224"] + if pretrained: + load_pretrained( + model, + num_classes=model.num_classes, + in_chans=kwargs.get("in_chans", 3), + filter_fn=_conv_filter, + ) + return model + + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, + embed_dim=1024, + depth=24, + num_heads=16, + mlp_ratio=4, + qkv_bias=True, + **kwargs, + ) + model.default_cfg = default_cfgs["vit_large_patch16_224"] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get("in_chans", 3) + ) + return model diff --git a/Transformer-Explainability/baselines/ViT/generate_visualizations.py b/Transformer-Explainability/baselines/ViT/generate_visualizations.py new file mode 100644 index 0000000000000000000000000000000000000000..e76c0e2dffeb1a07e4f579d81166599c3d463782 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/generate_visualizations.py @@ -0,0 +1,237 @@ +import argparse +import os + +import h5py +# Import saliency methods and models +from misc_functions import * +from torchvision.datasets import ImageNet +from tqdm import tqdm +from ViT_explanation_generator import LRP, Baselines +from ViT_LRP import vit_base_patch16_224 as vit_LRP +from ViT_new import vit_base_patch16_224 +from ViT_orig_LRP import vit_base_patch16_224 as vit_orig_LRP + + +def normalize(tensor, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]): + dtype = tensor.dtype + mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device) + std = torch.as_tensor(std, dtype=dtype, device=tensor.device) + tensor.sub_(mean[None, :, None, None]).div_(std[None, :, None, None]) + return tensor + + +def compute_saliency_and_save(args): + first = True + with h5py.File(os.path.join(args.method_dir, "results.hdf5"), "a") as f: + data_cam = f.create_dataset( + "vis", + (1, 1, 224, 224), + maxshape=(None, 1, 224, 224), + dtype=np.float32, + compression="gzip", + ) + data_image = f.create_dataset( + "image", + (1, 3, 224, 224), + maxshape=(None, 3, 224, 224), + dtype=np.float32, + compression="gzip", + ) + data_target = f.create_dataset( + "target", (1,), maxshape=(None,), dtype=np.int32, compression="gzip" + ) + for batch_idx, (data, target) in enumerate(tqdm(sample_loader)): + if first: + first = False + data_cam.resize(data_cam.shape[0] + data.shape[0] - 1, axis=0) + data_image.resize(data_image.shape[0] + data.shape[0] - 1, axis=0) + data_target.resize(data_target.shape[0] + data.shape[0] - 1, axis=0) + else: + data_cam.resize(data_cam.shape[0] + data.shape[0], axis=0) + data_image.resize(data_image.shape[0] + data.shape[0], axis=0) + data_target.resize(data_target.shape[0] + data.shape[0], axis=0) + + # Add data + data_image[-data.shape[0] :] = data.data.cpu().numpy() + data_target[-data.shape[0] :] = target.data.cpu().numpy() + + target = target.to(device) + + data = normalize(data) + data = data.to(device) + data.requires_grad_() + + index = None + if args.vis_class == "target": + index = target + + if args.method == "rollout": + Res = baselines.generate_rollout(data, start_layer=1).reshape( + data.shape[0], 1, 14, 14 + ) + # Res = Res - Res.mean() + + elif args.method == "lrp": + Res = lrp.generate_LRP(data, start_layer=1, index=index).reshape( + data.shape[0], 1, 14, 14 + ) + # Res = Res - Res.mean() + + elif args.method == "transformer_attribution": + Res = lrp.generate_LRP( + data, start_layer=1, method="grad", index=index + ).reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == "full_lrp": + Res = orig_lrp.generate_LRP(data, method="full", index=index).reshape( + data.shape[0], 1, 224, 224 + ) + # Res = Res - Res.mean() + + elif args.method == "lrp_last_layer": + Res = orig_lrp.generate_LRP( + data, method="last_layer", is_ablation=args.is_ablation, index=index + ).reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == "attn_last_layer": + Res = lrp.generate_LRP( + data, method="last_layer_attn", is_ablation=args.is_ablation + ).reshape(data.shape[0], 1, 14, 14) + + elif args.method == "attn_gradcam": + Res = baselines.generate_cam_attn(data, index=index).reshape( + data.shape[0], 1, 14, 14 + ) + + if args.method != "full_lrp" and args.method != "input_grads": + Res = torch.nn.functional.interpolate( + Res, scale_factor=16, mode="bilinear" + ).cuda() + Res = (Res - Res.min()) / (Res.max() - Res.min()) + + data_cam[-data.shape[0] :] = Res.data.cpu().numpy() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Train a segmentation") + parser.add_argument("--batch-size", type=int, default=1, help="") + parser.add_argument( + "--method", + type=str, + default="grad_rollout", + choices=[ + "rollout", + "lrp", + "transformer_attribution", + "full_lrp", + "lrp_last_layer", + "attn_last_layer", + "attn_gradcam", + ], + help="", + ) + parser.add_argument("--lmd", type=float, default=10, help="") + parser.add_argument( + "--vis-class", + type=str, + default="top", + choices=["top", "target", "index"], + help="", + ) + parser.add_argument("--class-id", type=int, default=0, help="") + parser.add_argument("--cls-agn", action="store_true", default=False, help="") + parser.add_argument("--no-ia", action="store_true", default=False, help="") + parser.add_argument("--no-fx", action="store_true", default=False, help="") + parser.add_argument("--no-fgx", action="store_true", default=False, help="") + parser.add_argument("--no-m", action="store_true", default=False, help="") + parser.add_argument("--no-reg", action="store_true", default=False, help="") + parser.add_argument("--is-ablation", type=bool, default=False, help="") + parser.add_argument("--imagenet-validation-path", type=str, required=True, help="") + args = parser.parse_args() + + # PATH variables + PATH = os.path.dirname(os.path.abspath(__file__)) + "/" + os.makedirs(os.path.join(PATH, "visualizations"), exist_ok=True) + + try: + os.remove( + os.path.join( + PATH, + "visualizations/{}/{}/results.hdf5".format(args.method, args.vis_class), + ) + ) + except OSError: + pass + + os.makedirs( + os.path.join(PATH, "visualizations/{}".format(args.method)), exist_ok=True + ) + if args.vis_class == "index": + os.makedirs( + os.path.join( + PATH, + "visualizations/{}/{}_{}".format( + args.method, args.vis_class, args.class_id + ), + ), + exist_ok=True, + ) + args.method_dir = os.path.join( + PATH, + "visualizations/{}/{}_{}".format( + args.method, args.vis_class, args.class_id + ), + ) + else: + ablation_fold = "ablation" if args.is_ablation else "not_ablation" + os.makedirs( + os.path.join( + PATH, + "visualizations/{}/{}/{}".format( + args.method, args.vis_class, ablation_fold + ), + ), + exist_ok=True, + ) + args.method_dir = os.path.join( + PATH, + "visualizations/{}/{}/{}".format( + args.method, args.vis_class, ablation_fold + ), + ) + + cuda = torch.cuda.is_available() + device = torch.device("cuda" if cuda else "cpu") + + # Model + model = vit_base_patch16_224(pretrained=True).cuda() + baselines = Baselines(model) + + # LRP + model_LRP = vit_LRP(pretrained=True).cuda() + model_LRP.eval() + lrp = LRP(model_LRP) + + # orig LRP + model_orig_LRP = vit_orig_LRP(pretrained=True).cuda() + model_orig_LRP.eval() + orig_lrp = LRP(model_orig_LRP) + + # Dataset loader for sample images + transform = transforms.Compose( + [ + transforms.Resize((224, 224)), + transforms.ToTensor(), + ] + ) + + imagenet_ds = ImageNet( + args.imagenet_validation_path, split="val", download=False, transform=transform + ) + sample_loader = torch.utils.data.DataLoader( + imagenet_ds, batch_size=args.batch_size, shuffle=False, num_workers=4 + ) + + compute_saliency_and_save(args) diff --git a/Transformer-Explainability/baselines/ViT/helpers.py b/Transformer-Explainability/baselines/ViT/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..af0656daaa068ebe189447a62235f0cabbe28829 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/helpers.py @@ -0,0 +1,332 @@ +""" Model creation / weight loading / state_dict helpers + +Hacked together by / Copyright 2020 Ross Wightman +""" +import logging +import math +import os +from collections import OrderedDict +from copy import deepcopy +from typing import Callable + +import torch +import torch.nn as nn +import torch.utils.model_zoo as model_zoo + +_logger = logging.getLogger(__name__) + + +def load_state_dict(checkpoint_path, use_ema=False): + if checkpoint_path and os.path.isfile(checkpoint_path): + checkpoint = torch.load(checkpoint_path, map_location="cpu") + state_dict_key = "state_dict" + if isinstance(checkpoint, dict): + if use_ema and "state_dict_ema" in checkpoint: + state_dict_key = "state_dict_ema" + if state_dict_key and state_dict_key in checkpoint: + new_state_dict = OrderedDict() + for k, v in checkpoint[state_dict_key].items(): + # strip `module.` prefix + name = k[7:] if k.startswith("module") else k + new_state_dict[name] = v + state_dict = new_state_dict + else: + state_dict = checkpoint + _logger.info( + "Loaded {} from checkpoint '{}'".format(state_dict_key, checkpoint_path) + ) + return state_dict + else: + _logger.error("No checkpoint found at '{}'".format(checkpoint_path)) + raise FileNotFoundError() + + +def load_checkpoint(model, checkpoint_path, use_ema=False, strict=True): + state_dict = load_state_dict(checkpoint_path, use_ema) + model.load_state_dict(state_dict, strict=strict) + + +def resume_checkpoint( + model, checkpoint_path, optimizer=None, loss_scaler=None, log_info=True +): + resume_epoch = None + if os.path.isfile(checkpoint_path): + checkpoint = torch.load(checkpoint_path, map_location="cpu") + if isinstance(checkpoint, dict) and "state_dict" in checkpoint: + if log_info: + _logger.info("Restoring model state from checkpoint...") + new_state_dict = OrderedDict() + for k, v in checkpoint["state_dict"].items(): + name = k[7:] if k.startswith("module") else k + new_state_dict[name] = v + model.load_state_dict(new_state_dict) + + if optimizer is not None and "optimizer" in checkpoint: + if log_info: + _logger.info("Restoring optimizer state from checkpoint...") + optimizer.load_state_dict(checkpoint["optimizer"]) + + if loss_scaler is not None and loss_scaler.state_dict_key in checkpoint: + if log_info: + _logger.info("Restoring AMP loss scaler state from checkpoint...") + loss_scaler.load_state_dict(checkpoint[loss_scaler.state_dict_key]) + + if "epoch" in checkpoint: + resume_epoch = checkpoint["epoch"] + if "version" in checkpoint and checkpoint["version"] > 1: + resume_epoch += 1 # start at the next epoch, old checkpoints incremented before save + + if log_info: + _logger.info( + "Loaded checkpoint '{}' (epoch {})".format( + checkpoint_path, checkpoint["epoch"] + ) + ) + else: + model.load_state_dict(checkpoint) + if log_info: + _logger.info("Loaded checkpoint '{}'".format(checkpoint_path)) + return resume_epoch + else: + _logger.error("No checkpoint found at '{}'".format(checkpoint_path)) + raise FileNotFoundError() + + +def load_pretrained( + model, cfg=None, num_classes=1000, in_chans=3, filter_fn=None, strict=True +): + if cfg is None: + cfg = getattr(model, "default_cfg") + if cfg is None or "url" not in cfg or not cfg["url"]: + _logger.warning("Pretrained model URL is invalid, using random initialization.") + return + + state_dict = model_zoo.load_url(cfg["url"], progress=False, map_location="cpu") + + if filter_fn is not None: + state_dict = filter_fn(state_dict) + + if in_chans == 1: + conv1_name = cfg["first_conv"] + _logger.info( + "Converting first conv (%s) pretrained weights from 3 to 1 channel" + % conv1_name + ) + conv1_weight = state_dict[conv1_name + ".weight"] + # Some weights are in torch.half, ensure it's float for sum on CPU + conv1_type = conv1_weight.dtype + conv1_weight = conv1_weight.float() + O, I, J, K = conv1_weight.shape + if I > 3: + assert conv1_weight.shape[1] % 3 == 0 + # For models with space2depth stems + conv1_weight = conv1_weight.reshape(O, I // 3, 3, J, K) + conv1_weight = conv1_weight.sum(dim=2, keepdim=False) + else: + conv1_weight = conv1_weight.sum(dim=1, keepdim=True) + conv1_weight = conv1_weight.to(conv1_type) + state_dict[conv1_name + ".weight"] = conv1_weight + elif in_chans != 3: + conv1_name = cfg["first_conv"] + conv1_weight = state_dict[conv1_name + ".weight"] + conv1_type = conv1_weight.dtype + conv1_weight = conv1_weight.float() + O, I, J, K = conv1_weight.shape + if I != 3: + _logger.warning( + "Deleting first conv (%s) from pretrained weights." % conv1_name + ) + del state_dict[conv1_name + ".weight"] + strict = False + else: + # NOTE this strategy should be better than random init, but there could be other combinations of + # the original RGB input layer weights that'd work better for specific cases. + _logger.info( + "Repeating first conv (%s) weights in channel dim." % conv1_name + ) + repeat = int(math.ceil(in_chans / 3)) + conv1_weight = conv1_weight.repeat(1, repeat, 1, 1)[:, :in_chans, :, :] + conv1_weight *= 3 / float(in_chans) + conv1_weight = conv1_weight.to(conv1_type) + state_dict[conv1_name + ".weight"] = conv1_weight + + classifier_name = cfg["classifier"] + if num_classes == 1000 and cfg["num_classes"] == 1001: + # special case for imagenet trained models with extra background class in pretrained weights + classifier_weight = state_dict[classifier_name + ".weight"] + state_dict[classifier_name + ".weight"] = classifier_weight[1:] + classifier_bias = state_dict[classifier_name + ".bias"] + state_dict[classifier_name + ".bias"] = classifier_bias[1:] + elif num_classes != cfg["num_classes"]: + # completely discard fully connected for all other differences between pretrained and created model + del state_dict[classifier_name + ".weight"] + del state_dict[classifier_name + ".bias"] + strict = False + + model.load_state_dict(state_dict, strict=strict) + + +def extract_layer(model, layer): + layer = layer.split(".") + module = model + if hasattr(model, "module") and layer[0] != "module": + module = model.module + if not hasattr(model, "module") and layer[0] == "module": + layer = layer[1:] + for l in layer: + if hasattr(module, l): + if not l.isdigit(): + module = getattr(module, l) + else: + module = module[int(l)] + else: + return module + return module + + +def set_layer(model, layer, val): + layer = layer.split(".") + module = model + if hasattr(model, "module") and layer[0] != "module": + module = model.module + lst_index = 0 + module2 = module + for l in layer: + if hasattr(module2, l): + if not l.isdigit(): + module2 = getattr(module2, l) + else: + module2 = module2[int(l)] + lst_index += 1 + lst_index -= 1 + for l in layer[:lst_index]: + if not l.isdigit(): + module = getattr(module, l) + else: + module = module[int(l)] + l = layer[lst_index] + setattr(module, l, val) + + +def adapt_model_from_string(parent_module, model_string): + separator = "***" + state_dict = {} + lst_shape = model_string.split(separator) + for k in lst_shape: + k = k.split(":") + key = k[0] + shape = k[1][1:-1].split(",") + if shape[0] != "": + state_dict[key] = [int(i) for i in shape] + + new_module = deepcopy(parent_module) + for n, m in parent_module.named_modules(): + old_module = extract_layer(parent_module, n) + if isinstance(old_module, nn.Conv2d) or isinstance(old_module, Conv2dSame): + if isinstance(old_module, Conv2dSame): + conv = Conv2dSame + else: + conv = nn.Conv2d + s = state_dict[n + ".weight"] + in_channels = s[1] + out_channels = s[0] + g = 1 + if old_module.groups > 1: + in_channels = out_channels + g = in_channels + new_conv = conv( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=old_module.kernel_size, + bias=old_module.bias is not None, + padding=old_module.padding, + dilation=old_module.dilation, + groups=g, + stride=old_module.stride, + ) + set_layer(new_module, n, new_conv) + if isinstance(old_module, nn.BatchNorm2d): + new_bn = nn.BatchNorm2d( + num_features=state_dict[n + ".weight"][0], + eps=old_module.eps, + momentum=old_module.momentum, + affine=old_module.affine, + track_running_stats=True, + ) + set_layer(new_module, n, new_bn) + if isinstance(old_module, nn.Linear): + # FIXME extra checks to ensure this is actually the FC classifier layer and not a diff Linear layer? + num_features = state_dict[n + ".weight"][1] + new_fc = nn.Linear( + in_features=num_features, + out_features=old_module.out_features, + bias=old_module.bias is not None, + ) + set_layer(new_module, n, new_fc) + if hasattr(new_module, "num_features"): + new_module.num_features = num_features + new_module.eval() + parent_module.eval() + + return new_module + + +def adapt_model_from_file(parent_module, model_variant): + adapt_file = os.path.join( + os.path.dirname(__file__), "pruned", model_variant + ".txt" + ) + with open(adapt_file, "r") as f: + return adapt_model_from_string(parent_module, f.read().strip()) + + +def build_model_with_cfg( + model_cls: Callable, + variant: str, + pretrained: bool, + default_cfg: dict, + model_cfg: dict = None, + feature_cfg: dict = None, + pretrained_strict: bool = True, + pretrained_filter_fn: Callable = None, + **kwargs, +): + pruned = kwargs.pop("pruned", False) + features = False + feature_cfg = feature_cfg or {} + + if kwargs.pop("features_only", False): + features = True + feature_cfg.setdefault("out_indices", (0, 1, 2, 3, 4)) + if "out_indices" in kwargs: + feature_cfg["out_indices"] = kwargs.pop("out_indices") + + model = ( + model_cls(**kwargs) if model_cfg is None else model_cls(cfg=model_cfg, **kwargs) + ) + model.default_cfg = deepcopy(default_cfg) + + if pruned: + model = adapt_model_from_file(model, variant) + + if pretrained: + load_pretrained( + model, + num_classes=kwargs.get("num_classes", 0), + in_chans=kwargs.get("in_chans", 3), + filter_fn=pretrained_filter_fn, + strict=pretrained_strict, + ) + + if features: + feature_cls = FeatureListNet + if "feature_cls" in feature_cfg: + feature_cls = feature_cfg.pop("feature_cls") + if isinstance(feature_cls, str): + feature_cls = feature_cls.lower() + if "hook" in feature_cls: + feature_cls = FeatureHookNet + else: + assert False, f"Unknown feature class {feature_cls}" + model = feature_cls(model, **feature_cfg) + + return model diff --git a/Transformer-Explainability/baselines/ViT/imagenet_seg_eval.py b/Transformer-Explainability/baselines/ViT/imagenet_seg_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..e0723773a224ab218e91906e491f8a6a408180a9 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/imagenet_seg_eval.py @@ -0,0 +1,380 @@ +import argparse +import os + +import imageio +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch.nn.functional as F +import torchvision.transforms as transforms +from data.Imagenet import Imagenet_Segmentation +from numpy import * +from PIL import Image +from sklearn.metrics import precision_recall_curve +from torch.utils.data import DataLoader +from tqdm import tqdm +from utils import render +from utils.iou import IoU +from utils.metrices import * +from utils.saver import Saver +from ViT_explanation_generator import LRP, Baselines +from ViT_LRP import vit_base_patch16_224 as vit_LRP +from ViT_new import vit_base_patch16_224 +from ViT_orig_LRP import vit_base_patch16_224 as vit_orig_LRP + +plt.switch_backend("agg") + + +# hyperparameters +num_workers = 0 +batch_size = 1 + +cls = [ + "airplane", + "bicycle", + "bird", + "boat", + "bottle", + "bus", + "car", + "cat", + "chair", + "cow", + "dining table", + "dog", + "horse", + "motobike", + "person", + "potted plant", + "sheep", + "sofa", + "train", + "tv", +] + +# Args +parser = argparse.ArgumentParser(description="Training multi-class classifier") +parser.add_argument( + "--arc", type=str, default="vgg", metavar="N", help="Model architecture" +) +parser.add_argument( + "--train_dataset", type=str, default="imagenet", metavar="N", help="Testing Dataset" +) +parser.add_argument( + "--method", + type=str, + default="grad_rollout", + choices=[ + "rollout", + "lrp", + "transformer_attribution", + "full_lrp", + "lrp_last_layer", + "attn_last_layer", + "attn_gradcam", + ], + help="", +) +parser.add_argument("--thr", type=float, default=0.0, help="threshold") +parser.add_argument("--K", type=int, default=1, help="new - top K results") +parser.add_argument("--save-img", action="store_true", default=False, help="") +parser.add_argument("--no-ia", action="store_true", default=False, help="") +parser.add_argument("--no-fx", action="store_true", default=False, help="") +parser.add_argument("--no-fgx", action="store_true", default=False, help="") +parser.add_argument("--no-m", action="store_true", default=False, help="") +parser.add_argument("--no-reg", action="store_true", default=False, help="") +parser.add_argument("--is-ablation", type=bool, default=False, help="") +parser.add_argument("--imagenet-seg-path", type=str, required=True) +args = parser.parse_args() + +args.checkname = args.method + "_" + args.arc + +alpha = 2 + +cuda = torch.cuda.is_available() +device = torch.device("cuda" if cuda else "cpu") + +# Define Saver +saver = Saver(args) +saver.results_dir = os.path.join(saver.experiment_dir, "results") +if not os.path.exists(saver.results_dir): + os.makedirs(saver.results_dir) +if not os.path.exists(os.path.join(saver.results_dir, "input")): + os.makedirs(os.path.join(saver.results_dir, "input")) +if not os.path.exists(os.path.join(saver.results_dir, "explain")): + os.makedirs(os.path.join(saver.results_dir, "explain")) + +args.exp_img_path = os.path.join(saver.results_dir, "explain/img") +if not os.path.exists(args.exp_img_path): + os.makedirs(args.exp_img_path) +args.exp_np_path = os.path.join(saver.results_dir, "explain/np") +if not os.path.exists(args.exp_np_path): + os.makedirs(args.exp_np_path) + +# Data +normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) +test_img_trans = transforms.Compose( + [ + transforms.Resize((224, 224)), + transforms.ToTensor(), + normalize, + ] +) +test_lbl_trans = transforms.Compose( + [ + transforms.Resize((224, 224), Image.NEAREST), + ] +) + +ds = Imagenet_Segmentation( + args.imagenet_seg_path, transform=test_img_trans, target_transform=test_lbl_trans +) +dl = DataLoader( + ds, batch_size=batch_size, shuffle=False, num_workers=1, drop_last=False +) + +# Model +model = vit_base_patch16_224(pretrained=True).cuda() +baselines = Baselines(model) + +# LRP +model_LRP = vit_LRP(pretrained=True).cuda() +model_LRP.eval() +lrp = LRP(model_LRP) + +# orig LRP +model_orig_LRP = vit_orig_LRP(pretrained=True).cuda() +model_orig_LRP.eval() +orig_lrp = LRP(model_orig_LRP) + +metric = IoU(2, ignore_index=-1) + +iterator = tqdm(dl) + +model.eval() + + +def compute_pred(output): + pred = output.data.max(1, keepdim=True)[ + 1 + ] # get the index of the max log-probability + # pred[0, 0] = 282 + # print('Pred cls : ' + str(pred)) + T = pred.squeeze().cpu().numpy() + T = np.expand_dims(T, 0) + T = (T[:, np.newaxis] == np.arange(1000)) * 1.0 + T = torch.from_numpy(T).type(torch.FloatTensor) + Tt = T.cuda() + + return Tt + + +def eval_batch(image, labels, evaluator, index): + evaluator.zero_grad() + # Save input image + if args.save_img: + img = image[0].permute(1, 2, 0).data.cpu().numpy() + img = 255 * (img - img.min()) / (img.max() - img.min()) + img = img.astype("uint8") + Image.fromarray(img, "RGB").save( + os.path.join(saver.results_dir, "input/{}_input.png".format(index)) + ) + Image.fromarray( + (labels.repeat(3, 1, 1).permute(1, 2, 0).data.cpu().numpy() * 255).astype( + "uint8" + ), + "RGB", + ).save(os.path.join(saver.results_dir, "input/{}_mask.png".format(index))) + + image.requires_grad = True + + image = image.requires_grad_() + predictions = evaluator(image) + + # segmentation test for the rollout baseline + if args.method == "rollout": + Res = baselines.generate_rollout(image.cuda(), start_layer=1).reshape( + batch_size, 1, 14, 14 + ) + + # segmentation test for the LRP baseline (this is full LRP, not partial) + elif args.method == "full_lrp": + Res = orig_lrp.generate_LRP(image.cuda(), method="full").reshape( + batch_size, 1, 224, 224 + ) + + # segmentation test for our method + elif args.method == "transformer_attribution": + Res = lrp.generate_LRP( + image.cuda(), start_layer=1, method="transformer_attribution" + ).reshape(batch_size, 1, 14, 14) + + # segmentation test for the partial LRP baseline (last attn layer) + elif args.method == "lrp_last_layer": + Res = orig_lrp.generate_LRP( + image.cuda(), method="last_layer", is_ablation=args.is_ablation + ).reshape(batch_size, 1, 14, 14) + + # segmentation test for the raw attention baseline (last attn layer) + elif args.method == "attn_last_layer": + Res = orig_lrp.generate_LRP( + image.cuda(), method="last_layer_attn", is_ablation=args.is_ablation + ).reshape(batch_size, 1, 14, 14) + + # segmentation test for the GradCam baseline (last attn layer) + elif args.method == "attn_gradcam": + Res = baselines.generate_cam_attn(image.cuda()).reshape(batch_size, 1, 14, 14) + + if args.method != "full_lrp": + # interpolate to full image size (224,224) + Res = torch.nn.functional.interpolate( + Res, scale_factor=16, mode="bilinear" + ).cuda() + + # threshold between FG and BG is the mean + Res = (Res - Res.min()) / (Res.max() - Res.min()) + + ret = Res.mean() + + Res_1 = Res.gt(ret).type(Res.type()) + Res_0 = Res.le(ret).type(Res.type()) + + Res_1_AP = Res + Res_0_AP = 1 - Res + + Res_1[Res_1 != Res_1] = 0 + Res_0[Res_0 != Res_0] = 0 + Res_1_AP[Res_1_AP != Res_1_AP] = 0 + Res_0_AP[Res_0_AP != Res_0_AP] = 0 + + # TEST + pred = Res.clamp(min=args.thr) / Res.max() + pred = pred.view(-1).data.cpu().numpy() + target = labels.view(-1).data.cpu().numpy() + # print("target", target.shape) + + output = torch.cat((Res_0, Res_1), 1) + output_AP = torch.cat((Res_0_AP, Res_1_AP), 1) + + if args.save_img: + # Save predicted mask + mask = F.interpolate(Res_1, [64, 64], mode="bilinear") + mask = mask[0].squeeze().data.cpu().numpy() + # mask = Res_1[0].squeeze().data.cpu().numpy() + mask = 255 * mask + mask = mask.astype("uint8") + imageio.imsave( + os.path.join(args.exp_img_path, "mask_" + str(index) + ".jpg"), mask + ) + + relevance = F.interpolate(Res, [64, 64], mode="bilinear") + relevance = relevance[0].permute(1, 2, 0).data.cpu().numpy() + # relevance = Res[0].permute(1, 2, 0).data.cpu().numpy() + hm = np.sum(relevance, axis=-1) + maps = (render.hm_to_rgb(hm, scaling=3, sigma=1, cmap="seismic") * 255).astype( + np.uint8 + ) + imageio.imsave( + os.path.join(args.exp_img_path, "heatmap_" + str(index) + ".jpg"), maps + ) + + # Evaluate Segmentation + batch_inter, batch_union, batch_correct, batch_label = 0, 0, 0, 0 + batch_ap, batch_f1 = 0, 0 + + # Segmentation resutls + correct, labeled = batch_pix_accuracy(output[0].data.cpu(), labels[0]) + inter, union = batch_intersection_union(output[0].data.cpu(), labels[0], 2) + batch_correct += correct + batch_label += labeled + batch_inter += inter + batch_union += union + # print("output", output.shape) + # print("ap labels", labels.shape) + # ap = np.nan_to_num(get_ap_scores(output, labels)) + ap = np.nan_to_num(get_ap_scores(output_AP, labels)) + f1 = np.nan_to_num(get_f1_scores(output[0, 1].data.cpu(), labels[0])) + batch_ap += ap + batch_f1 += f1 + + return ( + batch_correct, + batch_label, + batch_inter, + batch_union, + batch_ap, + batch_f1, + pred, + target, + ) + + +total_inter, total_union, total_correct, total_label = ( + np.int64(0), + np.int64(0), + np.int64(0), + np.int64(0), +) +total_ap, total_f1 = [], [] + +predictions, targets = [], [] +for batch_idx, (image, labels) in enumerate(iterator): + if args.method == "blur": + images = (image[0].cuda(), image[1].cuda()) + else: + images = image.cuda() + labels = labels.cuda() + # print("image", image.shape) + # print("lables", labels.shape) + + correct, labeled, inter, union, ap, f1, pred, target = eval_batch( + images, labels, model, batch_idx + ) + + predictions.append(pred) + targets.append(target) + + total_correct += correct.astype("int64") + total_label += labeled.astype("int64") + total_inter += inter.astype("int64") + total_union += union.astype("int64") + total_ap += [ap] + total_f1 += [f1] + pixAcc = ( + np.float64(1.0) + * total_correct + / (np.spacing(1, dtype=np.float64) + total_label) + ) + IoU = ( + np.float64(1.0) * total_inter / (np.spacing(1, dtype=np.float64) + total_union) + ) + mIoU = IoU.mean() + mAp = np.mean(total_ap) + mF1 = np.mean(total_f1) + iterator.set_description( + "pixAcc: %.4f, mIoU: %.4f, mAP: %.4f, mF1: %.4f" % (pixAcc, mIoU, mAp, mF1) + ) + +predictions = np.concatenate(predictions) +targets = np.concatenate(targets) +pr, rc, thr = precision_recall_curve(targets, predictions) +np.save(os.path.join(saver.experiment_dir, "precision.npy"), pr) +np.save(os.path.join(saver.experiment_dir, "recall.npy"), rc) + +plt.figure() +plt.plot(rc, pr) +plt.savefig(os.path.join(saver.experiment_dir, "PR_curve_{}.png".format(args.method))) + +txtfile = os.path.join(saver.experiment_dir, "result_mIoU_%.4f.txt" % mIoU) +# txtfile = 'result_mIoU_%.4f.txt' % mIoU +fh = open(txtfile, "w") +print("Mean IoU over %d classes: %.4f\n" % (2, mIoU)) +print("Pixel-wise Accuracy: %2.2f%%\n" % (pixAcc * 100)) +print("Mean AP over %d classes: %.4f\n" % (2, mAp)) +print("Mean F1 over %d classes: %.4f\n" % (2, mF1)) + +fh.write("Mean IoU over %d classes: %.4f\n" % (2, mIoU)) +fh.write("Pixel-wise Accuracy: %2.2f%%\n" % (pixAcc * 100)) +fh.write("Mean AP over %d classes: %.4f\n" % (2, mAp)) +fh.write("Mean F1 over %d classes: %.4f\n" % (2, mF1)) +fh.close() diff --git a/Transformer-Explainability/baselines/ViT/layer_helpers.py b/Transformer-Explainability/baselines/ViT/layer_helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..d4b5443db79e836a829b2e9770fa40a40b0dfc2d --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/layer_helpers.py @@ -0,0 +1,22 @@ +""" Layer/Module Helpers +Hacked together by / Copyright 2020 Ross Wightman +""" +import collections.abc +from itertools import repeat + + +# From PyTorch internals +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable): + return x + return tuple(repeat(x, n)) + + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = _ntuple diff --git a/Transformer-Explainability/baselines/ViT/misc_functions.py b/Transformer-Explainability/baselines/ViT/misc_functions.py new file mode 100644 index 0000000000000000000000000000000000000000..9872864198a9a037d099439dd22899b342c72e83 --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/misc_functions.py @@ -0,0 +1,68 @@ +# +# Copyright (c) 2019 Idiap Research Institute, http://www.idiap.ch/ +# Written by Suraj Srinivas +# + +""" Misc helper functions """ + +import subprocess + +import cv2 +import numpy as np +import torch +import torchvision.transforms as transforms + + +class NormalizeInverse(transforms.Normalize): + # Undo normalization on images + + def __init__(self, mean, std): + mean = torch.as_tensor(mean) + std = torch.as_tensor(std) + std_inv = 1 / (std + 1e-7) + mean_inv = -mean * std_inv + super(NormalizeInverse, self).__init__(mean=mean_inv, std=std_inv) + + def __call__(self, tensor): + return super(NormalizeInverse, self).__call__(tensor.clone()) + + +def create_folder(folder_name): + try: + subprocess.call(["mkdir", "-p", folder_name]) + except OSError: + None + + +def save_saliency_map(image, saliency_map, filename): + """ + Save saliency map on image. + + Args: + image: Tensor of size (3,H,W) + saliency_map: Tensor of size (1,H,W) + filename: string with complete path and file extension + + """ + + image = image.data.cpu().numpy() + saliency_map = saliency_map.data.cpu().numpy() + + saliency_map = saliency_map - saliency_map.min() + saliency_map = saliency_map / saliency_map.max() + saliency_map = saliency_map.clip(0, 1) + + saliency_map = np.uint8(saliency_map * 255).transpose(1, 2, 0) + saliency_map = cv2.resize(saliency_map, (224, 224)) + + image = np.uint8(image * 255).transpose(1, 2, 0) + image = cv2.resize(image, (224, 224)) + + # Apply JET colormap + color_heatmap = cv2.applyColorMap(saliency_map, cv2.COLORMAP_JET) + + # Combine image with heatmap + img_with_heatmap = np.float32(color_heatmap) + np.float32(image) + img_with_heatmap = img_with_heatmap / np.max(img_with_heatmap) + + cv2.imwrite(filename, np.uint8(255 * img_with_heatmap)) diff --git a/Transformer-Explainability/baselines/ViT/pertubation_eval_from_hdf5.py b/Transformer-Explainability/baselines/ViT/pertubation_eval_from_hdf5.py new file mode 100644 index 0000000000000000000000000000000000000000..60ff8bcb6ba3c298f6e08788c34a1d1738491f3c --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/pertubation_eval_from_hdf5.py @@ -0,0 +1,274 @@ +import argparse +# from models.vgg import vgg19 +import glob +import os + +import numpy as np +import torch +from dataset.expl_hdf5 import ImagenetResults +from tqdm import tqdm +# Import saliency methods and models +from ViT_explanation_generator import Baselines +from ViT_new import vit_base_patch16_224 + + +def normalize(tensor, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]): + dtype = tensor.dtype + mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device) + std = torch.as_tensor(std, dtype=dtype, device=tensor.device) + tensor.sub_(mean[None, :, None, None]).div_(std[None, :, None, None]) + return tensor + + +def eval(args): + num_samples = 0 + num_correct_model = np.zeros( + ( + len( + imagenet_ds, + ) + ) + ) + dissimilarity_model = np.zeros( + ( + len( + imagenet_ds, + ) + ) + ) + model_index = 0 + + if args.scale == "per": + base_size = 224 * 224 + perturbation_steps = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] + elif args.scale == "100": + base_size = 100 + perturbation_steps = [5, 10, 15, 20, 25, 30, 35, 40, 45] + else: + raise Exception("scale not valid") + + num_correct_pertub = np.zeros((9, len(imagenet_ds))) + dissimilarity_pertub = np.zeros((9, len(imagenet_ds))) + logit_diff_pertub = np.zeros((9, len(imagenet_ds))) + prob_diff_pertub = np.zeros((9, len(imagenet_ds))) + perturb_index = 0 + + for batch_idx, (data, vis, target) in enumerate(tqdm(sample_loader)): + # Update the number of samples + num_samples += len(data) + + data = data.to(device) + vis = vis.to(device) + target = target.to(device) + norm_data = normalize(data.clone()) + + # Compute model accuracy + pred = model(norm_data) + pred_probabilities = torch.softmax(pred, dim=1) + pred_org_logit = pred.data.max(1, keepdim=True)[0].squeeze(1) + pred_org_prob = pred_probabilities.data.max(1, keepdim=True)[0].squeeze(1) + pred_class = pred.data.max(1, keepdim=True)[1].squeeze(1) + tgt_pred = (target == pred_class).type(target.type()).data.cpu().numpy() + num_correct_model[model_index : model_index + len(tgt_pred)] = tgt_pred + + probs = torch.softmax(pred, dim=1) + target_probs = torch.gather(probs, 1, target[:, None])[:, 0] + second_probs = probs.data.topk(2, dim=1)[0][:, 1] + temp = torch.log(target_probs / second_probs).data.cpu().numpy() + dissimilarity_model[model_index : model_index + len(temp)] = temp + + if args.wrong: + wid = np.argwhere(tgt_pred == 0).flatten() + if len(wid) == 0: + continue + wid = torch.from_numpy(wid).to(vis.device) + vis = vis.index_select(0, wid) + data = data.index_select(0, wid) + target = target.index_select(0, wid) + + # Save original shape + org_shape = data.shape + + if args.neg: + vis = -vis + + vis = vis.reshape(org_shape[0], -1) + + for i in range(len(perturbation_steps)): + _data = data.clone() + + _, idx = torch.topk(vis, int(base_size * perturbation_steps[i]), dim=-1) + idx = idx.unsqueeze(1).repeat(1, org_shape[1], 1) + _data = _data.reshape(org_shape[0], org_shape[1], -1) + _data = _data.scatter_(-1, idx, 0) + _data = _data.reshape(*org_shape) + + _norm_data = normalize(_data) + + out = model(_norm_data) + + pred_probabilities = torch.softmax(out, dim=1) + pred_prob = pred_probabilities.data.max(1, keepdim=True)[0].squeeze(1) + diff = (pred_prob - pred_org_prob).data.cpu().numpy() + prob_diff_pertub[i, perturb_index : perturb_index + len(diff)] = diff + + pred_logit = out.data.max(1, keepdim=True)[0].squeeze(1) + diff = (pred_logit - pred_org_logit).data.cpu().numpy() + logit_diff_pertub[i, perturb_index : perturb_index + len(diff)] = diff + + target_class = out.data.max(1, keepdim=True)[1].squeeze(1) + temp = (target == target_class).type(target.type()).data.cpu().numpy() + num_correct_pertub[i, perturb_index : perturb_index + len(temp)] = temp + + probs_pertub = torch.softmax(out, dim=1) + target_probs = torch.gather(probs_pertub, 1, target[:, None])[:, 0] + second_probs = probs_pertub.data.topk(2, dim=1)[0][:, 1] + temp = torch.log(target_probs / second_probs).data.cpu().numpy() + dissimilarity_pertub[i, perturb_index : perturb_index + len(temp)] = temp + + model_index += len(target) + perturb_index += len(target) + + np.save(os.path.join(args.experiment_dir, "model_hits.npy"), num_correct_model) + np.save( + os.path.join(args.experiment_dir, "model_dissimilarities.npy"), + dissimilarity_model, + ) + np.save( + os.path.join(args.experiment_dir, "perturbations_hits.npy"), + num_correct_pertub[:, :perturb_index], + ) + np.save( + os.path.join(args.experiment_dir, "perturbations_dissimilarities.npy"), + dissimilarity_pertub[:, :perturb_index], + ) + np.save( + os.path.join(args.experiment_dir, "perturbations_logit_diff.npy"), + logit_diff_pertub[:, :perturb_index], + ) + np.save( + os.path.join(args.experiment_dir, "perturbations_prob_diff.npy"), + prob_diff_pertub[:, :perturb_index], + ) + + print(np.mean(num_correct_model), np.std(num_correct_model)) + print(np.mean(dissimilarity_model), np.std(dissimilarity_model)) + print(perturbation_steps) + print(np.mean(num_correct_pertub, axis=1), np.std(num_correct_pertub, axis=1)) + print(np.mean(dissimilarity_pertub, axis=1), np.std(dissimilarity_pertub, axis=1)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Train a segmentation") + parser.add_argument("--batch-size", type=int, default=16, help="") + parser.add_argument("--neg", type=bool, default=True, help="") + parser.add_argument("--value", action="store_true", default=False, help="") + parser.add_argument( + "--scale", type=str, default="per", choices=["per", "100"], help="" + ) + parser.add_argument( + "--method", + type=str, + default="grad_rollout", + choices=[ + "rollout", + "lrp", + "transformer_attribution", + "full_lrp", + "v_gradcam", + "lrp_last_layer", + "lrp_second_layer", + "gradcam", + "attn_last_layer", + "attn_gradcam", + "input_grads", + ], + help="", + ) + parser.add_argument( + "--vis-class", + type=str, + default="top", + choices=["top", "target", "index"], + help="", + ) + parser.add_argument("--wrong", action="store_true", default=False, help="") + parser.add_argument("--class-id", type=int, default=0, help="") + parser.add_argument("--is-ablation", type=bool, default=False, help="") + args = parser.parse_args() + + torch.multiprocessing.set_start_method("spawn") + + # PATH variables + PATH = os.path.dirname(os.path.abspath(__file__)) + "/" + dataset = PATH + "dataset/" + os.makedirs(os.path.join(PATH, "experiments"), exist_ok=True) + os.makedirs(os.path.join(PATH, "experiments/perturbations"), exist_ok=True) + + exp_name = args.method + exp_name += "_neg" if args.neg else "_pos" + print(exp_name) + + if args.vis_class == "index": + args.runs_dir = os.path.join( + PATH, + "experiments/perturbations/{}/{}_{}".format( + exp_name, args.vis_class, args.class_id + ), + ) + else: + ablation_fold = "ablation" if args.is_ablation else "not_ablation" + args.runs_dir = os.path.join( + PATH, + "experiments/perturbations/{}/{}/{}".format( + exp_name, args.vis_class, ablation_fold + ), + ) + # args.runs_dir = os.path.join(PATH, 'experiments/perturbations/{}/{}'.format(exp_name, + # args.vis_class)) + + if args.wrong: + args.runs_dir += "_wrong" + + experiments = sorted(glob.glob(os.path.join(args.runs_dir, "experiment_*"))) + experiment_id = int(experiments[-1].split("_")[-1]) + 1 if experiments else 0 + args.experiment_dir = os.path.join( + args.runs_dir, "experiment_{}".format(str(experiment_id)) + ) + os.makedirs(args.experiment_dir, exist_ok=True) + + cuda = torch.cuda.is_available() + device = torch.device("cuda" if cuda else "cpu") + + if args.vis_class == "index": + vis_method_dir = os.path.join( + PATH, + "visualizations/{}/{}_{}".format( + args.method, args.vis_class, args.class_id + ), + ) + else: + ablation_fold = "ablation" if args.is_ablation else "not_ablation" + vis_method_dir = os.path.join( + PATH, + "visualizations/{}/{}/{}".format( + args.method, args.vis_class, ablation_fold + ), + ) + # vis_method_dir = os.path.join(PATH, 'visualizations/{}/{}'.format(args.method, + # args.vis_class)) + + # imagenet_ds = ImagenetResults('visualizations/{}'.format(args.method)) + imagenet_ds = ImagenetResults(vis_method_dir) + + # Model + model = vit_base_patch16_224(pretrained=True).cuda() + model.eval() + + save_path = PATH + "results/" + + sample_loader = torch.utils.data.DataLoader( + imagenet_ds, batch_size=args.batch_size, num_workers=2, shuffle=False + ) + + eval(args) diff --git a/Transformer-Explainability/baselines/ViT/weight_init.py b/Transformer-Explainability/baselines/ViT/weight_init.py new file mode 100644 index 0000000000000000000000000000000000000000..67091a63d8519051bb8255687973454f0749319c --- /dev/null +++ b/Transformer-Explainability/baselines/ViT/weight_init.py @@ -0,0 +1,63 @@ +import math +import warnings + +import torch + + +def _no_grad_trunc_normal_(tensor, mean, std, a, b): + # Cut & paste from PyTorch official master until it's in a few official releases - RW + # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf + def norm_cdf(x): + # Computes standard normal cumulative distribution function + return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0 + + if (mean < a - 2 * std) or (mean > b + 2 * std): + warnings.warn( + "mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " + "The distribution of values may be incorrect.", + stacklevel=2, + ) + + with torch.no_grad(): + # Values are generated by using a truncated uniform distribution and + # then using the inverse CDF for the normal distribution. + # Get upper and lower cdf values + l = norm_cdf((a - mean) / std) + u = norm_cdf((b - mean) / std) + + # Uniformly fill tensor with values from [l, u], then translate to + # [2l-1, 2u-1]. + tensor.uniform_(2 * l - 1, 2 * u - 1) + + # Use inverse cdf transform for normal distribution to get truncated + # standard normal + tensor.erfinv_() + + # Transform to proper mean, std + tensor.mul_(std * math.sqrt(2.0)) + tensor.add_(mean) + + # Clamp to ensure it's in the proper range + tensor.clamp_(min=a, max=b) + return tensor + + +def trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0): + # type: (Tensor, float, float, float, float) -> Tensor + r"""Fills the input Tensor with values drawn from a truncated + normal distribution. The values are effectively drawn from the + normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)` + with values outside :math:`[a, b]` redrawn until they are within + the bounds. The method used for generating the random values works + best when :math:`a \leq \text{mean} \leq b`. + Args: + tensor: an n-dimensional `torch.Tensor` + mean: the mean of the normal distribution + std: the standard deviation of the normal distribution + a: the minimum cutoff value + b: the maximum cutoff value + Examples: + >>> w = torch.empty(3, 5) + >>> nn.init.trunc_normal_(w) + """ + return _no_grad_trunc_normal_(tensor, mean, std, a, b) diff --git a/Transformer-Explainability/data/Imagenet.py b/Transformer-Explainability/data/Imagenet.py new file mode 100644 index 0000000000000000000000000000000000000000..886fb038d384c704949017f66dd9f49f13bf60dd --- /dev/null +++ b/Transformer-Explainability/data/Imagenet.py @@ -0,0 +1,207 @@ +import os +from glob import glob + +import cv2 +import h5py +import numpy as np +import torch +import torch.utils.data as data +from PIL import Image, ImageFilter +from torchvision.datasets import ImageNet + + +class ImageNet_blur(ImageNet): + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (sample, target) where target is class_index of the target class. + """ + path, target = self.samples[index] + sample = self.loader(path) + + gauss_blur = ImageFilter.GaussianBlur(11) + median_blur = ImageFilter.MedianFilter(11) + + blurred_img1 = sample.filter(gauss_blur) + blurred_img2 = sample.filter(median_blur) + blurred_img = Image.blend(blurred_img1, blurred_img2, 0.5) + + if self.transform is not None: + sample = self.transform(sample) + blurred_img = self.transform(blurred_img) + if self.target_transform is not None: + target = self.target_transform(target) + + return (sample, blurred_img), target + + +class Imagenet_Segmentation(data.Dataset): + CLASSES = 2 + + def __init__(self, path, transform=None, target_transform=None): + self.path = path + self.transform = transform + self.target_transform = target_transform + # self.h5py = h5py.File(path, 'r+') + self.h5py = None + tmp = h5py.File(path, "r") + self.data_length = len(tmp["/value/img"]) + tmp.close() + del tmp + + def __getitem__(self, index): + if self.h5py is None: + self.h5py = h5py.File(self.path, "r") + + img = np.array(self.h5py[self.h5py["/value/img"][index, 0]]).transpose( + (2, 1, 0) + ) + target = np.array( + self.h5py[self.h5py[self.h5py["/value/gt"][index, 0]][0, 0]] + ).transpose((1, 0)) + + img = Image.fromarray(img).convert("RGB") + target = Image.fromarray(target) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype("int32") + target = torch.from_numpy(target).long() + + return img, target + + def __len__(self): + # return len(self.h5py['/value/img']) + return self.data_length + + +class Imagenet_Segmentation_Blur(data.Dataset): + CLASSES = 2 + + def __init__(self, path, transform=None, target_transform=None): + self.path = path + self.transform = transform + self.target_transform = target_transform + # self.h5py = h5py.File(path, 'r+') + self.h5py = None + tmp = h5py.File(path, "r") + self.data_length = len(tmp["/value/img"]) + tmp.close() + del tmp + + def __getitem__(self, index): + if self.h5py is None: + self.h5py = h5py.File(self.path, "r") + + img = np.array(self.h5py[self.h5py["/value/img"][index, 0]]).transpose( + (2, 1, 0) + ) + target = np.array( + self.h5py[self.h5py[self.h5py["/value/gt"][index, 0]][0, 0]] + ).transpose((1, 0)) + + img = Image.fromarray(img).convert("RGB") + target = Image.fromarray(target) + + gauss_blur = ImageFilter.GaussianBlur(11) + median_blur = ImageFilter.MedianFilter(11) + + blurred_img1 = img.filter(gauss_blur) + blurred_img2 = img.filter(median_blur) + blurred_img = Image.blend(blurred_img1, blurred_img2, 0.5) + + # blurred_img1 = cv2.GaussianBlur(img, (11, 11), 5) + # blurred_img2 = np.float32(cv2.medianBlur(img, 11)) + # blurred_img = (blurred_img1 + blurred_img2) / 2 + + if self.transform is not None: + img = self.transform(img) + blurred_img = self.transform(blurred_img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype("int32") + target = torch.from_numpy(target).long() + + return (img, blurred_img), target + + def __len__(self): + # return len(self.h5py['/value/img']) + return self.data_length + + +class Imagenet_Segmentation_eval_dir(data.Dataset): + CLASSES = 2 + + def __init__(self, path, eval_path, transform=None, target_transform=None): + self.transform = transform + self.target_transform = target_transform + self.h5py = h5py.File(path, "r+") + + # 500 each file + self.results = glob(os.path.join(eval_path, "*.npy")) + + def __getitem__(self, index): + img = np.array(self.h5py[self.h5py["/value/img"][index, 0]]).transpose( + (2, 1, 0) + ) + target = np.array( + self.h5py[self.h5py[self.h5py["/value/gt"][index, 0]][0, 0]] + ).transpose((1, 0)) + res = np.load(self.results[index]) + + img = Image.fromarray(img).convert("RGB") + target = Image.fromarray(target) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype("int32") + target = torch.from_numpy(target).long() + + return img, target + + def __len__(self): + return len(self.h5py["/value/img"]) + + +if __name__ == "__main__": + import scipy.io as sio + import torchvision.transforms as transforms + from imageio import imsave + from tqdm import tqdm + + # meta = sio.loadmat('/home/shirgur/ext/Data/Datasets/temp/ILSVRC2012_devkit_t12/data/meta.mat', squeeze_me=True)['synsets'] + # Data + normalize = transforms.Normalize( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + test_img_trans = transforms.Compose( + [ + transforms.Resize((224, 224)), + transforms.ToTensor(), + normalize, + ] + ) + test_lbl_trans = transforms.Compose( + [ + transforms.Resize((224, 224), Image.NEAREST), + ] + ) + + ds = Imagenet_Segmentation( + "/home/shirgur/ext/Data/Datasets/imagenet-seg/other/gtsegs_ijcv.mat", + transform=test_img_trans, + target_transform=test_lbl_trans, + ) + + for i, (img, tgt) in enumerate(tqdm(ds)): + tgt = (tgt.numpy() * 255).astype(np.uint8) + imsave("/home/shirgur/ext/Code/C2S/run/imagenet/gt/{}.png".format(i), tgt) + + print("here") diff --git a/Transformer-Explainability/data/VOC.py b/Transformer-Explainability/data/VOC.py new file mode 100644 index 0000000000000000000000000000000000000000..fba1826196825e281a2b6447796a1927080bfd5c --- /dev/null +++ b/Transformer-Explainability/data/VOC.py @@ -0,0 +1,420 @@ +import os +import tarfile + +import h5py +import numpy as np +import torch +import torch.utils.data as data +from PIL import Image +from scipy import io +from torchvision.datasets.utils import download_url + +DATASET_YEAR_DICT = { + "2012": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar", + "filename": "VOCtrainval_11-May-2012.tar", + "md5": "6cd6e144f989b92b3379bac3b3de84fd", + "base_dir": "VOCdevkit/VOC2012", + }, + "2011": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2011/VOCtrainval_25-May-2011.tar", + "filename": "VOCtrainval_25-May-2011.tar", + "md5": "6c3384ef61512963050cb5d687e5bf1e", + "base_dir": "TrainVal/VOCdevkit/VOC2011", + }, + "2010": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar", + "filename": "VOCtrainval_03-May-2010.tar", + "md5": "da459979d0c395079b5c75ee67908abb", + "base_dir": "VOCdevkit/VOC2010", + }, + "2009": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2009/VOCtrainval_11-May-2009.tar", + "filename": "VOCtrainval_11-May-2009.tar", + "md5": "59065e4b188729180974ef6572f6a212", + "base_dir": "VOCdevkit/VOC2009", + }, + "2008": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2008/VOCtrainval_14-Jul-2008.tar", + "filename": "VOCtrainval_11-May-2012.tar", + "md5": "2629fa636546599198acfcfbfcf1904a", + "base_dir": "VOCdevkit/VOC2008", + }, + "2007": { + "url": "http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar", + "filename": "VOCtrainval_06-Nov-2007.tar", + "md5": "c52e279531787c972589f7e41ab4ae64", + "base_dir": "VOCdevkit/VOC2007", + }, +} + + +class VOCSegmentation(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + """ + + CLASSES = 20 + CLASSES_NAMES = [ + "aeroplane", + "bicycle", + "bird", + "boat", + "bottle", + "bus", + "car", + "cat", + "chair", + "cow", + "diningtable", + "dog", + "horse", + "motorbike", + "person", + "potted-plant", + "sheep", + "sofa", + "train", + "tvmonitor", + "ambigious", + ] + + def __init__( + self, + root, + year="2012", + image_set="train", + download=False, + transform=None, + target_transform=None, + ): + self.root = os.path.expanduser(root) + self.year = year + self.url = DATASET_YEAR_DICT[year]["url"] + self.filename = DATASET_YEAR_DICT[year]["filename"] + self.md5 = DATASET_YEAR_DICT[year]["md5"] + self.transform = transform + self.target_transform = target_transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]["base_dir"] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, "JPEGImages") + mask_dir = os.path.join(voc_root, "SegmentationClass") + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError( + "Dataset not found or corrupted." + + " You can use download=True to download it" + ) + + splits_dir = os.path.join(voc_root, "ImageSets/Segmentation") + + split_f = os.path.join(splits_dir, image_set.rstrip("\n") + ".txt") + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"' + ) + + with open(os.path.join(split_f), "r") as f: + file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names] + assert len(self.images) == len(self.masks) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert("RGB") + target = Image.open(self.masks[index]) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype("int32") + target[target == 255] = -1 + target = torch.from_numpy(target).long() + + return img, target + + @staticmethod + def _mask_transform(mask): + target = np.array(mask).astype("int32") + target[target == 255] = -1 + return torch.from_numpy(target).long() + + def __len__(self): + return len(self.images) + + @property + def pred_offset(self): + return 0 + + +class VOCClassification(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + """ + + CLASSES = 20 + + def __init__( + self, root, year="2012", image_set="train", download=False, transform=None + ): + self.root = os.path.expanduser(root) + self.year = year + self.url = DATASET_YEAR_DICT[year]["url"] + self.filename = DATASET_YEAR_DICT[year]["filename"] + self.md5 = DATASET_YEAR_DICT[year]["md5"] + self.transform = transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]["base_dir"] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, "JPEGImages") + mask_dir = os.path.join(voc_root, "SegmentationClass") + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError( + "Dataset not found or corrupted." + + " You can use download=True to download it" + ) + + splits_dir = os.path.join(voc_root, "ImageSets/Segmentation") + + split_f = os.path.join(splits_dir, image_set.rstrip("\n") + ".txt") + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"' + ) + + with open(os.path.join(split_f), "r") as f: + file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names] + assert len(self.images) == len(self.masks) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert("RGB") + target = Image.open(self.masks[index]) + + # if self.transform is not None: + # img = self.transform(img) + if self.transform is not None: + img, target = self.transform(img, target) + + visible_classes = np.unique(target) + labels = torch.zeros(self.CLASSES) + for id in visible_classes: + if id not in (0, 255): + labels[id - 1].fill_(1) + + return img, labels + + def __len__(self): + return len(self.images) + + +class VOCSBDClassification(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + """ + + CLASSES = 20 + + def __init__( + self, + root, + sbd_root, + year="2012", + image_set="train", + download=False, + transform=None, + ): + self.root = os.path.expanduser(root) + self.sbd_root = os.path.expanduser(sbd_root) + self.year = year + self.url = DATASET_YEAR_DICT[year]["url"] + self.filename = DATASET_YEAR_DICT[year]["filename"] + self.md5 = DATASET_YEAR_DICT[year]["md5"] + self.transform = transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]["base_dir"] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, "JPEGImages") + mask_dir = os.path.join(voc_root, "SegmentationClass") + sbd_image_dir = os.path.join(sbd_root, "img") + sbd_mask_dir = os.path.join(sbd_root, "cls") + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError( + "Dataset not found or corrupted." + + " You can use download=True to download it" + ) + + splits_dir = os.path.join(voc_root, "ImageSets/Segmentation") + + split_f = os.path.join(splits_dir, image_set.rstrip("\n") + ".txt") + sbd_split = os.path.join(sbd_root, "train.txt") + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"' + ) + + with open(os.path.join(split_f), "r") as f: + voc_file_names = [x.strip() for x in f.readlines()] + + with open(os.path.join(sbd_split), "r") as f: + sbd_file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in voc_file_names] + self.images += [os.path.join(sbd_image_dir, x + ".jpg") for x in sbd_file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in voc_file_names] + self.masks += [os.path.join(sbd_mask_dir, x + ".mat") for x in sbd_file_names] + assert len(self.images) == len(self.masks) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert("RGB") + mask_path = self.masks[index] + if mask_path[-3:] == "mat": + target = io.loadmat(mask_path, struct_as_record=False, squeeze_me=True)[ + "GTcls" + ].Segmentation + target = Image.fromarray(target, mode="P") + else: + target = Image.open(self.masks[index]) + + if self.transform is not None: + img, target = self.transform(img, target) + + visible_classes = np.unique(target) + labels = torch.zeros(self.CLASSES) + for id in visible_classes: + if id not in (0, 255): + labels[id - 1].fill_(1) + + return img, labels + + def __len__(self): + return len(self.images) + + +def download_extract(url, root, filename, md5): + download_url(url, root, filename, md5) + with tarfile.open(os.path.join(root, filename), "r") as tar: + tar.extractall(path=root) + + +class VOCResults(data.Dataset): + CLASSES = 20 + CLASSES_NAMES = [ + "aeroplane", + "bicycle", + "bird", + "boat", + "bottle", + "bus", + "car", + "cat", + "chair", + "cow", + "diningtable", + "dog", + "horse", + "motorbike", + "person", + "potted-plant", + "sheep", + "sofa", + "train", + "tvmonitor", + "ambigious", + ] + + def __init__(self, path): + super(VOCResults, self).__init__() + + self.path = os.path.join(path, "results.hdf5") + self.data = None + + print("Reading dataset length...") + with h5py.File(self.path, "r") as f: + self.data_length = len(f["/image"]) + + def __len__(self): + return self.data_length + + def __getitem__(self, item): + if self.data is None: + self.data = h5py.File(self.path, "r") + + image = torch.tensor(self.data["image"][item]) + vis = torch.tensor(self.data["vis"][item]) + target = torch.tensor(self.data["target"][item]) + class_pred = torch.tensor(self.data["class_pred"][item]) + + return image, vis, target, class_pred diff --git a/Transformer-Explainability/data/__init__.py b/Transformer-Explainability/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/data/imagenet_utils.py b/Transformer-Explainability/data/imagenet_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..af5399c9778be19ecc5e940fe9191d6f9b71f7d6 --- /dev/null +++ b/Transformer-Explainability/data/imagenet_utils.py @@ -0,0 +1,1002 @@ +CLS2IDX = { + 0: "tench, Tinca tinca", + 1: "goldfish, Carassius auratus", + 2: "great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias", + 3: "tiger shark, Galeocerdo cuvieri", + 4: "hammerhead, hammerhead shark", + 5: "electric ray, crampfish, numbfish, torpedo", + 6: "stingray", + 7: "cock", + 8: "hen", + 9: "ostrich, Struthio camelus", + 10: "brambling, Fringilla montifringilla", + 11: "goldfinch, Carduelis carduelis", + 12: "house finch, linnet, Carpodacus mexicanus", + 13: "junco, snowbird", + 14: "indigo bunting, indigo finch, indigo bird, Passerina cyanea", + 15: "robin, American robin, Turdus migratorius", + 16: "bulbul", + 17: "jay", + 18: "magpie", + 19: "chickadee", + 20: "water ouzel, dipper", + 21: "kite", + 22: "bald eagle, American eagle, Haliaeetus leucocephalus", + 23: "vulture", + 24: "great grey owl, great gray owl, Strix nebulosa", + 25: "European fire salamander, Salamandra salamandra", + 26: "common newt, Triturus vulgaris", + 27: "eft", + 28: "spotted salamander, Ambystoma maculatum", + 29: "axolotl, mud puppy, Ambystoma mexicanum", + 30: "bullfrog, Rana catesbeiana", + 31: "tree frog, tree-frog", + 32: "tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui", + 33: "loggerhead, loggerhead turtle, Caretta caretta", + 34: "leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea", + 35: "mud turtle", + 36: "terrapin", + 37: "box turtle, box tortoise", + 38: "banded gecko", + 39: "common iguana, iguana, Iguana iguana", + 40: "American chameleon, anole, Anolis carolinensis", + 41: "whiptail, whiptail lizard", + 42: "agama", + 43: "frilled lizard, Chlamydosaurus kingi", + 44: "alligator lizard", + 45: "Gila monster, Heloderma suspectum", + 46: "green lizard, Lacerta viridis", + 47: "African chameleon, Chamaeleo chamaeleon", + 48: "Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis", + 49: "African crocodile, Nile crocodile, Crocodylus niloticus", + 50: "American alligator, Alligator mississipiensis", + 51: "triceratops", + 52: "thunder snake, worm snake, Carphophis amoenus", + 53: "ringneck snake, ring-necked snake, ring snake", + 54: "hognose snake, puff adder, sand viper", + 55: "green snake, grass snake", + 56: "king snake, kingsnake", + 57: "garter snake, grass snake", + 58: "water snake", + 59: "vine snake", + 60: "night snake, Hypsiglena torquata", + 61: "boa constrictor, Constrictor constrictor", + 62: "rock python, rock snake, Python sebae", + 63: "Indian cobra, Naja naja", + 64: "green mamba", + 65: "sea snake", + 66: "horned viper, cerastes, sand viper, horned asp, Cerastes cornutus", + 67: "diamondback, diamondback rattlesnake, Crotalus adamanteus", + 68: "sidewinder, horned rattlesnake, Crotalus cerastes", + 69: "trilobite", + 70: "harvestman, daddy longlegs, Phalangium opilio", + 71: "scorpion", + 72: "black and gold garden spider, Argiope aurantia", + 73: "barn spider, Araneus cavaticus", + 74: "garden spider, Aranea diademata", + 75: "black widow, Latrodectus mactans", + 76: "tarantula", + 77: "wolf spider, hunting spider", + 78: "tick", + 79: "centipede", + 80: "black grouse", + 81: "ptarmigan", + 82: "ruffed grouse, partridge, Bonasa umbellus", + 83: "prairie chicken, prairie grouse, prairie fowl", + 84: "peacock", + 85: "quail", + 86: "partridge", + 87: "African grey, African gray, Psittacus erithacus", + 88: "macaw", + 89: "sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita", + 90: "lorikeet", + 91: "coucal", + 92: "bee eater", + 93: "hornbill", + 94: "hummingbird", + 95: "jacamar", + 96: "toucan", + 97: "drake", + 98: "red-breasted merganser, Mergus serrator", + 99: "goose", + 100: "black swan, Cygnus atratus", + 101: "tusker", + 102: "echidna, spiny anteater, anteater", + 103: "platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus", + 104: "wallaby, brush kangaroo", + 105: "koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus", + 106: "wombat", + 107: "jellyfish", + 108: "sea anemone, anemone", + 109: "brain coral", + 110: "flatworm, platyhelminth", + 111: "nematode, nematode worm, roundworm", + 112: "conch", + 113: "snail", + 114: "slug", + 115: "sea slug, nudibranch", + 116: "chiton, coat-of-mail shell, sea cradle, polyplacophore", + 117: "chambered nautilus, pearly nautilus, nautilus", + 118: "Dungeness crab, Cancer magister", + 119: "rock crab, Cancer irroratus", + 120: "fiddler crab", + 121: "king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica", + 122: "American lobster, Northern lobster, Maine lobster, Homarus americanus", + 123: "spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish", + 124: "crayfish, crawfish, crawdad, crawdaddy", + 125: "hermit crab", + 126: "isopod", + 127: "white stork, Ciconia ciconia", + 128: "black stork, Ciconia nigra", + 129: "spoonbill", + 130: "flamingo", + 131: "little blue heron, Egretta caerulea", + 132: "American egret, great white heron, Egretta albus", + 133: "bittern", + 134: "crane", + 135: "limpkin, Aramus pictus", + 136: "European gallinule, Porphyrio porphyrio", + 137: "American coot, marsh hen, mud hen, water hen, Fulica americana", + 138: "bustard", + 139: "ruddy turnstone, Arenaria interpres", + 140: "red-backed sandpiper, dunlin, Erolia alpina", + 141: "redshank, Tringa totanus", + 142: "dowitcher", + 143: "oystercatcher, oyster catcher", + 144: "pelican", + 145: "king penguin, Aptenodytes patagonica", + 146: "albatross, mollymawk", + 147: "grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus", + 148: "killer whale, killer, orca, grampus, sea wolf, Orcinus orca", + 149: "dugong, Dugong dugon", + 150: "sea lion", + 151: "Chihuahua", + 152: "Japanese spaniel", + 153: "Maltese dog, Maltese terrier, Maltese", + 154: "Pekinese, Pekingese, Peke", + 155: "Shih-Tzu", + 156: "Blenheim spaniel", + 157: "papillon", + 158: "toy terrier", + 159: "Rhodesian ridgeback", + 160: "Afghan hound, Afghan", + 161: "basset, basset hound", + 162: "beagle", + 163: "bloodhound, sleuthhound", + 164: "bluetick", + 165: "black-and-tan coonhound", + 166: "Walker hound, Walker foxhound", + 167: "English foxhound", + 168: "redbone", + 169: "borzoi, Russian wolfhound", + 170: "Irish wolfhound", + 171: "Italian greyhound", + 172: "whippet", + 173: "Ibizan hound, Ibizan Podenco", + 174: "Norwegian elkhound, elkhound", + 175: "otterhound, otter hound", + 176: "Saluki, gazelle hound", + 177: "Scottish deerhound, deerhound", + 178: "Weimaraner", + 179: "Staffordshire bullterrier, Staffordshire bull terrier", + 180: "American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier", + 181: "Bedlington terrier", + 182: "Border terrier", + 183: "Kerry blue terrier", + 184: "Irish terrier", + 185: "Norfolk terrier", + 186: "Norwich terrier", + 187: "Yorkshire terrier", + 188: "wire-haired fox terrier", + 189: "Lakeland terrier", + 190: "Sealyham terrier, Sealyham", + 191: "Airedale, Airedale terrier", + 192: "cairn, cairn terrier", + 193: "Australian terrier", + 194: "Dandie Dinmont, Dandie Dinmont terrier", + 195: "Boston bull, Boston terrier", + 196: "miniature schnauzer", + 197: "giant schnauzer", + 198: "standard schnauzer", + 199: "Scotch terrier, Scottish terrier, Scottie", + 200: "Tibetan terrier, chrysanthemum dog", + 201: "silky terrier, Sydney silky", + 202: "soft-coated wheaten terrier", + 203: "West Highland white terrier", + 204: "Lhasa, Lhasa apso", + 205: "flat-coated retriever", + 206: "curly-coated retriever", + 207: "golden retriever", + 208: "Labrador retriever", + 209: "Chesapeake Bay retriever", + 210: "German short-haired pointer", + 211: "vizsla, Hungarian pointer", + 212: "English setter", + 213: "Irish setter, red setter", + 214: "Gordon setter", + 215: "Brittany spaniel", + 216: "clumber, clumber spaniel", + 217: "English springer, English springer spaniel", + 218: "Welsh springer spaniel", + 219: "cocker spaniel, English cocker spaniel, cocker", + 220: "Sussex spaniel", + 221: "Irish water spaniel", + 222: "kuvasz", + 223: "schipperke", + 224: "groenendael", + 225: "malinois", + 226: "briard", + 227: "kelpie", + 228: "komondor", + 229: "Old English sheepdog, bobtail", + 230: "Shetland sheepdog, Shetland sheep dog, Shetland", + 231: "collie", + 232: "Border collie", + 233: "Bouvier des Flandres, Bouviers des Flandres", + 234: "Rottweiler", + 235: "German shepherd, German shepherd dog, German police dog, alsatian", + 236: "Doberman, Doberman pinscher", + 237: "miniature pinscher", + 238: "Greater Swiss Mountain dog", + 239: "Bernese mountain dog", + 240: "Appenzeller", + 241: "EntleBucher", + 242: "boxer", + 243: "bull mastiff", + 244: "Tibetan mastiff", + 245: "French bulldog", + 246: "Great Dane", + 247: "Saint Bernard, St Bernard", + 248: "Eskimo dog, husky", + 249: "malamute, malemute, Alaskan malamute", + 250: "Siberian husky", + 251: "dalmatian, coach dog, carriage dog", + 252: "affenpinscher, monkey pinscher, monkey dog", + 253: "basenji", + 254: "pug, pug-dog", + 255: "Leonberg", + 256: "Newfoundland, Newfoundland dog", + 257: "Great Pyrenees", + 258: "Samoyed, Samoyede", + 259: "Pomeranian", + 260: "chow, chow chow", + 261: "keeshond", + 262: "Brabancon griffon", + 263: "Pembroke, Pembroke Welsh corgi", + 264: "Cardigan, Cardigan Welsh corgi", + 265: "toy poodle", + 266: "miniature poodle", + 267: "standard poodle", + 268: "Mexican hairless", + 269: "timber wolf, grey wolf, gray wolf, Canis lupus", + 270: "white wolf, Arctic wolf, Canis lupus tundrarum", + 271: "red wolf, maned wolf, Canis rufus, Canis niger", + 272: "coyote, prairie wolf, brush wolf, Canis latrans", + 273: "dingo, warrigal, warragal, Canis dingo", + 274: "dhole, Cuon alpinus", + 275: "African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus", + 276: "hyena, hyaena", + 277: "red fox, Vulpes vulpes", + 278: "kit fox, Vulpes macrotis", + 279: "Arctic fox, white fox, Alopex lagopus", + 280: "grey fox, gray fox, Urocyon cinereoargenteus", + 281: "tabby, tabby cat", + 282: "tiger cat", + 283: "Persian cat", + 284: "Siamese cat, Siamese", + 285: "Egyptian cat", + 286: "cougar, puma, catamount, mountain lion, painter, panther, Felis concolor", + 287: "lynx, catamount", + 288: "leopard, Panthera pardus", + 289: "snow leopard, ounce, Panthera uncia", + 290: "jaguar, panther, Panthera onca, Felis onca", + 291: "lion, king of beasts, Panthera leo", + 292: "tiger, Panthera tigris", + 293: "cheetah, chetah, Acinonyx jubatus", + 294: "brown bear, bruin, Ursus arctos", + 295: "American black bear, black bear, Ursus americanus, Euarctos americanus", + 296: "ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus", + 297: "sloth bear, Melursus ursinus, Ursus ursinus", + 298: "mongoose", + 299: "meerkat, mierkat", + 300: "tiger beetle", + 301: "ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle", + 302: "ground beetle, carabid beetle", + 303: "long-horned beetle, longicorn, longicorn beetle", + 304: "leaf beetle, chrysomelid", + 305: "dung beetle", + 306: "rhinoceros beetle", + 307: "weevil", + 308: "fly", + 309: "bee", + 310: "ant, emmet, pismire", + 311: "grasshopper, hopper", + 312: "cricket", + 313: "walking stick, walkingstick, stick insect", + 314: "cockroach, roach", + 315: "mantis, mantid", + 316: "cicada, cicala", + 317: "leafhopper", + 318: "lacewing, lacewing fly", + 319: "dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk", + 320: "damselfly", + 321: "admiral", + 322: "ringlet, ringlet butterfly", + 323: "monarch, monarch butterfly, milkweed butterfly, Danaus plexippus", + 324: "cabbage butterfly", + 325: "sulphur butterfly, sulfur butterfly", + 326: "lycaenid, lycaenid butterfly", + 327: "starfish, sea star", + 328: "sea urchin", + 329: "sea cucumber, holothurian", + 330: "wood rabbit, cottontail, cottontail rabbit", + 331: "hare", + 332: "Angora, Angora rabbit", + 333: "hamster", + 334: "porcupine, hedgehog", + 335: "fox squirrel, eastern fox squirrel, Sciurus niger", + 336: "marmot", + 337: "beaver", + 338: "guinea pig, Cavia cobaya", + 339: "sorrel", + 340: "zebra", + 341: "hog, pig, grunter, squealer, Sus scrofa", + 342: "wild boar, boar, Sus scrofa", + 343: "warthog", + 344: "hippopotamus, hippo, river horse, Hippopotamus amphibius", + 345: "ox", + 346: "water buffalo, water ox, Asiatic buffalo, Bubalus bubalis", + 347: "bison", + 348: "ram, tup", + 349: "bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis", + 350: "ibex, Capra ibex", + 351: "hartebeest", + 352: "impala, Aepyceros melampus", + 353: "gazelle", + 354: "Arabian camel, dromedary, Camelus dromedarius", + 355: "llama", + 356: "weasel", + 357: "mink", + 358: "polecat, fitch, foulmart, foumart, Mustela putorius", + 359: "black-footed ferret, ferret, Mustela nigripes", + 360: "otter", + 361: "skunk, polecat, wood pussy", + 362: "badger", + 363: "armadillo", + 364: "three-toed sloth, ai, Bradypus tridactylus", + 365: "orangutan, orang, orangutang, Pongo pygmaeus", + 366: "gorilla, Gorilla gorilla", + 367: "chimpanzee, chimp, Pan troglodytes", + 368: "gibbon, Hylobates lar", + 369: "siamang, Hylobates syndactylus, Symphalangus syndactylus", + 370: "guenon, guenon monkey", + 371: "patas, hussar monkey, Erythrocebus patas", + 372: "baboon", + 373: "macaque", + 374: "langur", + 375: "colobus, colobus monkey", + 376: "proboscis monkey, Nasalis larvatus", + 377: "marmoset", + 378: "capuchin, ringtail, Cebus capucinus", + 379: "howler monkey, howler", + 380: "titi, titi monkey", + 381: "spider monkey, Ateles geoffroyi", + 382: "squirrel monkey, Saimiri sciureus", + 383: "Madagascar cat, ring-tailed lemur, Lemur catta", + 384: "indri, indris, Indri indri, Indri brevicaudatus", + 385: "Indian elephant, Elephas maximus", + 386: "African elephant, Loxodonta africana", + 387: "lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens", + 388: "giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca", + 389: "barracouta, snoek", + 390: "eel", + 391: "coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch", + 392: "rock beauty, Holocanthus tricolor", + 393: "anemone fish", + 394: "sturgeon", + 395: "gar, garfish, garpike, billfish, Lepisosteus osseus", + 396: "lionfish", + 397: "puffer, pufferfish, blowfish, globefish", + 398: "abacus", + 399: "abaya", + 400: "academic gown, academic robe, judge's robe", + 401: "accordion, piano accordion, squeeze box", + 402: "acoustic guitar", + 403: "aircraft carrier, carrier, flattop, attack aircraft carrier", + 404: "airliner", + 405: "airship, dirigible", + 406: "altar", + 407: "ambulance", + 408: "amphibian, amphibious vehicle", + 409: "analog clock", + 410: "apiary, bee house", + 411: "apron", + 412: "ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin", + 413: "assault rifle, assault gun", + 414: "backpack, back pack, knapsack, packsack, rucksack, haversack", + 415: "bakery, bakeshop, bakehouse", + 416: "balance beam, beam", + 417: "balloon", + 418: "ballpoint, ballpoint pen, ballpen, Biro", + 419: "Band Aid", + 420: "banjo", + 421: "bannister, banister, balustrade, balusters, handrail", + 422: "barbell", + 423: "barber chair", + 424: "barbershop", + 425: "barn", + 426: "barometer", + 427: "barrel, cask", + 428: "barrow, garden cart, lawn cart, wheelbarrow", + 429: "baseball", + 430: "basketball", + 431: "bassinet", + 432: "bassoon", + 433: "bathing cap, swimming cap", + 434: "bath towel", + 435: "bathtub, bathing tub, bath, tub", + 436: "beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon", + 437: "beacon, lighthouse, beacon light, pharos", + 438: "beaker", + 439: "bearskin, busby, shako", + 440: "beer bottle", + 441: "beer glass", + 442: "bell cote, bell cot", + 443: "bib", + 444: "bicycle-built-for-two, tandem bicycle, tandem", + 445: "bikini, two-piece", + 446: "binder, ring-binder", + 447: "binoculars, field glasses, opera glasses", + 448: "birdhouse", + 449: "boathouse", + 450: "bobsled, bobsleigh, bob", + 451: "bolo tie, bolo, bola tie, bola", + 452: "bonnet, poke bonnet", + 453: "bookcase", + 454: "bookshop, bookstore, bookstall", + 455: "bottlecap", + 456: "bow", + 457: "bow tie, bow-tie, bowtie", + 458: "brass, memorial tablet, plaque", + 459: "brassiere, bra, bandeau", + 460: "breakwater, groin, groyne, mole, bulwark, seawall, jetty", + 461: "breastplate, aegis, egis", + 462: "broom", + 463: "bucket, pail", + 464: "buckle", + 465: "bulletproof vest", + 466: "bullet train, bullet", + 467: "butcher shop, meat market", + 468: "cab, hack, taxi, taxicab", + 469: "caldron, cauldron", + 470: "candle, taper, wax light", + 471: "cannon", + 472: "canoe", + 473: "can opener, tin opener", + 474: "cardigan", + 475: "car mirror", + 476: "carousel, carrousel, merry-go-round, roundabout, whirligig", + 477: "carpenter's kit, tool kit", + 478: "carton", + 479: "car wheel", + 480: "cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM", + 481: "cassette", + 482: "cassette player", + 483: "castle", + 484: "catamaran", + 485: "CD player", + 486: "cello, violoncello", + 487: "cellular telephone, cellular phone, cellphone, cell, mobile phone", + 488: "chain", + 489: "chainlink fence", + 490: "chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour", + 491: "chain saw, chainsaw", + 492: "chest", + 493: "chiffonier, commode", + 494: "chime, bell, gong", + 495: "china cabinet, china closet", + 496: "Christmas stocking", + 497: "church, church building", + 498: "cinema, movie theater, movie theatre, movie house, picture palace", + 499: "cleaver, meat cleaver, chopper", + 500: "cliff dwelling", + 501: "cloak", + 502: "clog, geta, patten, sabot", + 503: "cocktail shaker", + 504: "coffee mug", + 505: "coffeepot", + 506: "coil, spiral, volute, whorl, helix", + 507: "combination lock", + 508: "computer keyboard, keypad", + 509: "confectionery, confectionary, candy store", + 510: "container ship, containership, container vessel", + 511: "convertible", + 512: "corkscrew, bottle screw", + 513: "cornet, horn, trumpet, trump", + 514: "cowboy boot", + 515: "cowboy hat, ten-gallon hat", + 516: "cradle", + 517: "crane", + 518: "crash helmet", + 519: "crate", + 520: "crib, cot", + 521: "Crock Pot", + 522: "croquet ball", + 523: "crutch", + 524: "cuirass", + 525: "dam, dike, dyke", + 526: "desk", + 527: "desktop computer", + 528: "dial telephone, dial phone", + 529: "diaper, nappy, napkin", + 530: "digital clock", + 531: "digital watch", + 532: "dining table, board", + 533: "dishrag, dishcloth", + 534: "dishwasher, dish washer, dishwashing machine", + 535: "disk brake, disc brake", + 536: "dock, dockage, docking facility", + 537: "dogsled, dog sled, dog sleigh", + 538: "dome", + 539: "doormat, welcome mat", + 540: "drilling platform, offshore rig", + 541: "drum, membranophone, tympan", + 542: "drumstick", + 543: "dumbbell", + 544: "Dutch oven", + 545: "electric fan, blower", + 546: "electric guitar", + 547: "electric locomotive", + 548: "entertainment center", + 549: "envelope", + 550: "espresso maker", + 551: "face powder", + 552: "feather boa, boa", + 553: "file, file cabinet, filing cabinet", + 554: "fireboat", + 555: "fire engine, fire truck", + 556: "fire screen, fireguard", + 557: "flagpole, flagstaff", + 558: "flute, transverse flute", + 559: "folding chair", + 560: "football helmet", + 561: "forklift", + 562: "fountain", + 563: "fountain pen", + 564: "four-poster", + 565: "freight car", + 566: "French horn, horn", + 567: "frying pan, frypan, skillet", + 568: "fur coat", + 569: "garbage truck, dustcart", + 570: "gasmask, respirator, gas helmet", + 571: "gas pump, gasoline pump, petrol pump, island dispenser", + 572: "goblet", + 573: "go-kart", + 574: "golf ball", + 575: "golfcart, golf cart", + 576: "gondola", + 577: "gong, tam-tam", + 578: "gown", + 579: "grand piano, grand", + 580: "greenhouse, nursery, glasshouse", + 581: "grille, radiator grille", + 582: "grocery store, grocery, food market, market", + 583: "guillotine", + 584: "hair slide", + 585: "hair spray", + 586: "half track", + 587: "hammer", + 588: "hamper", + 589: "hand blower, blow dryer, blow drier, hair dryer, hair drier", + 590: "hand-held computer, hand-held microcomputer", + 591: "handkerchief, hankie, hanky, hankey", + 592: "hard disc, hard disk, fixed disk", + 593: "harmonica, mouth organ, harp, mouth harp", + 594: "harp", + 595: "harvester, reaper", + 596: "hatchet", + 597: "holster", + 598: "home theater, home theatre", + 599: "honeycomb", + 600: "hook, claw", + 601: "hoopskirt, crinoline", + 602: "horizontal bar, high bar", + 603: "horse cart, horse-cart", + 604: "hourglass", + 605: "iPod", + 606: "iron, smoothing iron", + 607: "jack-o'-lantern", + 608: "jean, blue jean, denim", + 609: "jeep, landrover", + 610: "jersey, T-shirt, tee shirt", + 611: "jigsaw puzzle", + 612: "jinrikisha, ricksha, rickshaw", + 613: "joystick", + 614: "kimono", + 615: "knee pad", + 616: "knot", + 617: "lab coat, laboratory coat", + 618: "ladle", + 619: "lampshade, lamp shade", + 620: "laptop, laptop computer", + 621: "lawn mower, mower", + 622: "lens cap, lens cover", + 623: "letter opener, paper knife, paperknife", + 624: "library", + 625: "lifeboat", + 626: "lighter, light, igniter, ignitor", + 627: "limousine, limo", + 628: "liner, ocean liner", + 629: "lipstick, lip rouge", + 630: "Loafer", + 631: "lotion", + 632: "loudspeaker, speaker, speaker unit, loudspeaker system, speaker system", + 633: "loupe, jeweler's loupe", + 634: "lumbermill, sawmill", + 635: "magnetic compass", + 636: "mailbag, postbag", + 637: "mailbox, letter box", + 638: "maillot", + 639: "maillot, tank suit", + 640: "manhole cover", + 641: "maraca", + 642: "marimba, xylophone", + 643: "mask", + 644: "matchstick", + 645: "maypole", + 646: "maze, labyrinth", + 647: "measuring cup", + 648: "medicine chest, medicine cabinet", + 649: "megalith, megalithic structure", + 650: "microphone, mike", + 651: "microwave, microwave oven", + 652: "military uniform", + 653: "milk can", + 654: "minibus", + 655: "miniskirt, mini", + 656: "minivan", + 657: "missile", + 658: "mitten", + 659: "mixing bowl", + 660: "mobile home, manufactured home", + 661: "Model T", + 662: "modem", + 663: "monastery", + 664: "monitor", + 665: "moped", + 666: "mortar", + 667: "mortarboard", + 668: "mosque", + 669: "mosquito net", + 670: "motor scooter, scooter", + 671: "mountain bike, all-terrain bike, off-roader", + 672: "mountain tent", + 673: "mouse, computer mouse", + 674: "mousetrap", + 675: "moving van", + 676: "muzzle", + 677: "nail", + 678: "neck brace", + 679: "necklace", + 680: "nipple", + 681: "notebook, notebook computer", + 682: "obelisk", + 683: "oboe, hautboy, hautbois", + 684: "ocarina, sweet potato", + 685: "odometer, hodometer, mileometer, milometer", + 686: "oil filter", + 687: "organ, pipe organ", + 688: "oscilloscope, scope, cathode-ray oscilloscope, CRO", + 689: "overskirt", + 690: "oxcart", + 691: "oxygen mask", + 692: "packet", + 693: "paddle, boat paddle", + 694: "paddlewheel, paddle wheel", + 695: "padlock", + 696: "paintbrush", + 697: "pajama, pyjama, pj's, jammies", + 698: "palace", + 699: "panpipe, pandean pipe, syrinx", + 700: "paper towel", + 701: "parachute, chute", + 702: "parallel bars, bars", + 703: "park bench", + 704: "parking meter", + 705: "passenger car, coach, carriage", + 706: "patio, terrace", + 707: "pay-phone, pay-station", + 708: "pedestal, plinth, footstall", + 709: "pencil box, pencil case", + 710: "pencil sharpener", + 711: "perfume, essence", + 712: "Petri dish", + 713: "photocopier", + 714: "pick, plectrum, plectron", + 715: "pickelhaube", + 716: "picket fence, paling", + 717: "pickup, pickup truck", + 718: "pier", + 719: "piggy bank, penny bank", + 720: "pill bottle", + 721: "pillow", + 722: "ping-pong ball", + 723: "pinwheel", + 724: "pirate, pirate ship", + 725: "pitcher, ewer", + 726: "plane, carpenter's plane, woodworking plane", + 727: "planetarium", + 728: "plastic bag", + 729: "plate rack", + 730: "plow, plough", + 731: "plunger, plumber's helper", + 732: "Polaroid camera, Polaroid Land camera", + 733: "pole", + 734: "police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria", + 735: "poncho", + 736: "pool table, billiard table, snooker table", + 737: "pop bottle, soda bottle", + 738: "pot, flowerpot", + 739: "potter's wheel", + 740: "power drill", + 741: "prayer rug, prayer mat", + 742: "printer", + 743: "prison, prison house", + 744: "projectile, missile", + 745: "projector", + 746: "puck, hockey puck", + 747: "punching bag, punch bag, punching ball, punchball", + 748: "purse", + 749: "quill, quill pen", + 750: "quilt, comforter, comfort, puff", + 751: "racer, race car, racing car", + 752: "racket, racquet", + 753: "radiator", + 754: "radio, wireless", + 755: "radio telescope, radio reflector", + 756: "rain barrel", + 757: "recreational vehicle, RV, R.V.", + 758: "reel", + 759: "reflex camera", + 760: "refrigerator, icebox", + 761: "remote control, remote", + 762: "restaurant, eating house, eating place, eatery", + 763: "revolver, six-gun, six-shooter", + 764: "rifle", + 765: "rocking chair, rocker", + 766: "rotisserie", + 767: "rubber eraser, rubber, pencil eraser", + 768: "rugby ball", + 769: "rule, ruler", + 770: "running shoe", + 771: "safe", + 772: "safety pin", + 773: "saltshaker, salt shaker", + 774: "sandal", + 775: "sarong", + 776: "sax, saxophone", + 777: "scabbard", + 778: "scale, weighing machine", + 779: "school bus", + 780: "schooner", + 781: "scoreboard", + 782: "screen, CRT screen", + 783: "screw", + 784: "screwdriver", + 785: "seat belt, seatbelt", + 786: "sewing machine", + 787: "shield, buckler", + 788: "shoe shop, shoe-shop, shoe store", + 789: "shoji", + 790: "shopping basket", + 791: "shopping cart", + 792: "shovel", + 793: "shower cap", + 794: "shower curtain", + 795: "ski", + 796: "ski mask", + 797: "sleeping bag", + 798: "slide rule, slipstick", + 799: "sliding door", + 800: "slot, one-armed bandit", + 801: "snorkel", + 802: "snowmobile", + 803: "snowplow, snowplough", + 804: "soap dispenser", + 805: "soccer ball", + 806: "sock", + 807: "solar dish, solar collector, solar furnace", + 808: "sombrero", + 809: "soup bowl", + 810: "space bar", + 811: "space heater", + 812: "space shuttle", + 813: "spatula", + 814: "speedboat", + 815: "spider web, spider's web", + 816: "spindle", + 817: "sports car, sport car", + 818: "spotlight, spot", + 819: "stage", + 820: "steam locomotive", + 821: "steel arch bridge", + 822: "steel drum", + 823: "stethoscope", + 824: "stole", + 825: "stone wall", + 826: "stopwatch, stop watch", + 827: "stove", + 828: "strainer", + 829: "streetcar, tram, tramcar, trolley, trolley car", + 830: "stretcher", + 831: "studio couch, day bed", + 832: "stupa, tope", + 833: "submarine, pigboat, sub, U-boat", + 834: "suit, suit of clothes", + 835: "sundial", + 836: "sunglass", + 837: "sunglasses, dark glasses, shades", + 838: "sunscreen, sunblock, sun blocker", + 839: "suspension bridge", + 840: "swab, swob, mop", + 841: "sweatshirt", + 842: "swimming trunks, bathing trunks", + 843: "swing", + 844: "switch, electric switch, electrical switch", + 845: "syringe", + 846: "table lamp", + 847: "tank, army tank, armored combat vehicle, armoured combat vehicle", + 848: "tape player", + 849: "teapot", + 850: "teddy, teddy bear", + 851: "television, television system", + 852: "tennis ball", + 853: "thatch, thatched roof", + 854: "theater curtain, theatre curtain", + 855: "thimble", + 856: "thresher, thrasher, threshing machine", + 857: "throne", + 858: "tile roof", + 859: "toaster", + 860: "tobacco shop, tobacconist shop, tobacconist", + 861: "toilet seat", + 862: "torch", + 863: "totem pole", + 864: "tow truck, tow car, wrecker", + 865: "toyshop", + 866: "tractor", + 867: "trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi", + 868: "tray", + 869: "trench coat", + 870: "tricycle, trike, velocipede", + 871: "trimaran", + 872: "tripod", + 873: "triumphal arch", + 874: "trolleybus, trolley coach, trackless trolley", + 875: "trombone", + 876: "tub, vat", + 877: "turnstile", + 878: "typewriter keyboard", + 879: "umbrella", + 880: "unicycle, monocycle", + 881: "upright, upright piano", + 882: "vacuum, vacuum cleaner", + 883: "vase", + 884: "vault", + 885: "velvet", + 886: "vending machine", + 887: "vestment", + 888: "viaduct", + 889: "violin, fiddle", + 890: "volleyball", + 891: "waffle iron", + 892: "wall clock", + 893: "wallet, billfold, notecase, pocketbook", + 894: "wardrobe, closet, press", + 895: "warplane, military plane", + 896: "washbasin, handbasin, washbowl, lavabo, wash-hand basin", + 897: "washer, automatic washer, washing machine", + 898: "water bottle", + 899: "water jug", + 900: "water tower", + 901: "whiskey jug", + 902: "whistle", + 903: "wig", + 904: "window screen", + 905: "window shade", + 906: "Windsor tie", + 907: "wine bottle", + 908: "wing", + 909: "wok", + 910: "wooden spoon", + 911: "wool, woolen, woollen", + 912: "worm fence, snake fence, snake-rail fence, Virginia fence", + 913: "wreck", + 914: "yawl", + 915: "yurt", + 916: "web site, website, internet site, site", + 917: "comic book", + 918: "crossword puzzle, crossword", + 919: "street sign", + 920: "traffic light, traffic signal, stoplight", + 921: "book jacket, dust cover, dust jacket, dust wrapper", + 922: "menu", + 923: "plate", + 924: "guacamole", + 925: "consomme", + 926: "hot pot, hotpot", + 927: "trifle", + 928: "ice cream, icecream", + 929: "ice lolly, lolly, lollipop, popsicle", + 930: "French loaf", + 931: "bagel, beigel", + 932: "pretzel", + 933: "cheeseburger", + 934: "hotdog, hot dog, red hot", + 935: "mashed potato", + 936: "head cabbage", + 937: "broccoli", + 938: "cauliflower", + 939: "zucchini, courgette", + 940: "spaghetti squash", + 941: "acorn squash", + 942: "butternut squash", + 943: "cucumber, cuke", + 944: "artichoke, globe artichoke", + 945: "bell pepper", + 946: "cardoon", + 947: "mushroom", + 948: "Granny Smith", + 949: "strawberry", + 950: "orange", + 951: "lemon", + 952: "fig", + 953: "pineapple, ananas", + 954: "banana", + 955: "jackfruit, jak, jack", + 956: "custard apple", + 957: "pomegranate", + 958: "hay", + 959: "carbonara", + 960: "chocolate sauce, chocolate syrup", + 961: "dough", + 962: "meat loaf, meatloaf", + 963: "pizza, pizza pie", + 964: "potpie", + 965: "burrito", + 966: "red wine", + 967: "espresso", + 968: "cup", + 969: "eggnog", + 970: "alp", + 971: "bubble", + 972: "cliff, drop, drop-off", + 973: "coral reef", + 974: "geyser", + 975: "lakeside, lakeshore", + 976: "promontory, headland, head, foreland", + 977: "sandbar, sand bar", + 978: "seashore, coast, seacoast, sea-coast", + 979: "valley, vale", + 980: "volcano", + 981: "ballplayer, baseball player", + 982: "groom, bridegroom", + 983: "scuba diver", + 984: "rapeseed", + 985: "daisy", + 986: "yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum", + 987: "corn", + 988: "acorn", + 989: "hip, rose hip, rosehip", + 990: "buckeye, horse chestnut, conker", + 991: "coral fungus", + 992: "agaric", + 993: "gyromitra", + 994: "stinkhorn, carrion fungus", + 995: "earthstar", + 996: "hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa", + 997: "bolete", + 998: "ear, spike, capitulum", + 999: "toilet tissue, toilet paper, bathroom tissue", +} diff --git a/Transformer-Explainability/data/transforms.py b/Transformer-Explainability/data/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..af82afbe417466ed568e0aac86e7bd2115abed4b --- /dev/null +++ b/Transformer-Explainability/data/transforms.py @@ -0,0 +1,485 @@ +from __future__ import division + +import random +import sys + +from PIL import Image + +try: + import accimage +except ImportError: + accimage = None +import collections +import numbers + +from torchvision.transforms import functional as F + +if sys.version_info < (3, 3): + Sequence = collections.Sequence + Iterable = collections.Iterable +else: + Sequence = collections.abc.Sequence + Iterable = collections.abc.Iterable + +_pil_interpolation_to_str = { + Image.NEAREST: "PIL.Image.NEAREST", + Image.BILINEAR: "PIL.Image.BILINEAR", + Image.BICUBIC: "PIL.Image.BICUBIC", + Image.LANCZOS: "PIL.Image.LANCZOS", + Image.HAMMING: "PIL.Image.HAMMING", + Image.BOX: "PIL.Image.BOX", +} + + +class Compose(object): + """Composes several transforms together. + + Args: + transforms (list of ``Transform`` objects): list of transforms to compose. + + Example: + >>> transforms.Compose([ + >>> transforms.CenterCrop(10), + >>> transforms.ToTensor(), + >>> ]) + """ + + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, img, tgt): + for t in self.transforms: + img, tgt = t(img, tgt) + return img, tgt + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string + + +class Resize(object): + """Resize the input PIL Image to the given size. + + Args: + size (sequence or int): Desired output size. If size is a sequence like + (h, w), output size will be matched to this. If size is an int, + smaller edge of the image will be matched to this number. + i.e, if height > width, then image will be rescaled to + (size * height / width, size) + interpolation (int, optional): Desired interpolation. Default is + ``PIL.Image.BILINEAR`` + """ + + def __init__(self, size, interpolation=Image.BILINEAR): + assert isinstance(size, int) or (isinstance(size, Iterable) and len(size) == 2) + self.size = size + self.interpolation = interpolation + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be scaled. + + Returns: + PIL Image: Rescaled image. + """ + return F.resize(img, self.size, self.interpolation), F.resize( + tgt, self.size, Image.NEAREST + ) + + def __repr__(self): + interpolate_str = _pil_interpolation_to_str[self.interpolation] + return self.__class__.__name__ + "(size={0}, interpolation={1})".format( + self.size, interpolate_str + ) + + +class CenterCrop(object): + """Crops the given PIL Image at the center. + + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + """ + + def __init__(self, size): + if isinstance(size, numbers.Number): + self.size = (int(size), int(size)) + else: + self.size = size + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be cropped. + + Returns: + PIL Image: Cropped image. + """ + return F.center_crop(img, self.size), F.center_crop(tgt, self.size) + + def __repr__(self): + return self.__class__.__name__ + "(size={0})".format(self.size) + + +class RandomCrop(object): + """Crop the given PIL Image at a random location. + + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + padding (int or sequence, optional): Optional padding on each border + of the image. Default is None, i.e no padding. If a sequence of length + 4 is provided, it is used to pad left, top, right, bottom borders + respectively. If a sequence of length 2 is provided, it is used to + pad left/right, top/bottom borders, respectively. + pad_if_needed (boolean): It will pad the image if smaller than the + desired size to avoid raising an exception. + fill: Pixel fill value for constant fill. Default is 0. If a tuple of + length 3, it is used to fill R, G, B channels respectively. + This value is only used when the padding_mode is constant + padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. + + - constant: pads with a constant value, this value is specified with fill + + - edge: pads with the last value on the edge of the image + + - reflect: pads with reflection of image (without repeating the last value on the edge) + + padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode + will result in [3, 2, 1, 2, 3, 4, 3, 2] + + - symmetric: pads with reflection of image (repeating the last value on the edge) + + padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode + will result in [2, 1, 1, 2, 3, 4, 4, 3] + + """ + + def __init__( + self, size, padding=None, pad_if_needed=False, fill=0, padding_mode="constant" + ): + if isinstance(size, numbers.Number): + self.size = (int(size), int(size)) + else: + self.size = size + self.padding = padding + self.pad_if_needed = pad_if_needed + self.fill = fill + self.padding_mode = padding_mode + + @staticmethod + def get_params(img, output_size): + """Get parameters for ``crop`` for a random crop. + + Args: + img (PIL Image): Image to be cropped. + output_size (tuple): Expected output size of the crop. + + Returns: + tuple: params (i, j, h, w) to be passed to ``crop`` for random crop. + """ + w, h = img.size + th, tw = output_size + if w == tw and h == th: + return 0, 0, h, w + + i = random.randint(0, h - th) + j = random.randint(0, w - tw) + return i, j, th, tw + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be cropped. + + Returns: + PIL Image: Cropped image. + """ + if self.padding is not None: + img = F.pad(img, self.padding, self.fill, self.padding_mode) + tgt = F.pad(tgt, self.padding, self.fill, self.padding_mode) + + # pad the width if needed + if self.pad_if_needed and img.size[0] < self.size[1]: + img = F.pad( + img, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode + ) + tgt = F.pad( + tgt, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode + ) + # pad the height if needed + if self.pad_if_needed and img.size[1] < self.size[0]: + img = F.pad( + img, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode + ) + tgt = F.pad( + tgt, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode + ) + + i, j, h, w = self.get_params(img, self.size) + + return F.crop(img, i, j, h, w), F.crop(tgt, i, j, h, w) + + def __repr__(self): + return self.__class__.__name__ + "(size={0}, padding={1})".format( + self.size, self.padding + ) + + +class RandomHorizontalFlip(object): + """Horizontally flip the given PIL Image randomly with a given probability. + + Args: + p (float): probability of the image being flipped. Default value is 0.5 + """ + + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be flipped. + + Returns: + PIL Image: Randomly flipped image. + """ + if random.random() < self.p: + return F.hflip(img), F.hflip(tgt) + + return img, tgt + + def __repr__(self): + return self.__class__.__name__ + "(p={})".format(self.p) + + +class RandomVerticalFlip(object): + """Vertically flip the given PIL Image randomly with a given probability. + + Args: + p (float): probability of the image being flipped. Default value is 0.5 + """ + + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be flipped. + + Returns: + PIL Image: Randomly flipped image. + """ + if random.random() < self.p: + return F.vflip(img), F.vflip(tgt) + return img, tgt + + def __repr__(self): + return self.__class__.__name__ + "(p={})".format(self.p) + + +class Lambda(object): + """Apply a user-defined lambda as a transform. + + Args: + lambd (function): Lambda/function to be used for transform. + """ + + def __init__(self, lambd): + assert callable(lambd), repr(type(lambd).__name__) + " object is not callable" + self.lambd = lambd + + def __call__(self, img, tgt): + return self.lambd(img, tgt) + + def __repr__(self): + return self.__class__.__name__ + "()" + + +class ColorJitter(object): + """Randomly change the brightness, contrast and saturation of an image. + + Args: + brightness (float or tuple of float (min, max)): How much to jitter brightness. + brightness_factor is chosen uniformly from [max(0, 1 - brightness), 1 + brightness] + or the given [min, max]. Should be non negative numbers. + contrast (float or tuple of float (min, max)): How much to jitter contrast. + contrast_factor is chosen uniformly from [max(0, 1 - contrast), 1 + contrast] + or the given [min, max]. Should be non negative numbers. + saturation (float or tuple of float (min, max)): How much to jitter saturation. + saturation_factor is chosen uniformly from [max(0, 1 - saturation), 1 + saturation] + or the given [min, max]. Should be non negative numbers. + hue (float or tuple of float (min, max)): How much to jitter hue. + hue_factor is chosen uniformly from [-hue, hue] or the given [min, max]. + Should have 0<= hue <= 0.5 or -0.5 <= min <= max <= 0.5. + """ + + def __init__(self, brightness=0, contrast=0, saturation=0, hue=0): + self.brightness = self._check_input(brightness, "brightness") + self.contrast = self._check_input(contrast, "contrast") + self.saturation = self._check_input(saturation, "saturation") + self.hue = self._check_input( + hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False + ) + + def _check_input( + self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True + ): + if isinstance(value, numbers.Number): + if value < 0: + raise ValueError( + "If {} is a single number, it must be non negative.".format(name) + ) + value = [center - value, center + value] + if clip_first_on_zero: + value[0] = max(value[0], 0) + elif isinstance(value, (tuple, list)) and len(value) == 2: + if not bound[0] <= value[0] <= value[1] <= bound[1]: + raise ValueError("{} values should be between {}".format(name, bound)) + else: + raise TypeError( + "{} should be a single number or a list/tuple with lenght 2.".format( + name + ) + ) + + # if value is 0 or (1., 1.) for brightness/contrast/saturation + # or (0., 0.) for hue, do nothing + if value[0] == value[1] == center: + value = None + return value + + @staticmethod + def get_params(brightness, contrast, saturation, hue): + """Get a randomized transform to be applied on image. + + Arguments are same as that of __init__. + + Returns: + Transform which randomly adjusts brightness, contrast and + saturation in a random order. + """ + transforms = [] + + if brightness is not None: + brightness_factor = random.uniform(brightness[0], brightness[1]) + transforms.append( + Lambda( + lambda img, tgt: (F.adjust_brightness(img, brightness_factor), tgt) + ) + ) + + if contrast is not None: + contrast_factor = random.uniform(contrast[0], contrast[1]) + transforms.append( + Lambda(lambda img, tgt: (F.adjust_contrast(img, contrast_factor), tgt)) + ) + + if saturation is not None: + saturation_factor = random.uniform(saturation[0], saturation[1]) + transforms.append( + Lambda( + lambda img, tgt: (F.adjust_saturation(img, saturation_factor), tgt) + ) + ) + + if hue is not None: + hue_factor = random.uniform(hue[0], hue[1]) + transforms.append( + Lambda(lambda img, tgt: (F.adjust_hue(img, hue_factor), tgt)) + ) + + random.shuffle(transforms) + transform = Compose(transforms) + + return transform + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Input image. + + Returns: + PIL Image: Color jittered image. + """ + transform = self.get_params( + self.brightness, self.contrast, self.saturation, self.hue + ) + return transform(img, tgt) + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + format_string += "brightness={0}".format(self.brightness) + format_string += ", contrast={0}".format(self.contrast) + format_string += ", saturation={0}".format(self.saturation) + format_string += ", hue={0})".format(self.hue) + return format_string + + +class Normalize(object): + """Normalize a tensor image with mean and standard deviation. + Given mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels, this transform + will normalize each channel of the input ``torch.*Tensor`` i.e. + ``input[channel] = (input[channel] - mean[channel]) / std[channel]`` + + .. note:: + This transform acts out of place, i.e., it does not mutates the input tensor. + + Args: + mean (sequence): Sequence of means for each channel. + std (sequence): Sequence of standard deviations for each channel. + """ + + def __init__(self, mean, std, inplace=False): + self.mean = mean + self.std = std + self.inplace = inplace + + def __call__(self, img, tgt): + """ + Args: + tensor (Tensor): Tensor image of size (C, H, W) to be normalized. + + Returns: + Tensor: Normalized Tensor image. + """ + # return F.normalize(img, self.mean, self.std, self.inplace), tgt + return F.normalize(img, self.mean, self.std), tgt + + def __repr__(self): + return self.__class__.__name__ + "(mean={0}, std={1})".format( + self.mean, self.std + ) + + +class ToTensor(object): + """Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor. + + Converts a PIL Image or numpy.ndarray (H x W x C) in the range + [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] + if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) + or if the numpy.ndarray has dtype = np.uint8 + + In the other cases, tensors are returned without scaling. + """ + + def __call__(self, img, tgt): + """ + Args: + pic (PIL Image or numpy.ndarray): Image to be converted to tensor. + + Returns: + Tensor: Converted image. + """ + return F.to_tensor(img), tgt + + def __repr__(self): + return self.__class__.__name__ + "()" diff --git a/Transformer-Explainability/dataset/expl_hdf5.py b/Transformer-Explainability/dataset/expl_hdf5.py new file mode 100644 index 0000000000000000000000000000000000000000..60d394dd5b254f4e72f7a673b8a0f5e812355544 --- /dev/null +++ b/Transformer-Explainability/dataset/expl_hdf5.py @@ -0,0 +1,52 @@ +import os + +import h5py +import torch +from torch.utils.data import Dataset + + +class ImagenetResults(Dataset): + def __init__(self, path): + super(ImagenetResults, self).__init__() + + self.path = os.path.join(path, "results.hdf5") + self.data = None + + print("Reading dataset length...") + with h5py.File(self.path, "r") as f: + # tmp = h5py.File(self.path , 'r') + self.data_length = len(f["/image"]) + + def __len__(self): + return self.data_length + + def __getitem__(self, item): + if self.data is None: + self.data = h5py.File(self.path, "r") + + image = torch.tensor(self.data["image"][item]) + vis = torch.tensor(self.data["vis"][item]) + target = torch.tensor(self.data["target"][item]).long() + + return image, vis, target + + +if __name__ == "__main__": + import imageio + import numpy as np + from utils import render + + ds = ImagenetResults("../visualizations/fullgrad") + sample_loader = torch.utils.data.DataLoader(ds, batch_size=5, shuffle=False) + + iterator = iter(sample_loader) + image, vis, target = next(iterator) + + maps = ( + render.hm_to_rgb(vis[0].data.cpu().numpy(), scaling=3, sigma=1, cmap="seismic") + * 255 + ).astype(np.uint8) + + # imageio.imsave('../delete_hm.jpg', maps) + + print(len(ds)) diff --git a/Transformer-Explainability/example.PNG b/Transformer-Explainability/example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..629d13ed73ae21bb2f0200dfbefd06e2371b00f2 Binary files /dev/null and b/Transformer-Explainability/example.PNG differ diff --git a/Transformer-Explainability/example.ipynb b/Transformer-Explainability/example.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..723a01c5450464ae33839e4e88078ee1c6aee1f4 --- /dev/null +++ b/Transformer-Explainability/example.ipynb @@ -0,0 +1,310 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import numpy as np\n", + "import cv2\n", + "from samples.CLS2IDX import CLS2IDX" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auxiliary Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from baselines.ViT.ViT_LRP import vit_base_patch16_224 as vit_LRP\n", + "from baselines.ViT.ViT_explanation_generator import LRP\n", + "\n", + "normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n", + "transform = transforms.Compose([\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " normalize,\n", + "])\n", + "\n", + "# create heatmap from mask on image\n", + "def show_cam_on_image(img, mask):\n", + " heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)\n", + " heatmap = np.float32(heatmap) / 255\n", + " cam = heatmap + np.float32(img)\n", + " cam = cam / np.max(cam)\n", + " return cam\n", + "\n", + "# initialize ViT pretrained\n", + "model = vit_LRP(pretrained=True).cuda()\n", + "model.eval()\n", + "attribution_generator = LRP(model)\n", + "\n", + "def generate_visualization(original_image, class_index=None):\n", + " transformer_attribution = attribution_generator.generate_LRP(original_image.unsqueeze(0).cuda(), method=\"transformer_attribution\", index=class_index).detach()\n", + " transformer_attribution = transformer_attribution.reshape(1, 1, 14, 14)\n", + " transformer_attribution = torch.nn.functional.interpolate(transformer_attribution, scale_factor=16, mode='bilinear')\n", + " transformer_attribution = transformer_attribution.reshape(224, 224).cuda().data.cpu().numpy()\n", + " transformer_attribution = (transformer_attribution - transformer_attribution.min()) / (transformer_attribution.max() - transformer_attribution.min())\n", + " image_transformer_attribution = original_image.permute(1, 2, 0).data.cpu().numpy()\n", + " image_transformer_attribution = (image_transformer_attribution - image_transformer_attribution.min()) / (image_transformer_attribution.max() - image_transformer_attribution.min())\n", + " vis = show_cam_on_image(image_transformer_attribution, transformer_attribution)\n", + " vis = np.uint8(255 * vis)\n", + " vis = cv2.cvtColor(np.array(vis), cv2.COLOR_RGB2BGR)\n", + " return vis\n", + "\n", + "def print_top_classes(predictions, **kwargs): \n", + " # Print Top-5 predictions\n", + " prob = torch.softmax(predictions, dim=1)\n", + " class_indices = predictions.data.topk(5, dim=1)[1][0].tolist()\n", + " max_str_len = 0\n", + " class_names = []\n", + " for cls_idx in class_indices:\n", + " class_names.append(CLS2IDX[cls_idx])\n", + " if len(CLS2IDX[cls_idx]) > max_str_len:\n", + " max_str_len = len(CLS2IDX[cls_idx])\n", + " \n", + " print('Top 5 classes:')\n", + " for cls_idx in class_indices:\n", + " output_string = '\\t{} : {}'.format(cls_idx, CLS2IDX[cls_idx])\n", + " output_string += ' ' * (max_str_len - len(CLS2IDX[cls_idx])) + '\\t\\t'\n", + " output_string += 'value = {:.3f}\\t prob = {:.1f}%'.format(predictions[0, cls_idx], 100 * prob[0, cls_idx])\n", + " print(output_string)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cat-Dog" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t282 : tiger cat \t\tvalue = 10.559\t prob = 68.6%\n", + "\t281 : tabby, tabby cat\t\tvalue = 9.059\t prob = 15.3%\n", + "\t285 : Egyptian cat \t\tvalue = 8.414\t prob = 8.0%\n", + "\t243 : bull mastiff \t\tvalue = 7.425\t prob = 3.0%\n", + "\t811 : space heater \t\tvalue = 5.152\t prob = 0.3%\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABwCAYAAAC9zaPrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAADjk0lEQVR4nOz92bNtSXLeif08ItawpzPeMTMrx5qrAAIgOEDg1BBFso1sqq2bprf+H/RfSK/SiwaTSWZ6kV5kklHdotrAUVQTYAMgCAJVBVRVjne+94z77GENEeF6iFhr75tZlVkF3aIelJF28twz77W+FR7un3/uLqrKl+vL9eX6cn25/uMs8//rF/Dl+nJ9ub5c//+0vjS6X64v15fry/UfcX1pdL9cX64v15frP+L60uh+ub5cX64v13/E9aXR/XJ9ub5cX67/iMt93hf/V//z/6mKRqwIgch6veLWfMa3/srf4NHDH+PXVyAliFItTkADlas4OHqde29/lbOLBzz48Q8QW7Hqe377//nb/I1f+zav314wm8144637iCtASq7Ozvjj3/8jVEFEECOIMRhjEIHZ4oD5bIYxgrMWVzjEWhQhSv4ZMRhjUUDVEoLy0cOnvP3GPTR4vv//+N/RXj2jazwxQucjtjAgQh88UQXvFY2R0Kc3nDCxJevG8IePbggRDieWRRVRFUIUrBNQiFFQPKhFiPlalLrKZ5sKqoIYRaPytDH8yv/w77E4ucuDTx7xz/9fv0NcLwGlLgzrLvBs1bGYVDw7X8qrAv2v/4P/jU6njq73oELhLNY52raj94FJ7agKg2rAoRRVTYiBoijo+46PP37IzdUNd9/8GsYV1HXF/GCGzVhB5PGjZzTrbf6LCgJIficWay3TyRQxlhCFs+s1q23Eze9QVDW3p8rRvCK6kj4Kse2wfptwchUmdGyvz5jPJqxb5cUy0HU9Z9c3eO+JIWKMgiiDQkcDxAggqAJBURWsM1gs/c0LQnsDKFLWiKshRjT/Z4xJP6eKAKpK+s0CEjHGZjdGQGP6PSZ9v4aWu8eGN+6doKo8e/SQsxfPWd/841eG60vYdh6AwrlPYVtQFRaNHidKUZWEECnKPWwvb7j71h62ixnWCJLA5fHjc7Zrj+BQHEiJSIFQIuYUe2fG9KsT5CtCuK9cV1fM/BOq+TGb6g6TyZy5TImriv5KiOctZrlNuEmF9B3N1QXzyYT1RnmxDnR4zrYrvPNEFzG1QK1oG+E56JNIfBbhPKDdGYRnqF5lbF3GdpXQKmvEVRlb9rANGVvZwzbBmbCV8XEGxvuhocvY3kKVPWz/bz8R2881us5YVNNGsmKSkVNQH7CuolHHYn7AanWNMyXO1bzx1ldxk5r3f/QHrJZXmHpGPT8mbG6oqoqm9YAQFRTBiEFEKKsaJAFrRNDRkAoi6cYMxhUxqJjx+9N+TkZXkN3nxWKMEFQx1qU3sRiTNoSRZNQRxUQHKNZGohhCIG0YI2BtutMZEBEwxhAiWLO7ryIgalFRFAFVzPBarKDpotOGzUBKUYAxhBhR1Wy0wBghZmNRFMXPtuN+xtV0HgxMSoexlsIajDXEaHHWMKkcIkrwIRusZLiiKiIG6yyoEmPA4NB8wAzLIFiT8En3Lb1PlybsixRVlecXSz56/xF921AsLjm+9yYHh2/QGEcJbDYN7//wA8x2SVXXmMNbHJweMT28Sxt6FocFfa0YI8jTkuurazardXrtkg2uDnslYcj48fhKMob59enL3/Pp3aPsfU3ydwzvxysV9neuNZJwjZEQI/EXoNYcsK1Lh7XmM9jWVYFA2n/DYcTL2CpKDB7jHKrp0BkeTCOSD9fBAMlL9ybdu+GZEZ5fLHl08xEn4RPqxSHmXol55x42VlQCm23D+z/4AHOxpCprzPw2B8dHTA/v0fYdi6OSfqqYiUEuL7neXLPxG/ZMYnay0j9E02v6idiOr4+M7f5zOXwH+YjNnxmuU3a4vvwzaVkxGBGifjG2n2t0jSmIGhCTDM7gRfq+papqNgLbzQ1VNeXw6C73v/Iel8unPPqTf0f0cPr6m9xsNhhrKMuaelLRtD1EMJq8DpuNp3UO5xwxxGw0X75dUUnGNt+bwdDC8L3Jm9T9myPpBIv5poixeV+kXyCSTzXAiCLDw6eCkWHfDYZzB8BoeEUJCnaAYXjNg2NnDJgIZrcNGQ4TTV831oIo3ocd7ppsfYzpe437XJh+7lVYy+nhnN73iBjKwuJjpCoLiBHnLDG5hMSYDK8qaFQiYJwlaCTGkLCJOnoGw4NtrU2HZX7KZQBz+Iemt84Hnj58Qbe8QsKWan7Anfu3mc4q2qhcbzrOXlwxry3vvHaHo8MDIo6HNy3nfU9ROs7Olzz64COEHu0bJotjvBPaEPOfGqxnNoKSDwL9GZzMcafuG9Cf+k28bHx1z1qnQ4Hh8mNk74uvbO2w7TK2Dh8CVVGARgpniFGJAWI+6DXuYWstUSNRM7YD9nm3af4epB+xhWzsPmV9u97z9Pw5HddgLqgWE45fu42dVnQrw3LAtnK8895dDucLNDoeXjecd5HCOl5cX/P4o4+RyqPSMLl1jLfQ5hNxiDw+Y/l/Elb7WH7645+nXkH2/1g+jOzu134Rtp9vdK0l+IDBgolYSQas3WwoZzWlK6gmR7z21jepDua8/8Efcn35nNi1FNUcU9aYts3uuVBPatbbLr8wZf84MNbgnKULkb3dmb5XIAzA52c/kszs3neNxnT3MAjHhwdcXy25dXqMMS4bWEENkL1cEYOYgIZ8QppkQFSSNzx4JqNXvXc/VdMrGZ264TVlw2pGbx6QREmISPrTxmCNAzH0PiTPfzwEDD5GrDX4ED4Ppp97iQhlYQnR46zBiqQoRgx91zJ4tqD4ECjHa03XaI1FY0Q0JjwGyPaWdeYzn/v0vgRYLtdsLs+ZOsNkfovbX/smi8Mpy+sVF5c3rJc3+PWS+8dT+uD5+MlzQjHB25J+2/Hi0RXd6oLm4in99hoRw/bijGpxhBQHqLFjhDL4MKoyesCy9za6SsNBMVgS1WSfhU9tTtn7ORkfjPEvDTQE6UDfD9GHQ+1VLxEoXaJsnLUJWzdg25GolfS3fQiU+bAcDlZrLRoDEjVjuzsgh+tz1uTzxEB+S1eaPWCjqIHlesPm+oKD23B7dsS9r34Vd1DwbHnF06ctq0c39Bc33J9M6IuWTy43BDtN2AbPi6eXdMtLmuUTen+DVJZte0Z1eoS4I3Tn7jBiu3N3P4vtuIaIch/b/Qf5Ux7wPraSqQfVHBUN2JpPYfvTjfgXeLpDGAyIwThLBPq2ZXF6i7uvfZVbb7zLzeqM97/3b+nalhChnBxibIVGxdoUwooYJtMJ26s14gxRIASlJD2I1ibuSTr/KQdk55WMrv7gN35qB8u4CSSfzEJZFlwtVyAm88fk8J+8qUx6P3Bwwmhw2OPsJNMgRjU/YpL/yu4lyXgc7GM13Px0GosygmWszd63EGJ6DXkLjCFfCMqmaT4Ppp97pfBRMdkps1awInhVVJSu9/Q+YkXpfeK50oMW0wFqLQElhpDvdSSEgCvs+DessQOr8DJu+XZEBTUF6yZiNXC4WMD0kProhOdPzlmfn9E1LaEP+O0aZgUaJ6xv1lzcXNPFiHEFMQTUK9ZabFliMfQa2V6fIZMemd/Kr1FHh2gMH0cDm7emxPFkERk2TsI0fYcZ79/upwYqiXG/Dj6/5L+RzFE67EcDkY3cq15K2vTD3zIjtsmMtL3H72ObfyrmA8IYS1DGKEZRgk/Rz7CsdSAO1QKRCqFCqUBrqAriAXDiWIunOOj4ykHPa7PI68eB50//GHe+4WArUBSsjjqK09uY+YzN8xWXV2e0PchBSawietNjjwzWO6yx9AS24RzxPWJvgzFpP8twwO1BOp6UO6MJP8lu7CLRXbwi+er3fulAPY12Jv2u5FgNMXNAdaDlfvL6fKM7cp47wxhjTwyeoppi6zkPH/6A1cUZ0+mcejplOl9Q1lO225YQPNYarHMUpTKpJ1y3F6SQNLzkhlvn0qbds2LDeTWcLuSPdXjGVRECgiURsHvGWXenctSIEnOYvhfijdwTu781GPl8uhkkG84hlhlenub7otlDTcAz/I5I9qIZf17GDRnzhjREkyD3vU9GfPDARLDWYkIkvmLyL8aID8lL9d5TlTZfd0y0RoDCGmJguNE5DFUwg6duCN6n+xclY7lb1pnRpimDZ5RvvIAxjnpxhNHn1GWBcRaZzlit1ixfPEP6lmk9RWtLYyzTyZyqmnD39hRbXHN2fo5qJEZQLOXkkAhMnAVjubq5wq8vsK6E6mD0XndbEwbgR59IMzbDc0E+iMefi4xJNIbNmzGXbLTJJ1k+QCX/nSEPMD5vvwhCd8RWX8J2uFZjIHrFWUHDcP3pMNWYvKshgR28T1+Lg2c83KNsdNUBJTBBdQIyRYoCPQJzy1G9fYS9ecod03DfXXBv2rG4+RHd83OmPsJkQVvXLG3PndMVi6ND3jp1PL1seXS+opcJm75gtQ2UocavPZWUoI6ryyW+O8f2Fehi94zuTC6f5uQHezCYzZ012f07Yat72KafGPJIO+MUR3+YHACYHOomqubzo5jPNbopqWXyJrE4Y+l9R7O94ersEdubKzRGZtM5wXc0N2ui76lmnk0XKKcOyUmrsrJUdUWMEENEjdl78NImdkWxd2G7G5a41uHkhe1myYtPfsRXDoRbhyX+8Osc3LrPrOyJXcdyW7DuA6VsIYJvNkhUZvNjpm9+i+cPf8x2ux0BCAhRDFGURAPuwkyNEezgrWWIzPBxMpLGxBF40QybxF3SL7tYEodEXHJ5jRWsSfxp71OCMXlTA0+RPOyfiXv8OZZqIIZIURo0hp0HK1A6h8cnL9sPh1LMPxfRmD1+Y4l5Y0qmSvZRG7O9ccAwfU0FDIZqccJiMWdeF2yqkqDC4uCYzaql27QczkuqsiAESzVzVMUUYydMK0u52uKbhj5CMT2gdBW+j5hiSoieylbUZc1q1RDXF4gpwVYJlxhT1KM7b1dGjyjmt+EI3tEsojHlC/Jz8fLVkr/f5IOX3UXvfThQuoknDaPH/CpX1EgMuoet5n2caIee5Gz0PpuawZHIh+pw2A/Ygr6MrQjGOsQUEGtgAjKDqkAXipwYqreOOXhnxq0nnqJZcsIL3j6YIKsPcdunLOYlrqzpgxCnkZNiztQc4GdzPl4tOWifsopT4vQuSwrWvbA1io8VsTimMwXLy4bYnSOxAKp83xM2YwAD+QDdvfxh7bBN3/NZbIc4Nr0lxzlFxjvPeWfkB74+5v3yedj+DEZ3MC5gnaXtlHazRM6F6cEtBGVycETfbQlBmcwOwVqiBkJIYUz0HldayqrMgAdcVeBjGI8LYyxFWe4lXxiPm5QISRny4Fv+3b/4bf7w3/2Q129V/Ma3X+O3/sEtqmoGdsoP//3v8dv//HtMj+/ztXvC177zBr/65m2CrDn47teoJwXPf7jgx9//MU8eP01/a5AVjQkhQcJwUu4ezgEXiYpEQfIDPSb98u9Kz+ZwsjKG8SGDNdhvYwzOFYgROt+Tjkkdvx6GaPcVb07VSB88tS2IKoQQcS7xzmJArMFE3SlkQsjSrpgdOcFYi/fdnpfAbpNmT9iIIYx0y2431LMZk8MjqkKoa4dKpJzWvPb6LZ5ctLRXBr9tIDpm0ymTaUlVToCCro9cXTc0mzZFQGWgrmu2Ggmhw/se6yNVOWXFkth32M0FTG+BSUkiM3g1mjaSquZXmYzuQBukf6f3wyZ7KS+eAMeYLEEj7gWeeQ1GeFThkJ8zXvlhml5TpPeBunZEAz4ohcsKGpNyJxoHTlPRkJyDn4jtEKUNdFu+OmMcIiVKCdRQOlgoHEH9+ozJu0dMb0XuX69AnvHaZMlfuD/h6tkNl/4F5cWWoqiZ1VMmxjDfXFJS0hYWf/4YXT1naxfE4g266oQzdVx4y00saUIHswXrjeLXLXZzCfEUNGOrw6O246oj40baoxL2I68B2/37mN4ZszuYhKzIGXgzBoMwROOMNuTzsP1io2sMORbJZLHBupLX3v4Wq80NTiy2rInRMz08pphO0ykJdF3P1LnE/UWlqgq60KcEkQre93sPsVKUJYN7sIM5Xe5wA188+Ij/8Ac/5unS4GYTfu03/iKLW6f47oynP/6Qxw8e862//ve5+7Vf4mQ2Y/Po33Lz8HvYquAP/v3H/PEPHrLqhdfunHBcHRD8NWjKwCM5RNGXLP/ufuTXKZqt6HgofJYnQtPpZwbWgxyhjI6FgnE57WkIPuZQj3ETh3F/v2pPV/E+pgQfAWvNjg9TRbI8LGZDGmIyunHcmGBzCDr4QD4EKoodbpK01oT9v5s2bTGZ0jYtSwNNF+h9z91bpzTL51x+8CHtxqOm5O7dE965d5+gSrPxNNtAFzxNExEKECF0LVEVV9SErqPXDbFdUVZVokBUie0asTVUi9GgxvEQGG5yYJdI2QtTBw+KyHCXUh4u3zHZ22Aax005UAs7xZGm+5Hv8Us60Fe4VFPy05gSkZiSXukrqCbqJAzOhZKwHfboHrbe+9HH8yFQZQck0X02KZtChdoSmQkcKBwK5WtTumlL9Ftm/VMK/4Sv36owjz9k+Xt/Rn+1Rbxwcvwa77x2im87musNvWnoa8Wdn3PSnMNiCeEaPzvgtLzFY6l4piWXzRqtvkLtDCvriP0a6SpgkSOufGyOJ9xP2Jjkz49RSdxFLqKIDt4s+fkwO2OkyTxLxnQ4THfYxi/E9vO1SDJk0VNobzKfp4BxFWK3uHKCK2qcs2zXSzQGfNcQNL2fzRbEEIgRyqKk9x4lyYlCP4Q/6Y+VdcXgVetA3OaHPEZFYuTH3/8xN13Fe2+9y9//T+5w8top3/u9f88HP/qAB4+vaZjw9l3h9/7Nv6BonrGoWqTb8PFHT/mTT5b84OENXS988OCGe7dmfOtUmKY/m/yavJnimHxP7l8kEvMuiiaBakyiSiQdh7vblqmBhL3sjDSDPjJj6IoUykUyvZDCnFGbPID3qjMuOnC6ybibjKnGOFI+aUPGZHyjYhkOpoiYdBh770f/Z5AfDddprHlZIpX/dES5vLikbc/Yntzi/OqKKEI9nfL+97/P9vKSSX3CV9/9Jt/4xre4uOk4P1uyXrXcXF8xP5gDJV2j+H4N9JiyZH77NYytkwemHX0f2N9Y0q9RV6WweDCq433VbHADI70gMfH1Q4J1+L78ti8RBHabcPh4n2bQbHSHZ2DIZ/xirG7mdM1LzsAgC0vfooQQMyeumBHbsMfX9+OVxfiyETHGIkaSp1sZdAYsgCPlkgv0csPdsqW6ep8TOeOuu8OH/+J7bH/0nEmc8d7r3+Abs/e4+OENV59cszq/4ebmgsW9YwjQrzp8fYMuzrGnU06/3lNMa6zUGDqCnzCRBWtXJ3qoX6OhQijZeTV74Iye+nhJGdshmvnULYQ9g2wytntUw6BqGc5dYQ/bOOrxf9r6Ak83hcDq00sxJgdbMRAHaRGCFA6CIlbY3txA8KiHrung+BDvW4qyTKJ6Al2f3J++7xO3aACNFEWZN66MlIlozknFyN0jx/LqmsXxPeZzy7tfWfD7v/sf+LOPb7BmTmsCLTXR1Uznxzx+8pj3L54zqy3NJjKrKw4PDWLmlAQenT2naYRff9Nh0JyU2fe05SX8RF9SubHLSw/GOm9YI6CGgRIZDhLYz2AbrM1iLI0EHxJdQdowMCga8lPyCpeiKZxE9pKIOgrmY4yEkBQJSiqCsNnP0SydM87St13iSI2FOITi6f4ZkZEL1L2/jMJ2teLF0zN8gGa9IelBQIJSTxb88nd+mTe/8R1uVh2PHz3h/OyG9brj+vKKW3d6jk9PWJ7Nib7HOkuzXdNv1tjJDFvNiLFh99xnqkN7/OoZ2CIXu2TOzhjQCkydEQ35fTbCojnSk/Ha0oPJaLQHLctgyMWYdJ+Gjbm3OWFPH/sLsLqRuIft8PoY9bYxxhHfYS/b4aoGbG3CVmNM9ycOhik/ucbmBLvNuTSFKehc2cqK/smPiKZnsn7EkV5hr47hWaRezvmlN7/LWydf5ebHN3zyxw94+PwFz1YrlpeXvP204/W7d1g+q4iuwx47mscrQrhm8XW4P+3porDSJRVFjiIFE3v86jmsS9hY6JYoSzBr0BJMtYdpHN/vIp39/TVQCDo+I+O16+5Lwss/NsrFwhdj+wWersGY4SFMiQJjDH0M+K5FjRk3piJYN8EVQnCR2K3GB99n628EyrJgs+3QOOVl0ZVQVuXoSQ8qguQkKncOa9585w2im3N8NOVw1rJeLvmTHzzCT085OTpmakoqd0A9qbl1+zauNPzrf3lGs+mYlxOs6XntZMr11nE6P6Httjy8vOJ0Jrx1kO5k2hCpekxVMTpketPNHhm/7IkmjaLmjwXNJyOSM5zGgATA5AqzHYzGGgSDRo8PO7mY5A2tI2doeZVLNY4ed/o4hdtJj5wOnxgHbtYSNT9UmXYAxVlLS9q0oi4H4DrqjEdqinwYDU+qCGXhcM7SbhtiFMrpEUYc9+++xunRbd56711WrWd5fcPlxQVXF0vWNx3eB9Y3N5yeHvHmm1/h449aurbBFTO0b5HJHGtrerWULmmcJcZUBRY8sUvJ03SIDkoDQYspzF4HDWjsQD2xbZC+IBXkSKqANAaw2Zjmw5ac7BzvgOzRFEPUs+8t5YjiM5v9Fa2oo4FN2LLDNgzYxlGlEIfDQDWrfBTn3IitGbDVndOVwul8GLUO3YBsFFkp5aGllZrVZssiJlWJqOX+8V1uzY55694brJc9y5sly6tzNhfntDc3OO/plkvsnRPefP0NPnr2Id2Nx8UJetZgXj9gMhckBmwhqHFIb5DeErc9cdUi16DLCP4SOANZosUEZvchBlR70D5ja0HsT8A2cxSDMHS0rpGkC2YPWx2DqeHbdnKxn47t53u6MMqzokacWIw1hKj4tqE8PIIYiT4gBmxVURAxPmYOsCOGtLv7vgcdjG6bODUryahp4kSKokgVZCHuUhiiLOoJ3/nGXarD1zi6c5ePP37Br/3qNzg5ikzqiktTs+2V6uge5fw2TgzGCs+ePeXjp1fMbOQbrx1wcHREd7XiatXSNi0nhyc8v7zkgxeBuTUcTZMHKJrKJpVIkCxv0+zxxmx01eQsZX7WAckGN8bhAR02Yzo9DZIyoBmPseQyF18kRzDTG5qSG2LsSxrJV7KyN9v1ARXJxRdC5wNd5xmy/H3X0XctUtfptUmShkXV9Nrz7zGDrxxTsgaGUmmbryZv1sx1GmM4Ojlm3QSknDE7vs3B4TG3j4+4dXDIdDplEi3tTYtzDo2BGFO427ctzXrDrTsnnJyc8uzpYwTBmgLBYF2BkopsFIMxEY2B4Dv28wfpXb7nIWfqY0iGN7Tgwx5+WQIvIDoUuuSNKYnjFDHgilSMIckwq9i0mY1NofuA7WB0XzVtlK/tp2MbPoNtdgLTPo/ZtNgdtrtE8nCAgEjEmoDQoE0BS4Pa7EhMhckb97gOW46KE8pj5WBScue9BbfaKbOiZlIF2k1FeeqoVpGDNhCdYsqO1my5ffc2p3rC0/MX0Cq2s0ib2xKIY+stHTXSGvQmEG56pFHogBAAD+ozlhlbjaA+Y9t/Ctv0bO+wtRlbk7F1GVuXsU3fn7A1IH53cI2JtD+npysAmoW/OVPvjCWGnm67YXHrTqpeyfrDxP0YNPRJuhIDIUZCDPRdCrWLomSzbTHG0vc9IQaMpqoha1O9eKp2UlQFE4X7d48Jfcf28ikRT9SeN7/7Tf7rf/k7/NlHG7bhCX/1V36Zb/7qX+dqs2bbetZnL3jx9Al9H/DW8WLdc3tuKcRgTMOT5TmnBwcYEZrW8+Mzw3fvCS4TNCnnmQxw0CQly7dj9L6Txzv0fIAoEZMYsvFBjVGIhvzZyJgBNRHrUk+FGEFDHI2AQQhB6b2nqgxJqP9ql2qk8wFrlevrm8TzxVTWPDxAXdvSNR0Gw+Jg4NgBTZVLUTXhLy9HPJLDb2PNHuGQ33L0U9V16qVRROaLOceHC7waJnVF4SwxOHrvca5kOp1RFnO6rqOuC8oy3beTkyMuzp4TYqReHBNsSdQOFYeVVKARQ08ITfLKhP1Xsgv7B7BUIXo09Jni2tFDMEjLQo48w5C4HneLehhLZyRXLA2yv8Jh5Gg88AaVzKtfadN3fcA4uLpegio+avZqdcS2bVoMsJBFjtISOMa5FNGM2O6a/uQgGmMDECAWsKrT9QdFZ1DcnRCObkF5SrnwHC8sfqbUxlI4IThDV/e4OyVTZpT3Stq2Y1JWlKcFOoHj28ecX5wTukhlD4laImKIYolSE6hhrYSrDlYRGkh6OM+OFvo0tiFjq5/Clp02WxUkIiqfwtbsYZsrMQcatHAYOSDZwPCF2H6u0bXW4kOunMob31pD78G3Dc46+hhSo4cQUnWQQtSA7zpCDDlpEOh84rqKomDbtYlDzZs2HbURV7i0UTvGpExEefjwAT/+3jXf+sYFjx8/4LW7t/mj//Bn/F/+yb/jeHHMf/73/1P+9n/2D/jRn/0hH3zwAe9/8pjJpCYGZbVc8/hpww9RvvOVBe/cXjBbt5xvAuvtJhlYA5ve8OxGuD9XjGVXTaUCca8GXUlG1jLKftLnB48gZqM88HnZiCv5BN2FLJK9xd4H/HAi540T8t9RckntK1xDRZwPinNC3weatgORdOiJxVmXpEHG49zA4eUSx6zlTJnaneQoicLNyCRYa/PV5OsdrXY6yOdTS03B8cGc49kEFUttHQbDk4slXefpg6fzPae372NsQd9tsM4RYqSspxyc3qHtPcX0ECtK0wTEFBSTCdDRr9eo7iqvdm+7tftsRGOW7r0kht+jBvY+K3vn0BBfyngg54dF0wFuSptporRXfhE+7vA6lYiPSi2p6KZpWxCTsTUZWzN27Bs6+aUinPS5oQIxYRtScsgO1x+xNpJcS0ne5U0NvUHmwBLsnTlVccrsoOVo1iFzqCMYozxZXtPVnv7A0/U9J7dvY4zF37Q464guUs1qDo7v0G0ipSyIxtHGCFIg0yO0XxDWDboKsAVaoFMgG93BQx88WWKmjuJnIv8x2TjAyFDItJfMIWnyRwnhADH6KWzjF2L7Bb0XBKMGmyVMQgoZIxEfWqwxtL5ntPAh4HtP3/WpTVsWagP0wSMiVJWjWXWpQ5cnVcLkq3bOjRnv4WRVFS4u1vzh7/4RRnuurtZ8/c03ODvf8JXbt/n7/9k/4u//w9/khz9+n//2n/9rHj5+wg9/9AGHR4f87b/5m9w+fcS6OwMNfPBsw+unc44XFS/WG6KmkmMrBuMK3r/0PFwGamdwJmKBSRm5U6dTzWPoUXpIZZVZw5eFCowET9Ts02ZveNgMcTh6c824sSBC8P5TtfjCwekJXz16nYePPklNgV7hGjLbISjOltRVjR02neQESTayQy1+9B4zNBxi4KohhiT7S0m27F3kZOFgdIelY1VQ+r8VQ11VnBzMKJ1FMckjC56r6yXPnj/j7Mlj+jbyrHuMqypm0ynu4AAjjl49xfSAvgsURQ020LYbjHNIUVIdnqDSs71eQxwONdk7FIfdN+i0+2R0Za+g/FMZkz3VX/76nmHeXenuE/kgjdixa9xIL/wCTO9QvRlCwNmKuqqwZA6f1PRpEI5bm9oZJmyH6zUZWyGEfnyN6fm0OaMRsTaQ3MsIeDR0sCnhcoJcC6GvsPMFBwcHlPYSTMDHSCc9V92S55unvGie0E9bnvMYZ0pmizluUmE6R++Voprjt1CECsSw0hZTFIRiSjG5RWVWbFfPYOVhDXQR1QahA+kZ1CiqEWKXsX350NzFYQO2+wft+K/RGO++qHvYmp8L2y/U6YKMmkwAl8l39T7xuTGkJEXw9M2G6HtC3ye6QzTp/YzBB0/QQFlVrK62maSXzNXVKRw1qa8rtCMZrSiunnB4esyzZ5fcnTvuHFTc/eZf4Ftf+8v85b/9t9isz3hxdsYHHz3i0ZOnnF/e4CM8Obvkr/6Nv8Hlf/NPsF3DNiirVjmdTqhY4l2Bc5nSEOF624+yqBEaUb57GrlVCdsQWXnl+YWntAYniXkunFKJUFiDEyiM4CSpMqKFMiqOpHwwpKQEYkZtnw8hc7q7nOfl+QWPrlqsMwR9tfSC5Cq5EFITFnLSK0kCk05TNdKJIkVBVbjkxe57BLJriDQ8ZDEnkAbP1tl9TjfH4kNyMP+iwtr0ZhIv2gPX1xvOz855+vATovdYW9B3Dd73VK6gKCqshT6kFqM2BsqyyP2VU0k5IhRFBQfHtJtrNHRo9GhMz60SGDwJMQ7RALFDBq0tuTkR7O8+dhswbysdtqmM9f/jRtbh+wSVXXvOXV3+q6cXRFLxQwhJQUJOhg6d8pIDpXRoOpg+g23W5FhLzH039l9zgi/izGB0e1QboAAtYHkHrgv8xuBvTVFX46zgLPQWrto15+sXPL3+BD3wuKmjKzp88JRaUxzU2JXQrQPWltgApXcIFmKDsY6Aw5optS1p+zXqO7T3qK4htigNaAvSIsYkTEdsdxjI4CTt378Bo/y/8WPZR2tncF/CVlOk+/Jv+uz6fPWCSRyQmJ1+1dgUV/fB0203eN/SLhUNPdvrc9QkLu78/JL1pmE2P2I6MUAy0EVV0Hbd7mQIO1ddRHCZrxNkbMIByjtff5fV00/41tdu8d5Xv8J7v/wOwd1menjI9PgWsx9/yOnpMR98+ICyKECFvgkcHh/z9W98nf/+d3+P4+MD5lXBpDSUBrRrcGKIaliut4R9YWP2/ATJ3Cx0EW5apdOIy4UUcbz1OdQmNzcxqX+qc1AYKG2S35XWUBeBwgh3YuLOvA+J081gWgO+S1VjiqGWkle5RNK9DTFl26MYOp8kTsZmTXIMNJ1P7TbJKoX9kmZSCXPwfaZUdhlzhnuSTt4kJ8yf04zt2LcWQSP0EUpjCEFZbVsuzs/RoBRlagcaI4gqTbPB9z530lKsc5RiscZibfpb1hbselhYKBeYap7+VvBo8MTQg++Sd2tcftgdmIJkcHMYORrPPV/nJe9397yge5HA/qfFIrbYKUBCwFnBvtoAZvy7o2xMhIjkzn3peYykv9/0iTYKkDvomdHREUnYeu8ZtOKj8yYAEbERMR3RD0eMABZpDzDLAt1Aw5RtKGldMrpBIjex5aI5R+eR4qBiU7RspMJqpOy2+FmgUEdwEesszgkSDU4N+IidFkRTEL1BOgNhgZnME0zdNRoPieES/AXEFWrMp7DNZe/7NMFL2A4XKXwWW2GgkHbYGsQ6hrYAMcQvxPYLEmnJhBhR1Aw195JKQjUQ2w1d1/LxJx8So6ewCbCiLPB9T9d0aMxJl7EqraLvexSLEei6jmlu1ChAVZbjfRjkLqrgqglH979CZRvuv/ttju68TZA5RT3n7OnHXF9ccHI44Vf/wneYTUtWm5b50QLve95+522ePviYWwcld28doP2G2iqzSc26Uy5v1rR+8HCGcGO/vDeJ/9ugbHzEmtSoZuByh3B64BkGJaCP0HvoJLLthUAi8Ic9e2Ir0FQYMZyQwyvwMSBAWRWpz+0rXGMj7RxWJ742a2rjrnxSgeB7WlIjdVPa8WsiaeKC77t8MOnI6Uv2asdimkHCpOMtymGsI6phUlVserCF0PvItunYrNeYwqVEnhHEppPP9w1ts8plwT2CULikVkkZ95ALM1LEEmMA36YLr+aoLVMVVYioS1xv6oVhETcfJW+4MnuNfSqD1pScEY3JW9ac+MwHZcIvJWDGCROQpVlliuJMNrq5ZWdRvPoEaVL/KEET3WMyhYWmntSyX43mPR15ukRV5STnUPJvCH2bsCVmHnpo4JP15lkql2RyyVaIKtIbaAzXfsGmusfj4op3XrugrwLNsmV9tUHrCddRueGYy76miA1mcUNzvKWaTJA2IL2hMhZ3KugB9AVEW6Zm8CXESYRZm6iFyQLlIPUGCQ51BbAYlSbiDnLD/QCuSLckpgM4ecBJJz9y+p/BNiVOP4tt/XNj+wWcbnp4h4IFSA+otcnLCL6jrqfUkwVt22ANFFYpncMVJUWVKu/FZA5TEm/ro6ePkalx+DwyZmh5WFT7VSXj1YFAeXDK8aLg9K1v4KYnxCB43/HjP/0TPn7wgH/7+3+CqnDr1gEHiwVHsxkWOJg6vv3OLabScXRyzM1FT1VYTk8rXGlo2oarpt8733LbQ0kGJmokKNx0cf9gHO9HIt0/nXjJ91AEwRHzSTj8fPILAmJSsiPGsEcv7CZXOFcQdvXAr2SJMeD7xD1HRq42ZBG8xYxFIJpfdYhpbJPkh9BknefQfN2I7PURHYJsGQ+kgV4Y0hohBEQts/khs3rCsjdMbWp8fXF2Rt81iDiqIsl0bFB81wGBprlmMlXQRGHUZQkGmjYfXjbdYEUyLSaJ0+23iJ1kWdcA5MBHp37GSP6anYB1yQSHodBBk/OLjvchYRZJYu6Ianb9ok9cuChazHMvil2loYih+BTn/UqwFUPSo2rW1iYPLWrMkfSOfxyUJEkOmrElT+Awgs+UosmyyR20g0wuRQWoJeUpUrtH3wVkBbh7LCcLfthvOL7f0c87PvlRw5P5nK05YKMT1sy5djWmvyFyzlEJ1VEAqxSVYG8VyMSwPfI0tqKTxFGbOhAOe7itUHWwWiNM0O08Sf9ogYASsijIgRQJXzsBa/awVXaVT5+HbdjD1hMlosU0lfsPz/nPgO0X9NNNRjfGmI1IMiw2a2n7pqGaH1DVE2yRKnoKV6SgzFrm85rghaHicdBoWmdpmp5FXRDi4OUlT6soqvxADD8x8Csp/ClnJ7jpIVRH0Ky5OH/GD/70T/ln/+p3IVj6ruHRoxdsFw2//u1foiwrmvaGg4llXs6ZzA/Y3FxQlGmUz1uvnxBj4PrPOtoAnQ/4mCt4SPRKE2ET0lt6gNOptjMo+UFMrxwyJTGE8Wry1eXDSxUmVnE5qx5yOS1CbiVJGjEkQ833q+X+TPZqI5pD9CF7HQfgidkzsulJIvi93gSak6xi8LHPRtjsRPnDgZPH03x6DXyadRWnx0c4gaiGzqe/c3V5iSrMJzXbpieqUjhD5SratqfvW7zviDisMRQO+hhZbdbZG4UQUytDVDC2IvRbrHFo3CLFFNWXU2I6vh+SxgOhZ/a+Yl9SpgxGSnbuezJ2Q5JleIaMpbB99gwH3k+Sdv0VLzPIFwfO3u2pThIoRDXExJKCkrrJDc9ZjOMB0ee9aUwqVd/RR5KVLUNJdTK4UCZtcgTXFBy6U850Ths3HNpAtHN+//qaR5TY+haXjWUda9piwqRoCO1jJqGhLHoWd25wE6VcW3ojLCc96zCnp4DoqYoOThTzWkWwW6zzaNwgYYr6CVCTNGTJ8EKB0mWeXj4V1ULqELc7XGXc/wO2JmNLxja1i03Yhp26JUesn4ft5xrd/dB5bGWIwVqHDw2+b5g5i/YrfBeSLlIqOt/TbJZMZzMS0V6O8iJrLIVzbLYt4aBO4WxMhglRijzDKd0JGTeois38qcG3G8r8BFy+eMCffP9PUTUUpWXdBHzfsxRhs95QHB4SfMdsPqdyQlFVhGCoywprDUZh4gy/ds9yOjM0rWXbRdatZ9XCNghHVrEizKyhy2NNQhj4XMZ7FNHxxBu0rsaA3X3jaJoXLmKLItELfcCWFcEUSUeY+VBrU0/UEPznwfRzL9mjEnyIFM5SlkVKIg7G3oQUxuVrSuWjAyO7S7aodmhu1Tm6TunSkxTJ7HLCSQeaHnYjhul0zmRaIb4lRoePhqbt2W62TOuag6MT4tUyhfgI00mFXW8IsafvO4IEnBOcgeW2Y73e7oxmzAe3GExREXyfqrM1ou0KKeYk3WVq+D0ciOPhOWzK0dAM5aHwEgc4Pq1DMxjJz+ugFU0b3NpEpzFSUnuG8FVia3bNoXxQisJQlUXu9SAYsSAxz/RKkrDPYCuapJuqaAiZF929VkUw4jBS5I8KlIKUELcYFaYyY7ot2Vx4zuqvUFhH3x3yh9trutoxPXyDZ9rSqtDFkqMJdPYAE89xvuOYS+4er6luw82m48nScc2CVgssgZoN7qjAvFESYoepSJV+7Qppp2iYonQYCaA9w8Eg+IytyU5ExjnztgOqn44tBwOcsB0aGzmQNATADM9Etpmfh+3nJ9KGptXRJO82BpyzqcWjhxjSHKbCObq+T7yRT71aBWW93mCt4ehogeQWgmItprBsmg4Buj6kqiZNNMaQeSZzUum5TfyRFZhWBUVV49dn9F5YXV/x9OkLikLZbD2TumAb0+98dnZBdXJKr1AVJWXlsNbSNFvK2mWJGrSd59mN4gyc1DArlKNK6Lt0/Q6l8cLb89Q+7niSqJe2V5pO6Y3gVdh2ShuVPiRJmSf1T+hhrOBCobDCYZU8PbB0nceVFX4yx5BKFUPsGLpRTSbTn23H/RwrHQqp4XVZpGSDzT0DzFAPaFKVjsma3MGNTSGp4pylQXMpcNZ27tzjpHAYe7EyhCyQjdP8YEYboG5u6LwjFAusWPquZ1ZXzGYHRLWI9JRlReEcIT5n26yI6nMpsyeEjq7rKI2yaT3WJb1xDB4xFmMLxJaIsVhVYt+gsgE72Xkymb/bp0b2d16UoaIwb7x8Qckj2uUBxj4r0STLn+mE5HEO/RB2Bv7Vr3xo5GbmRZlE/cYkD9QMobRN2A7VZy9hG4dJEamwSdSlGWoxOU3JUXQYW2bDVe3ejMFEw9zOaM+Uur3h7HCGvf8evV/ww5unVOWc27yNlwYbPYe2pigtF75m3U+w6rliwVZXdMWWc7Ph2hqu2gm9KygsTMKSo7LC36rxbYEUDush3jRo00JfIlQgPmPj2E0zNJ/CNsvF9qkwJNdX7LxhHSLOoXY6n9XW2h22+sXYfr6nGwLGlgTZnxSQJWRBCVl7a60QfY+PLUUWmGuWXsUYUqcqhD6AKwqctTRNl/t2ZlF99iJs7i+rKqjGRFXESIgtdVHx3nvfwAn02wuaOON73/sBq/WWuig5OlhgRFlVa5pNx/nymuPtBhsFNz1gMp8QujXbTYOzQ+VY2qgCXHdJKnVSk29aOq28xjRzKucLpk6oS9BS6AoQl6txpukEDZkHjgrRCF1IIWfbR5p8qQeVxRUVIkLQlPEUV9Atl0yqFN4rwuHxEb/xP/jNn22//YxrkAJqTDrqpLQwBCP4rKqJgwHK/F7fpeTRyFvprjfr2BBnaGu3SwG8bHQHUjA7xPNJyaZT7PWKvu9o6gVt7xOVIYZqUmCroxQtOEE0MFnVbDbXbLYbTFFjjdC1BmeFo8WETbNBchl438bM4aUWmiEOG8QioQMxqK3Z3yCJLjC70DJ7tsnQDv5MnjpNfKlp+b66I/2gyf5vSr5K5lbTN5tXThuNr1TS3gm5HN0ZQzRp5l66yIFqSM5M77usvMlcpqSDNsaheCndl6GRi+SkmTElSQ9RkgxuCS5RqjMt2TxV7KMlXbliuXqbZuXY/MjiZgVlmHDQz7AiWLFICNy0pzyLHXHjOSlmbMyKm3aFNx4/N9w0W4JUFEaZdEtOjSNWU7qTOg2I7QSuDLJpYVOgVCRzGoCkA0/YDiO6hgM2GdehynQYJPAyttmojp8b2ndq6vEhg859wPanY/QFRjdiXDqZjQg9CUyXG7CEnIwp6xrsCg0RK8PIZkXFESO0TWo4LapY4ygKy7Zts3MRGTvjSGr/ONwIJJ02MXOdd06OOLj3Bk3TYfuGti/48MMH1FXNm/ff4PGDjxFnuXN6i2bW07cN2/WaqXTYusYWBeePHuN9m8b49BF1BdPSsnXCsg1YLBoiRyVZ57ijVpCQmiSTDNHQKm/g+Ez2ajTLvlKGf/gORavhWRc6Yyny2PnUu1TYrldU6oFyTHYEH9is158H08+9TNYIax4X7YyhLgziYVYXFFboukjID6gtCkLX5obXA9+eo5+c6ZX8bOSZsgytOa01QxuYdK8yV2ZdSVXVPLsRQhNwzXNWN6/Rt6lQpCgcxiiFs3QhJTmNRKpJmgDR9x11UYEk/qwq6twEP6lrYvDp9eYe0CIOVZ8NsiUGRUJLkhKVDPKKsSgCxsNhDEEHLnAc8T1szsF+yihVY5jDl7lha7OnO2QoRX4RNjcndrPDEgOFKamdRbwwqx2FEbpe8ZJGV9miIPRtUmjIwLcPWXodDbSOSdJRyYu1JZH0vCJFcnYLxYmjjiWfPFbCxuPCBavlLfqmJ/6ZUtxySITS2FSpalPPhooZYeM49yXt3WM8DVf+mlkRqSrlRp5TmAoXPXXYMjEGZMumPuLy8ABpC8yhJV57ZNlDb9JrUw8UCIMc1TKMUxobHw0w6+DpppWwNZ/CdjRXI72wi2LYsxk/eX2u0Y05QZKaFqdaZRkkRiRvN/qeqiqY1BNazZ17rMEWuYGENbSdx2bvKmikriuazqeTVPLgu/w3rbNjzf7QDDp5wCWvv/0VOoWzbcGd8IKiOub8/IKjgyO+/cZ9ytgjhePo4IDr5YaPHj9AfUcfW/xsSt82XF9d07UtxSRJPbq+Z1qXbAqB6Khqx9llj0GZGt3LSrLbkMLY21ryaZd0qrvTLzk6ya1NPpLJE401g5aUGkpK+oyTJsyeLAvomjXvf+8PPw+mP8eS3ZTjLPPqQ/JYPSm55iQyrWzyDG1BoSV+DJdjTkSl1xy8zxIcZTfPTUcuc2xzOGZi0jOAK9h0ymopzK6eYcP7tKZMs/WMIAb66Om8TxQH4EqHmFQtpZpefzCWg7qg7wFjU/csn6isKJJ1sukwTV64TVGORgjbl8P+fH8GT+Zlck92m20v7NxjgmGgB/Xlz9usqBgKY0Bzq9NXuwZZZ8jtG6NCH1MjehBCBCeRgyoVBe2wzSF0dhqG1+19T5mNceL8BzpGsLZANc8oNAZcBAN1XQMVmxvP6oUwWz7H3nxAa0vCucfWBrMWOgKdD0hdoiK4skQ2gr8KdHPLebmgtQV3a8emb7iRjto4rN9iLcnLNimqkTw9SBYGORJoFK4FdIKaKqM0JZUJF6TimJ5UypxKhxWPsJ8Ak/G/9GFuY5+jgoGMsLnZzw5bPhfbz+d0Q+ZD9nisqEOv1MTR0rdZWpY4rIAjZq3iUOPdtR3TSdrkEpWiqlhe3zBUKfe+p8y9O1NXLUdKwMVsgNJrObx9j82Lj/mDj6f89dtX6K3Icrnk+Og2d1+7y/G8opjPmMznvP+jT3jw5AGbm2tMCevWQ3fD0d13eP70HI2BspqxvFlTFlCWFt+lU88AF1vB1sLE5eKI/EKGeVMvcX6yP1VgV9Sx23gwuE3Z4SGQJhWjZG1fkp0U9YQQujT4RZS7x5Mk4n+FK3GtKRkY8rUZa6gKy7YP+Kjge3qSqsKWgZv1hrKaIEU1JoOMpJ8bxvaMExH26AVrd8mJnWAMFosktUEiy1BBD9X5J2ym9/Dec3b2nNnRnGiKVNZLatjSa0gacZ8asat67GTCfFJz0ffjhAtVcK5EfUqiiHGpgjJl+BhUJEk21AIO3UOLfXzHlU1uPnQ163ZHDzhjnIOhdMWa0nXWmFGKZJ2DbWqP+cqXJNVICIEQc8c7a6idZesDPiiEjj6ptDFlzWq9oaxqpCg/g+3QzHzoxaAw0gsDtCKCGiWNXhcWi1lOTgrLbgJbQ/XkIZvZPXwTefH0jNnhEcFV2KpAbBoa0AdP6ANh7SlXga0TOD7g9mTKTX/D0jY0MWLVUVkgdKwUelMnqshFWBg4TnSfTADvoXfodgZtlZgGM0kPfehIjRua/LYlKRdC7ig3eK6ZIhsinIGe0yQUTdRRigZ+Fmw/3+iSkgcxH26DN5aqf2ziOn2knh5gakPBFFcdpDE+oaWwFhHPpumYTqtE0CNUZUHTtYhYIj43Xc4ktKZ+nmOtV5ZnVXXJfH7A6ke/y0fn3+Wk87xjH9A2qUF6Ma2pygOcBbWRW8dzJsayXl4zPz0i+p4uNNx7413q+ntURVIFeB9xRigLy7btEU1jhbZdz0XnuFcqllSKm7zv/DJH85ETLGPoOcjrNJdCm3EXDp9HQY2lGEowNZ2WpnD42GFzgcKkhG/faimr+os328+x0ssxDKWwKeKwLJuhdzK0fWDdNjhjqHA0rUekpyhSKD54Q8OUgZHPfWnKbTI2u4/SdRlrmc3q1L3NBwLC0hxz6FdsVitQZXVzzcNPPubeG29zuJjS5QNidXNDu91gTMF2u8GVE06PKiZ1gVmllnzR95lqGAaapkIMTGrdKOSWfDGmZk5WcNZgZEroe7ouJenGkzPBt+P1ssM3ni4DrqPzu3cP8peH/iWQynI1hlTd+YtYYlBNDlNyTg3L1g/+0x62UKll23pEPEVR7GHLHra6w3bn6md+PFdqiaIWjLPM5hNCBN8FQjAswymHmys23Ro6Ye2XPPzoY+69/S7z4zmdJGZ4tVzSrjYYsWwvtzhqZsenxOKQtRiWNDjfUxcLehPwfksjSidlujAXkRlwbMAq5sSlajYMJkwJjadb98RoEvWwdHBTQegQVhnbDpVuD9uhom0f1uG0GbDdVfP9LNh+vtHVoTCCNKJFZNAPY62lD4GuWTNZzOnaNQFH6FYEO6U+eSON1paWcHWBssqjX1LJoQ+eLngKm8e+5Ic1lQK7UReomqRYJyfHTIuem4sfs/nxmv9rI/wXsWe9WVOWKWvadmu8gdLAdFZQTgpumgYlor6jLByT2YTSSsq8tz1ladEQcC7lW1QjRWHpek8f4XwLJ2UkxOHgIUtCdvdm5Lo0GZiR30PHUTgDzzb6vs7lFnqRod1eUZbYLkDmMGsnTA4P6Ov7P9ee++KlSTqkaUMlPadlUEtbaxlG+URNvZA1G0iniYYYHjpjDb7vx2dy5P7SRWfZWE40KqgIhUsHzqZXYvSAx9dHrLY96+tLBMVrYLNe5fuZ+uKa3Iyn7z3OCnG7QbEcLGaUhaWuiiRzszWutCmhK/3I60ZMkm2JIsEiJt1zU1im0wllmQ7B7bphebPF+5w4HAPMlw+Ul9/v63l176tZgpU5dO89IWs4Ze9AenXQ6ljsornh1IitkA/BXL2nMlZDeu9xmQeGRIsN2I5XMvK6MBgYkdSSTw2oFVzlcGXBpgf1Ebzi7QmrTcv6aomE1Gtks0p5iqEWwBbJgPdNj3NKvFyjYjhghmsLbKgJXY1WM3CWjp6WMiXZAJUeU5nhlSFTcLbAGsu0nlDaAu2V7U3D8mqLX0fkQtBzg1xPYSskqmHDS9HOp/69wzZV6qWoMal7fPCEvvtCbL+gDNjk0zGN2Umhm8+bzeFbT+y3qadAOWHbtITmhk17yTosKRyU0rG8WXHwxvEYShvrwAhN02OnZeYVB17TYKxLmf/E2iBE7r35JoJiJXCv+TP++6dv8qMPO3zT8x/++E94/f4RtyZJhiQCrV+z7Rqa7YauaRDf8eZX38K5krLIfQdUqcuKZt1ibTIG3udQ36SSVI/lutNRg5uM65CpHzjel47B7AnvJimnz+lLgylNUSCkhjGTSYV/oZRlhURP1zWokkT/wbLp9qY7vooVU0URYohRCVEonWValcSQ+hqYSYWXdI+MsxgdegdExnJb4zCSB4xmmV/MPYEHL3E3T63PxjNzm0PBbehS8rUq6fUIe31G6TyunLI4PGIyX+BjqmArTGAxq1PPhxAxGrEG5pNirKCbTKcpLyAR71NFX4yB1Gja7JJFuTzWFgXWJomZEUGtpZpU1F3P2rd7lEM6WGU0w4yf2xnc4Vv3tL65gg1Jk3lTz+nE/P8i6IV9bf0wCaR0JmMbErZa4c0etrFk0JWncu7UY2Uf2+EAHi9bSHI84/BBECsYJ2CzOkBB+z5FbbaiN6eY5pxSA66eszg4ZjI7oFcl4ikUFpMJRi1hm7TTdgrzUBCXCkuowxQbHNJDUEeIQt+3qE+l6FKSpLOlQdTg6gJrDK42GAcaDVVXU1/2rM87dAo4zQKHGmmnwDU7zn7/zexhm52tvajOh9xhLN+ePze9oEbQ6BHrQJKXMDQ0dlboYiD0PvF2/RX9Zot1Bf3miuXVc2bzOd4p23VDiMf4kGqcjS1AYNt2TGpHDLrTuAFFWTN0eUIDRVlwcucOsbmm6wJ3qxveNU958bTERuHZizN+53d/n3/0D/5HTKczbNxyeXnJo2cvqKzjybNnvHH7gFuvvYmIwdmC9brh4GCeJu5qwBlDkY2xEaEwoM4wnVUUVclsNuMkCFfnl9DejBVbw0TQ3VjmtIYy4iEkTa0d8z7UiBTlyJFba1KRQmGJ7cCfpYe6sxXrdfszbrmfbQ2ed7KhSTTvrGVxdJy0rZqajfQ5vIw5IlFkLJUcIhMFYtiTkw3TBjLXZ7MczUseTYbgfWq4YkzEECicoFEIkwX29D4z+TH33nmPN9/9JpdNoGtbaJWqsNijEw5v3WW9XGOs4+TkhMIJq03L5aqjnkwxFgzp8Oy8p+99SoLY1E1MCTl/INkLBjRixCYu3VjKqqDZNoS4l5Ue8M2RzEAz7Bvg0diOj0Li5lOxi6EYehOjDEUqr3Zlk2HkJ2AbdtjapJrR4HEuFwrk4pj9qw1hqESU0aiAIJpwTTSjYAoDDkL0bH3AGsWqUohBcXh3wGTxOvP1j7n3jfd48zvf4jIqnTS0Eqkqi50ccXR0l/X2BoPlpD6m2AirZcflVUdtaowYTFR8FLq2p+sNhFyWXESQSFGnA3o2SSqiSd1Rlo6AJXilmHfopGFT1uk5jiRPt6sYTeJL2A7/31GIO2zJ2Kair0Ei+XnYfr6nayRJSVwJeKwVgjdoBGeGDlkdgqEoCzAtZTWlrjvqqUt/WAzg6X3MzbqTZtGI0HWJd+p90vIOZ0NZFQwSJCNKWRZMqgK652zaSFU6fvXOkn/1oy1BUgvJruupneBDS8QyWxygIbLpG/oYefu1Oxzcust2s2KyOGI6KSjris22Yess4hL/bE3KuDtrME6YzadMF3MOTk8wxnByesCT9z+iW9+MhiVNgxgyKLvNNPDgZq+L/SCdE1MQQqDZbthsGxAoXUGjKdkznRjaXnh4Fug2my/aaT/3GgxvJNKHiIijKGqsswTVNG+sT/pNDYHQtfRtkxrcZE/KSMIxaEwabmvxIeB9wLpU7WdydjmJ7YU+uQTcNB2l6amcEguDRqEXRY7uYnSDDVtunyyQVcf5dUxjxZ2jrgve/eZ3aLcdxI6DaYUPytmyIYilKFOCx+Rpr2Zoxk5S1gwGRHLiNzfbxJqBd81J4MLhnCF2I5L5vu2XQuR+BuOk351HvHOS0r0qywJXOEQyfbPXOOWVrywbixrpfcbWFdhpiVdF6hlm1lPF1LwnYbv5FLYyRjbR+6RzHrC1OdGWB1Q6Z1Er+OghBlbbnqIIVALRpPyMoMjsHsY22L7l9uEBEjrO24AnYEpLXTje/dq3afsWtONgXuBXytnllqCWorRYlUTNe8VsLcbnFqmVYGykki0T3TBly4EkpcbCFNTWEtQQbcSXDYtpx4e377PtJqlNw7WgywLxboxnJGsB9ycBZxc/7fesZijLEuccIjXWui/E9vM9XTGMGkxJN1izVsrmDHDsPQbDycltTDEHW+HthFBu6LuOANRaptFFmnoKpNlgidAXkVTmqql9oojiypKoqRmMK6pEafQboiloo6Gazni97Pna2vLB1Xv85q+f8lt/9Ve4fVxwvdrQRcet++9w/84pTx8/x4WewzuvEY1jff6UxbykLCa5LVtJs1mxbbJ21wkiEecMxlnqugCThNXWWqq6YHJyxGazwUQ/crboEHxKJuETdz3cfTGCBMmdDgWxluBbqqLK5Ltm1cZOmldKYPXixcgovso1iujzfDYjQtu2mA7EFYS+zyXIifqJYtFyguRJIUP/hqGENoQwTpdIYA7icqEqy9Sro098piL02w2eCiFQ2JSsTX1fC+ydt7m5/IgXTx9RHd3FWEdRlPS+pXaO2XTCpK7RPk0gWTUdakxuIQpDW0aTxf9D4fLopeUeq5o3kJHUsN4KkJszlUVBVRW0bffSXWP8LS/3XcgU9ku072CmjdklFK1N6hxj3Z7H9CrX8BRmHbZmbLsW6T0mYxt8TwjJ2VGxaDlNQzxl1y/DiqRkefCjd54e9NyPmEBVGWILfZOKpVSUfrXBF6m9ZlGkwabGpapAd/ION+uPePH0MeXduxh1OK3oNw31oWN2NGVS1KhpMXVkrR06dUyNhZh1zlEx20QhSBDUCVIoE9lwKDcccsVClpxIoKLnQCwTcaikpu1aNJxUgaaNfHL7bfzGwgXwwoJ3GWUdRAo7nPeSpMOONEazQgescThXpEj+z2t0x2wtid91krxcUcCkFxI0QPAcHUx58yt30OBZbbdcXK1YbXqWa89y3aQWakbGEjoxwnrbIxi6rsf7jqKsUAxVPUGspSwcwXs2647N+QOmRzWmWlDPOkzb8Bff9pz5Bfe/+9f4O//lP+TxD/47wpOntH3P4dGC/8n/+Ld4/OgJPQVvf+uXWV085/rRDzg8mGKKEsShGMqqzKGSwQRBNU0cHZrsK0CROllZa5nOZpwXFYQh25eybMneDF6tjKCNlS/Z8zECtiyZzQ8QYFLX44y7uqpYrbfE0NOiTJxhUX2ByOTnXIOBSBVSqZ9v0EjXNoS+pSjK1Joye7ohj5fZbrapiEJkVJykqRfK0I9h6MUqkhM3YplOazabLb73Ixe+ur6iNHNCn42XESprqJylNBOkfpOHDz7mNVdhTEFUz9WzT7BE5rdep5wtkNLh+57Cwq1Fla7BK21Ik29TFVXMvYBzEyNNapU4HJCkySGDARy83WgsriyxpsPHwZNl1GiPRna8oeOuYdBq7wkf0pdzeG7EUJYl7bZ5pbimlyLjgRpjxjammWih73BFKi7xff8ytus1dTlgq0AYsR1/syRKIWEbsBKYToTNpsFvBXURdcrqxTXl8TQ1uB/qJpyjLA2lc5jTt3n44AGvlTUiJdoErq4fYo8Ds6++Rnl7gT0sMOWaO3rNXYlsYs1NX7JuLN0a4hXoRoldREoobcsiXnPbXnMSX3DKOad0zE3LTGGmRSqFNp4gLcdOuRLPql7w4vZ99LkgE4Nssqc7gDtiqxnbjLDu6KTB0UrYCmVZ0W63PxWjL6AXHNGn4XWY3E8y61BNLqnzUYl9TzSW68s1VQHttsGoZ14GpkXkzqHjxRWstyVWU1hWuJJ10xJyiNZ1XU5uWKwrmM7neN+xWW5p+57zyyV1XGGqKaUvwDqqCfynv1Lyzz74MQ+eXHCwOGKxvIR1aq7z9jtv88brr3G1iURbcPXwh8wXUwqXGnWoSmqUbG3u7pWNR87wGpMywb04xNQULhmaySxSzWa0223W3ZpRMK0iqGjOksPA+yTDMoT0gq2mWJt6P8xmM+qqIPpU2577PxGjsOzhpn3FOt08TCg5qUn3GkJETEoGNM2WplkTuiZzW5I2UIy03tFn77dpOzbrDQeHp7iiTMNRYpqVJzlhlrLgSXEwNHkHaLYbQt1iTYkxQpGr4qpCqJzDThY04nnwoz9GbUExO+bocMHTD37AxaMPOX79XY7uvQnApEyWsAvJsPpcAhs16VST3Ujj7tPmyFtF7OiQ7I+OT30bIsY4nE1FLcPKadFdVPMS65cdlKxGGZwWaxh7Cwuk9qWrXHL7ypfma0vOQ8iRjEjCtm02NNs1oWvzdydNr8ZAG2xqnK8kbFcbDo5uURRlKm3PxTTGeJAeJGn0+36FeptG1huhiVt82eFKiymFonRUU0NdCJUFyyGNCTz4wfdQ4xK2iwOenP+AC/2Ik8N3+Mr9Y+6Zp7wpjymk53k44rEc8NQsOLMLth7ieer6JQ6m0nCk15xwzl2ecZfnHHUdM3rmvaFoKkRL6A3dtkO05T0bOdNTrg9PaQ9rdEJyxHTvDGVnaiGOCeP0LmZnacA2NexiFdjN5fvs+kKdrowC8ASQsS6NaZZUmdaHSLO+piiO+PjRc+bTKWIi602LD4G+96xurohSIyL4viNGT9v1eRxIynyW5SSR4a6ktjXzgznPHjxO03xj5MOPnnD89ozY94hEismEsj6kLhf81rHjv/4n/5T/4re+i7XCw+dX/N6f/Yi/9mtv89a9BYdOuFpuWJzcx3Ab7TaE5pqu3SK5qYdqmkAcQqCua3ofxhE2mDL1k3Vl5ph7posZ6xfnuBxy7We595MpQ7nwWLKd56elibfJG7LOsVjMOD+/ppTE6zuRNOZETIomXuFKNGTyLtE4VpKZXA0XY+qAH3xg6JhkRCBLiHqfBgquVmvm8xPmp7dSUUhMum0d6QWDGt1LQORHVwN93yK+haKkKGwW4+eG5NnxrOYH+HbN+bNH3D+9jy1LDu+8xtnjBxwdHVAXkkPG1EDdx4hKxBnFC6gkfnzUR2d+TmGkyowR0qTg3KQ/zwgLJpULF4WhbTegWR41UBK5L+3g3Q/3dLzB7Az0MEAD1TwZu6Nr25039QtYiVf0DJVkaZRR+vdgPBMWWZVjBmx7ut4nbBcnzE9uoZKeiRCGkuCAikdNl/MX27SPtSR6R78WpO2QakoxdZhJxM4NRWUwHrQLVItD/HrL+YOH3K9ewxYVhwevcz75hHuv17xbPeNdPuTt8AE2NDwIx1TcpTR3UOe5qRdES1JN2MhMNhzKklM94555weHqhvLGYvseY9PBLtEg3mBvLIWDN14/42H8kMfmLi8Wd6HKzlZWagwd1xK2We65l0BOFJaObVt98D8Ttl9AL2RNX0hEOrnlW8wCc2cNvff4bouTY0SUq+UNzy4uWK5Si0LVQLPtKMqOEDti8JyfP6dbN3ztl++ApEbTfd9jNTdSEQeqdG2qzEINZ2eXrA+22GKGKwtsfYhb3EKqQ948LdjGS/4X/6d/zb0D5TvvvUYw1/zP/g//ir/7G9/gb/3FdzGuoqgOkNgQV0rwDfQtqEf7VPbrRBJvpIOmkdy4Jjc4kUhRlBRFz7QqoCgR2nFzvcT35PhT477XAxgheJiWFdam1nCz6YSUJFa22y4N+ZSIDrX9f55d93lLdezcpqQCghgVV4zjXnOImjxDawxlkfokb/qe7XbLZt0wnR9ydPvero9D8PjeE/x07LkwXH/ivnO4r/mYCh2h2M3yigq9D6gRjAaMQHVwSrntCCixb2n7jsP7bzA9PM4SxmREoipd3+Oj5gSfjkNRd6OB4jhQM0UziZ9OJRUyUkyqyTgbk7x0iSmZuJezTvkOyEUWObli8+DHgX7AZOVKem0x87pd26Z78AtxdDUn9tKzEzUSI3vY7uiHz2C76dhutmw2LdP5IYe376bDKUv2vE+Ug7WWSI/GJCk10qKkoZAx1qg6pO8ITDGlgakQ50JvFW0U6RSLpZqeUlQdYQvxpqMrPIfvvslrp5a3zFO+1n/IwaNz/Dpw9+iKOLkBE9hgeYKDIjlszvRMdc2xveGWueBwu8I8VuyVYJoMjTXYaIitwBJMIUyrnvuHDzmRJ5xVc6IzSN+gYQP0GducgM3Jz6EqLXHmKaLtfC64IP5M2H6Bp2tyhk4zLTkUA+dkmjX0XSR0bRrwaIQ2pFC19316+BSmsxlt27JabVhenbO+uuE/+cvfYb6o0kbtmtxZSjBZaO2cY5gfHzRys25oQslBFanrSarVdg4xEGLPu/cPeX52hQ89d09m/MYvv83l+Tl/6Ze/wXw+IcaUpW9XDSG0GFcmo5eF/mPvA2uycbVpBIwYQm6NV7qSwllc01GUJVrUvLhqcc5giTiThlKKhtTFLJIOKhk7NCCkto/WuVT2GHourq64uVkhMeJza8UiKwMGT+qVLk30ws7YpX6qqRlMet3G2qTDRCkKR1GWNG1L0zasbtbU9YLjO6+n+5V/vt1uccblXgwue47p6RMkb96IGIcxlrBdYusjfFSqQnYNt/OMspjv0+zggMvnD1mfP2V1fcGtr3w163/TRAMfe3ofafqOqCmK0DjMrFOGMENDxJapPec+1z4cikP14I7GlFFapiH3oZIcywwnq4aRu9VAJn3Tm0p6FgxAjGM9vmavO/wi5Asx0VhDs6bk1aYWjwnb5DglzXQaw1QUJduupWk7VqvNiK1J4tZES2y3ODtga/IlDlRGg8YO77N9MlPC+gZ7+5DeCvVUsMfJKEUi0ia7YCmZVwdcPnmf9YMLVu8tufcrb3HLtLwpTzh8fkX49wG/jPj7LUfvPsUfF5xpzYQZxs7ACIUJTPoVx+Wao36JPYvoI4EXCtuI2GRTOpSuh5smJ7PnwunXr7hTv+DD2TuEWY1ak0qFM2YqkTTtWH4CtvFlbIdeMV+A7RfSC0jqsaouhc7WmhRCZv3fVgN9n9o0pmogwVqXS+MMk8mUyaTkydPHPH/2lM3lkt/6K7/E6dEMMpd7dXnN7bsNMztFx1lEjhhjqoiJHmsML24CR+UWI8dQpLEkodui6rCifOvtW/zgR+/zo4+f8K9//095/e6c124d4Kxh22zR4PHNima9pConqFrUhzE5QK6Ld1ksj4BK6pBvbIkpUrZdTO5VUDmuA/joEZW9BzF1xLImUQRFkdpCikBhwcfUh6LZbnBFSdf2pDaTiW6JMfu4UUlFsq927boh5ZrxkPoY1FicS/PtRARnLIWzVHVKUrV9x/X1DUU54dbrb6WKupi43q5r6JqWWCiXV9eUZUVdlpRlmfndFPWIMVnGZRD1VNKgNrXm64LSkyZIx75jUTnqwjKbL/DbFdfNEmLP9fkzure/SllN8BrovWfbe/qYSn7Vx5zjDOn1KaOzkGaIjXcie7Bx5H9T3Y6MNMvAj+6yojtDPQ4x3Euijdm1of+wenynnF8uqcoiSSX7iHEu9zZ51dh6yBJGIRWxpDFMA7Z+lK0VzlLXqRy769qM7Yxbr7+NcQVRY8a2TR5cEfewrSiLKudhtqhuEq62xpiABE9lW6grQh3pJmn4qJdIbHsW3lJHy2w6w0+E6ydXoMpm+ZhZV3PMOfpBZP39yOqmp18qUnoW9XMO7RFTPUalAqMUdEzZcCgrqnULL4DHSngaaftImEKsla6ELcJFFOxGufcQJvcaTiYXTMqWZjoZxOQ7TPcdnqHL1eh3hoztNVWZqMe2D0mZ8jnYfgG9kP+XOxQhiQvzeUquNTaXh/bgoaoqup48mK2kLKccHR2wbW44e/Gc8+cv+Nu//l1eu3NICBEfA2cXF0Qfub66JoRIVVW4InmhIaYOVnXpKArH02t4756j0A5sjdChocdvelx9xPG85u033uB/+4//gB8/eM7X7s9Tl6Sigjy9uF1fEPstPZHgu5RwCYmz1AhF4RgmIKPQtQGKVBUXY8zPs4IPFIVBJc0UE9H8lkn1rOXzIRVciNmVEG4w1Kst9c0Nk8mMttngDMTYUdAyLw19HkmVjMGrjUOH1zF40TE3Mx8mPSjgjEGqknqauPjY9bRNh3M1d954F1dWiduLStd3bDcpE9/2njY0mHWHNYbFfMJsWqekg00eLpm2MiJMXcROLKt14mRjDEm+FwPzMhXlIJb54Qnn0yNM19Gsr7g8e8bp/TfxUelDihAGqdjYGzU3s0+vM+TkpmQ6JOeho0+83ZB9HiZfK3lwZy59Hdv7vXwnPyVd2MtxR4YCFDGSxwylaRJKjuR+AfTCyEGyk431YZh7lugkZyxFJdSTCZiMbdvhbM2d19/FFXWSVsVI1/d72AbasMWs24TtbMZsNkFjj1hwhjGqMAYmleIOHauyxxeJBtpKhys9c+uSgYs18/AW580NZnJGu7nm4vyG9pbF1kqcRLRXmCpaQsgeZqEdUgQoA4W2WIkE49DKolMPh8DG41qoCsUUyqyAOqZoJbiILhRfOzYyo48F4jOOOZH+Ms4vIz06vQba1tP3SdYVsbgiOZw/bX2+pyskT1f78fQ3+XNIqoWPuSRUg6cqHCvT4FzJfFFzcnKMELm56Xn+9Bl/81e+xVffvJP4oeC5ul5yc32DlcgnP/oeRVlR1nPuf+UdfIx4PNNpmhhgRFBxcPwWZXdJv7nAb69YXV+waR2Hb/wyk3LC/dMDfuXdWzx5ccknTy94/+NP+KWvfYXQrug2l0S/SaLxvk2UQ9aihhBTk/XKATtpU+MDZUjGQI1JNeKqeTZY7mhnGDPZOxJBx3so+WGMmnlUsdxcXNI3LeIcXdcyn09Z9R3d6pqiKqhTunmvGuoVr/ziJWPo88EjxuCcoTSpEg9j8F3Pprmhaz13X3+Xsp4SNXWp8qGn3Tbp+m0qC01jXhIltdo0NG0K+11R5jJgYRjbE/ueyipN26YR7DnhpEMYR8otFPWEoztv0N5cEULL1dPHHJy+lqOQQDqlsnEUQ589DTMY39Bjs0FKXHuum9d0kCZ5lafQanRoU5P3mOmDXQ57QHigKHbUG3t7NR1eVhgN3miiM79fVuUvAFjJ9yH9zSEBNmJrDeVkkrLsxmZsV3Rt4O4bb1NMJgyjtXzwtNttujJjMXbAlh22XU/U5GQZycMftYTSotJjp9BIR1kIwSockvhwMWgLMrcUNyccnX6Fpr4mYvjo6YpPTm7xztc3FL2nuPZ0J0p7b8KL4g6X7RxFqIqOvvJYvyVIwZJDptMVB2+e48qIvRuxPVgihXgmVjnoYH6lLFXZfhueHN7jY32b7XIK16B+oKQkK3eGu7of0SSKyUoYHZUBW/MzYPsF9IIieTaU6iCXkJzNHKQSJiU/fI8tC6x1HBwesThYYG3qCvX86VP+0tff5Ze++kaSJ6GsNhuur29wokwrh6jSbTqiv+HBBz/ElgUH00nmFhOZb0ToZUofztmutogTfJe449RHOFAVJX/p22/xb/74Y55vt/x3f/A+33rzDpUzWCt4tWjoqSpD07SghhjT2KDWR+pcHRX63GuCEo2Rvu1T9ra0qJEk9u98GtWZNSaD55ic5JQ1T3K7xOkmFZWCc1hnU/bY+9yzGA5PT6gm05Rw8iFV+8WUmX+lK78+w9BJKmTdbfLADic1dV2y7nvaZst6fc3VxTWHp69RzQ5SsUpOrjTbbeJErUOcQ5D0evc8/5RsMRib+EbNqg7IUwsC+L7HqBKdo6pKvB+oCIsVUDXMb73O5fOnhKtnrC7PWJ6/YHZ8F7AgDh96ggZcYdl0EDSJ11PHuriTseX5aUYUB4gKmlUFZV3nstjUQN57P/bYTztif3vIHruwox1SIVMyfkIegw452klz2eJQdvuq14BtVmEkqiVl3p1zHEwq6qpi03vadst6vebq4pLDk3tU80U+ZPaxJWFryxz0plLbXbP0xA1LjlzSVAYHtaGXHnXgpcdIJJaO6k6FrzxiDSZY7BZ0Y5jxGtXqCZ1teXAZ+OOLGn/8Nre+/ZBus+ZpL1zIEct4j+f9nKDCzDVE21D0Hd5WXMshENhMLMdv31DcXyd6xYBGT1krNgpyCX0XeXZ8wJ92X+Nx/xrhhYElEPsd0DIepePndtiSsc1TRj6FrX4Otp9fkTZwVCKYGPIpnQiNqEppHNamTkXRd5SzKa+99haHJ7dYrZ/z/OyC93/0AbPo+fXvvJOz28q2bbi8uMZZx7SEwtkcesVRJYGPSUaWE2rkUG1zc8k83nB52VGVyvzggK7dpOGKRUFhHW/dn/PXvnOf/+Z3G/74hw95/8Ez3jydURtYR896fc3EztCb5ynRY2wac24sxqSsdwgBTEmaKgrrzZb5toJphQalaxo22232ZxIAMgBCfgjJFI0OBijX3LsiGWS7o2i6tgOESVWl8FcUY+Y5Wnu1rK7kdnyaQ9+xXaEKk7LkztGCXmHjPdfX15w9f8F0cYvp4jh3BUuUyXa7yZswZ+1JxsxZg7hUCmnNcNjAYHHNKGJOB0rfh2Qcuw6JPUEmFM6mjWnThAofI8V0wfEb77FdXULX8PzhB7xeH9L41H5abImokqb92FRxmGV/ArthixkrJ2kDiJC4zkEmlCdihJjLmwcc2dOS5I23H3PK/ifytxmJY0/hkdLJ/+10hK8SXAu6m4uWxrEP2BbcPVrQKWzCiqvrK86eP2O6uM304GiksUIMe9haxBSjA+2MAZfURcOYGjOEc+PgSwsFRBvoTcRMBcoeW/SEqqaoLFJYjFhsL/htpLALjrfv8eTJBVdxzu8/8Gzrd6n9CRQ9SwzbWNCHkpVJstWF2WLNBiOeYGuu1LDRggtzwLk0HBUrKulxxlPZyK2TAyaFZX19w6OrCX+0vs8P9auszufIM9BrBXrG6hdlxGjQv+ywlVQgYsuX6bqB1vkcbL84kQaAJl4s6zjTFIjkQTjn8CGgvaeuZrz25l9A2HB59YA//g/fY3N2zt/8ta9DDle2fcuL52epcsMGnLXEEFP3r9oRNGKLCiRVwMXsJSXQlfV6i5lEfBSatSWYhul8TlkoZQ6ZBOHv/ubX+IM/fcDDs45//M//Hf/V3/mLbK/PKCVgKkHaLZPC0pqQFAnOUmZ5U9TknQSZIKag7z1+5Tk9PUgJvhDpug7fecTuTsNhY0o+JHbxyU5GHxSiTRFB1PzAKqnZimTZVlaMJA/SwCvn/vIOyvIqBu5SE99njaXpOs7PXvDs8VMm0yMWJ7fG1n4xRjbbdeZ4LWILjN2VPFtr90pwMyWV78JL7S1J6oPYt+lQHRJbfUOQmst1h4phXmc+1QiLW/eYHN/j5tknXJ89B/N9Du9/jU2veJIyJIXCycgmaFISbzD6yUMRCkmNejRGVKCQAiNpACokry557TJSCS9xui8lWT7zj3zA5DKKQaqVja1zn8/7/XmXDG6ADod83MPWpA5tXc/F2QueP37KZHqcsU3YRR2w7V/GNu8NW+QkaL6e1Ekvl1qrADY5ToUhukg0LUwNRdlTsqW3HVRTbmxAJjXzokB6xahh4e9xubnP6nnL5aOeF33H8b3v0oQANqAmUhmlNC3WLpnJNY5rGu3opabRmsAhaiwlgQKPU4+NnmlhObWH1M5x4655oBt+2B1wcXaIfiLwTJBNgGFyxGco3U9hpcpQ9f4ytoJzguqfs8tY9tVSlZWGNNNeBJv1pxoVayxd3+L7LjVMMYar6yW/8zt/wNmDx/ydv/pLFNbQdsnoPn36lG67ZTabMMm8R9Q0G81UBaVx6aREkreiu/BaVVmuPLFWjIWuFZabACzpP/k+p1/5KuXBXawx3D1d8Pf+ytv87//vf8QffP9j5gX8zW8cUMQV6rfULikViiI1u/ZBR65PEWxZsdFpHuaXvISirFNmUpS26/EhjGOIxoo22ZmUoTNbxgiAgMFVFcamSjgRQa2hdJZRzyupA5Q1Nhu6V+vpDpuSIZIht9zUdEI3fcejp495/MkDymrB4emdkctUVZqmoW26ZChdLq/MjpvNU0RMli3tKhjzMyV5+ix5vlqMiG+IUqYUmEYk9vSd0rXDgE7LvLKIRlxZcfqVr3L1/AlWAturF2yDozx5AykKYva0rMZMS8RcHTS4LumSHYqNqXLOWpcKM6piN8ssV2BpDOPBOWauP7MhP51gS8sIVFWZvPWMdT4D8tSJV4srvIztoE+OMSRsEZq+5/HTxzz+5CFlNefw9B5DJkI1VSN+Btt8fekwTQfq0H9jdBzI+Qo1YC2xUHABXEusHaVpmMclhBVeC2IHYueUZc3swNFGy02Ycvrae1z96DFcRpYfXrGUR5S330DuzPAnDncsHBVXHJsbqnhDGa8JCK3OWTNnLTO8L3Erj/XgCoMpDKVWvNgcYPuSi/WSp1cXrD7YJGnZI+CZQrcldb8Zkqcy3sfPYhsztmmgg4zDSgdq8adj+8VF/TkTL+oJmn02IwSvVJg0jdUHQucxpuDi/BG//S/+Wz750cf83d/4ZSZ1QdelRNXzFy8Ibc9sUjKb5gkEUainE2yROUFTAmmjDkmHoV1aCIFNC9vosLJCpaaLlmXr0Ztn1AWUdY0pDwHlN3/1PX77d/6MTxR+/88e01x+wl/9xhG355ayMLTREjGEnDU3Jg/rcwWN1vTeUs8XFJOK6cRRTSapWil4+j5kbesQaeoYlgykeyorHiRHae8aVzKfTXAuNcfYgZPKkof8u83evVj7yqPQwYAO3huklnwhBkwUPnn6mI8++gBjK07vvZ6SbSF5TG3XsN1sEkdbFqnDlCbjZm3uXyG5u5gIBjN2/NqfQ5bCUkM0SmxX2OIETb1Dk/Emsu16ViRZ06zaGa354S1uvf4uF48+TNrhpx9jVysmp68xPbkDJlcVZS9Ph6q0/PPOgPU9ooGqLKnKImFTprJfRXYGd1AtjK88t90cLiKHoGnaghltcyokSgZ9tyGHEzn7o5+zMf+/wza+9PEwL80ofPL0KR99+BHG1pze/UqiUkIgaqRtP42tS89k1IytzQ1xdtgO/OaQbIRM6RSGWCrEFW56RC0d07DCEbEIbd9SrUtO6jl3sKxkSrT36Ran3Jq/w8WffkDzQUvz+H3s4orJd99i+iv3IDrau1MiMGVD5Ia1TFmbihs9ol/XmKct+gwKX1BVJWoEqSv0sKI3lu2lo3tk4KGBc5ALRbdb0CuUJkWZmRYcgsLPYpu17AO2ssN3mBn909YXqxf2asiT9i95MJ7ECdo8kyr0DTEq/+Z3/inf/6M/4e/9xnc5Opji+9TN6NnFC66ulhSFYTGvgaGHbJka/jqXymxtau6tmhuNx0gUzR2oLL5vOe8mHFRLlq2nDSlT6H3kxcUNB/eW2OoABI4O5vxX//Cv8L/8P/5THp6f86/PGp5eXPNf/o33OJpXmGhRXY03qaxSi7ZGS262aWZUfXgMwePKkrKqUxFA2xKDcnteg6aGIj5kAl0Z5UhEzdVV6T6qESjq1GZPTB7yOXgk6Zo1h9k2A6maDfCrXDnJk/6ZvJgYA10fwEQePnpEDJZ7b70zTs5VVdquY3Vzk567Ik2+UNJEAZc9XMlekRHSWPkc0g+NU3ZqjDziJArEHieB1jis7YnqcWJTD9R+je8ntNFSZS7YFQV33/0m69WK60cfpQGpN89RAvPjY9RYTJ4PNjSYNy5pplFFQouJPc4ZqjJ1dotRqZzFiKENSfuLgivmYF2OgGLuURsYGtnvvN/s6o8VS6mtoDEuJw13m+qlZiqveg3KENHUhUtS0rfzEXqfsI2We2+9nbFNh1LXtaxWqz1si/Qshzi2ohwcCCMmt2c1Lz3vOkQEkv8dgM7j+simmlHZG0JsqK1QFgXSraAzaCgpbJkPxJK797/J2txw/eIjwuWGeNWihWH+lVvoSYE/LFmaObXMCWzZ2ANW9phuPUGet5gnPe7cUvkCJBKB6tAia6GPkf7Cw3NwV3PYWDS2aNnmCjuHarGLjkay9tPY5rl3Y35CxkN9NNg/ZX1Ba8eBI9r1h9SRz003u7COCLTdhocPPuQP/vs/5Lf+0ne4e+uQ0KcT9mJ5wfOnT6lKx+GixlhDs+2xrqKcTokhtUEU43BFlTyrGJCQH2wZvOKAquOqKTitCqZloO0SB1pVBY+vPLdXDSeLLslXrPLLX3+d//xvfZf/9f/5AVoteLqCJliiTdOM8T7xM9YwmU3xES6WJdFWHJ4cU04q2rXPHacMvt+y3WwRcUnOJh5LTK0C80GRBj4mQ+OBGJLvoQpaTDAmTQtNxjYimrTB5Gy/yUkgdK9b/ytcyTkZRqfnj2PgetviL17QbDruv/lVbFGk5IpG+tCxvFniQ8CVSUuNQPSJYilcLpOMaYJ0mr6x7wWMfmJ+JiV79hGrSqktW1MhxmFjHLu7hdCjzRV+VlGWLv0GgXIy4f673+Ti4gzbrlPjeZcSd4GYVDIxqwTQHFlYYreliB3OGSbTClukUSvRp/xC0DQNOfiAEaUoNPVwsAbVNHR1mI+WoNl1mhvuaXofcG7QbO80svkmJA/qF2F1x1zCcKCmdobX2wZ/cfYytiG5qH3oX8LWFlmp4GMuE07ViUTN2Jo8jDEZm6GIJJVPpz2rjUE3EXulFBc91ydHdE6oZc1UFMUj0eIag5kvwC5oY4UGoZjMuP/1b3Hxp+fYG8UgFLXBIoSt4q+Us9kR2/g6nglLd0jfHiEvGoqzDrc1TKiw0aZp4xpxpKKYoKnXirFKUaXXGZ1DtSTqFJU+Y5ujMh0wTfdqh+1OwTEEPINUb7DVP239DA1vDJAMRFRh12knomqzDEfoui1/8v/+Z/zGd7/BW6/fzr06IzfNhocPH2PEcLCYUOT5Z0VhqCYzTF0hFNjCUZQ1w+wmpw4vPVGzcYqp/aBzjtYrm+kBRXhELbPEE5KE7h+dtRzearB16g9aFcJv/tpX+Ze//xZPriOFUaZ1RYyWvrmha7f4vkWqCcVkwdlVIGC4dfuIg+NDxBZEX2KtpdksmdjkNcSyZD2/nQyORPAtNnrEe0zsqGPAShopo3lTNmo4n05S7Xr2IFK2d3+TpLAtDuWz8gUI/jnWQIeIpgnMxiSKpek9V+c33H/jXYp6MiZgQgzc3CzxXY91Rdbb5qRU1n66ImWyLUVqWp6VAuREqM+lvUMfXtXUGXPw+lxocK6i7wXBIiRJFyL4ZoVv58RikdQW+SJmh0fcef1Nrh9/kJu2kEI/Iq1PWnDv0zDKycRi1ENsEYF6OqGsy2SkfZ90+lHpOp+cjJhm102KmIqU1BDF5Eo3IcbUGzqqEEfHJCUKE9HgKZyO1JhG3ek592moV7zSDiUlc81uHPsO23d22PKTsC1yEyAQk5r5u+wgWJfUJM7az2IbB/mUpkigBVkJXIN73mDkkFUxpSsd3RRUAorFtWtoSmyxoAsF6gWMYXp6wp333uJ6/QEmglbJgzdbpT2PbNfCsjilb0vqWGGvIvZ5B9dCHaaUWmKDEMjz9ILStn2uZA2Ig8kkYHuSjlsDIfao9sToM7aGiEXJ+mRlD9vtDttsa4deJgmHPyenKwwmfMhWpg5ZI2meQw1jHT4ov/7tt7lz77Wxa9Wmafnk408gKicnMyZ1BZqqt8rJBOdqTG76a11BWdX0uXlE9F2eM5R0n5LLJo11KIFlP+WoLig3PX3XoGqonOHsbMXT8zWvvz4n+JbLyxXXqxveff0+Hz/+PrZKw+owhq5p2W5WbLcNrj5lo1P60DGpeg6mAn5N15d0bUOcT2hWS9TE1MjFOExRpVDKGsxkSgi5jV6mDTR6Ytcj0SM+gWldgSF5C2JyTw0dZsEBMaZ2lyZ1hbLGvHo5p+r4UIgkvbUPAWssd954l3o6yYmVlGBbrVa0TYdxjqKuc/vJ9Gi40lFYg80nvjVmnL4Rx+mi6YEckowx9weQmLt9afK06yLSkQZI9iEpDqxJ+G+vz5lNU2/dECJd09G1DfVkwgVC2zRUVRr9HUmFDl3f5xlfgcIYrO/oYoCiQJ2ji4qLIfcTkMxZ+z3ZX6LPUmFBSiC73Ht87KcqqaF3zLxpzGXcMWe3BzpBBvoh00pDuPqqV96d+bVlo6j+ZWw1JcFjCKxWN7RNi3HFT8DWpPuW+yNbY8cRPTGrGUZsbXqmErYebRWzNugN6ItA7SKdMYTK0U4DWhUEt+ACob+OHE1qtDWEJtBtW/p+S3085WJuaDcNVSEYNcSt4JtAR6A1QDAUCvayp3sRkaZEtaBbg+sCQTxSCeqVLqRy/dRSRrFOME4RK1gdHAXGA0kk5j1Ajpp2LbTTwbTzdNMJRK4U/nS29eX1BZxu/sVD/1WNIKkzVvqj6eR21tH7wKwuIHeR6rueTx48wHc9RwdTFrMJ1hV4HyldhasmuKKirKYUZZn6DThHERxd2xNIesMYY6L9gsdkzypGaEOJKS1x2YA4QjRYZxAiP/zhI3yz4c37B3TNmn/z+3/K7/54iRjHP/qrt7l7UqLtFt+29J1n2wXCdM7VeUtoGw6OwG9WXN88w9sJ0dYQZhiBZtsQfUCL1GjdZN7VRxKHCxhnETG4skDqCZAaQ0tUSlWsK7LBteNYFDOE3cAgT5HM4g9a4Fe1hgTlEImawRCgGFfmUIk0GXezZrvZpIkHVZU8IUmJJmdMMrjGJDmSNePvNUYwMSXgQoyjAUr/15wo1b1rBaceNWmOVVIxaNb4Cr7dcvn8GZPDU0xR0bRbzh99Qvv8Q6zf4CfHzF//OuTeIDFXEcbQU4kifRo3FFUwtqTrI77vsESsRKqySBhCmpAbFWeG0ugxfhwT24z3MCUKUy+DVAqqud8Dakd5FTLIq8jJuV9MIm3InKcDPL/+fK+NK/awVTbbDdvNFmvdDluEqAEnKanorE0yQmvHg9PkZjk7bIfnMztm2qGxg/U01a2o4myPWksoFZmB1BGpDX5SsQyBrr+isoLtStqm4fzZJ7QXH2DrLX56zPydb4JYwlqJrRL7SOw8lSriW/qrlrARLEXCdtlhQ8RWkcoU+F6hIPWCRnFFxASLONkllHWIKmVMkBsjWCcUanfYRoA9bMn2cEjAfQGsX+jpSjauqcN1QG2BFYtIqs0Wm41u8BAlt4BTPnr4kOuraxbzCYvFhKKYoCoUpUXc/4e3/3q2LMvOe7HfdMtse3y6qmqPbjYANg0gULi6IhWhkBShB/FBD3rTm/4B/U96kSIUIV1KFKm4NCAv0TAEmmh0tS2b5viz7XLT6WHOtU9WA6imWtlaERVVJyszzz5rrDXmGN/4xvcZqmpCWU1YHJ/y3rf+cSrpncd7y+r2M7r9nn63pR967GBx0WPKVFl6KXFuQE2WyLhNL1ZZIzz0IYnbfPizPUvzlPdPF/zv/mff4On8I4QzvH9WovF0+zVD39G0Az01dXlKeHjN0N7j5ku2uz1bm7C4eaEwrmHoVjTbFcF7VDlDjNUg8aA0pHL1L0QcTTIAUqIlIkJ+5/L/cN6lF1Lqw/0enRhGPd93vQqczlJxwOkfW+DHQWAMga5r2GzS4Mzkl3Ic6plc0epMfTNasZhNmNUlzj+yBvbdQN/bVCn4XAESiT7kh1Ye6FkqJOzc2XTvtBKZuSGJ3rPbrOhdYHb2nGpxzLEsuY+RMNlRLp6hJvMszOOw3hGcI3rLtEoPeus8TmiKmLB8b3tU3o4QyuCDwtn052OMicYHh4p0HMyNQ6XHHY9w+G2CVOWnTmEcmmU1iLfiOHI73/V1oH/lr0Y4h7djGwNd37DdbIhETFmh9RjbiBEaKdMGm1EJC19Mp8wnFS4PVUOO7XCIbcLPJZHgLVIMCF8SdkUaBgeHnpRYeuRMoOcCMQFhFbEPbO83dDIwmz6jWpxy9PWKhyES6i1l/Qw1XeAD9HuL3XnC1hF3lqmWaBtoVx7nFIWOYB2+ybFVEhEN3iscgd5boogUhUyO6zmGfyO2h1lEOmXH2lUpTVQxw0UcYMFHZo44dHR/1/VfwV5ISTcKCcE9TudItK60b58kHmMEax2vr2+5vb5jNp1wcjIFBEoZgpAoU2CKirKsqacznn7lt5kev5dXfdPDe/LsWwRnGdoVQ7uh2z3Q7bd0+w3tbku/2zNYA6ZnqgcGIbE2UuiaqVFoM2Owlr/46TXf/WBgNin4H337KTerPZ21GLfF9h1t17Nre5yvaNZvCMMD2+2OwdTU8wJd1ngf2G833O0vYb8mSoiiJAaXkpGRnMwU+9bT28zuyNxPHxyQuL8hJshAKd6iFyX8NuaWJMrxtE1k/SRerr5sEPprXQcCVAxvTaVzW5Xbq2HoWK1WxBAp6ipZlcts2UTIrabICVdTVQXnyynzukhtZn4IbZ6cd9bR9JbehoP4iw8BQmrZEi8ZTJT0GdMdcd0YU8WFgDDs2T/cUC9Okdowf/FbFF1H8AMRRx8UznmCswmrDxYRJfthoLMO5zqU9EkSUKX7HoJKPmuDpOmz1GcUB6wuvZgJfx+XCA4QxFgEi3CohmOmGsmM8Y33N89iHt+t38Ag7ZGBGB8Pd5HhkHyYDv0XYyvzYaoz1KNU0hbWKi0NVVXJxdGMeVXm2U763Cm2nm5wNP1A7zx9L7BWppX5OOC9xG3S5pmZCPqo8F1EDCB7QRw0eppudBha9rtb6ukJqiyYf/M7FE9aQjMQW0/faNw2EO4d7mZAbAZEAftuoGt6nHWoaZdiKyJ4QehLdntLpKNRHiYRUcZURyYhZdASGUtiGDnJeXNUpjXnFKc8CB5jm4uhA3QUHyGnX9XB/EqebszVl/DiMHGNjFPK9I/Wmq5Ng6672xtev3pNWRQcHU9RpkSKxL1VqqAoKoqqZjKZcf7iGywvvpZ0bSHx6YQANFEV6GLCZPkCiAkf9Rbb72g2N9j9mtBe0Ww/4v52gwsBIQqEgcVkQtt2bDYDf/6Ta6YFPH/+lNlihtrdMtxdpiq3axl8wnRQiV+nJ0sWJ2cczSq2+yFVsl3D7foaP3SUtSHqiJzOMVrz9Kjg/OSEy9s116sdpiiQOp+WNgUoCXxkKZw4whEuD9FSmyaiRwqTkmBedYnZveGd27q89UwkqHGcQiejwmGwrNYrgvOUVY2uqqTTQHoG0maTPFS4hTGcLlLCHQ0YRR4UGamoTWRRFYRZzLhYou701tP2nk3TY63Dusg0KDaNwUWXrN/xYFKCV1HjnMfuH3DDQD07otAaVSiGXtB7DoaLzluCt4gYaF3mTEiJkoFCOLQuDnSqGAW9E3TW43x6TrWShJiWd6SSyGqK1pphvyKGIR0KuQGMIVW1B8oQ8a3kNy6JvkWYH6fj8stfzl87uJkSOLbICUd3Wei9z7F1KbZllXjVWTtbK3JsJVprClNwNp8xz0PHA0ZNeg5qo1hUhhDLHFuDDQW9LWh7xWYvsM5gvWZqFZu+wJG6ENNH8MnhV6mIGxy2X+MeBurJkkIqVKkZBkcXBa7x+Mbj1o6wGhBdR+uGTOPrUPQUVGhlcmxTUu+3lq7zuCKgvERHCCKCE0gUspqhq5Jhvyb6vJfwhdg+4vfjO5Mu+Rjb8X+MrJYvYXl+OWUsQuL7xcd2VIw0I4nPOrJaq8Ou+s2b1yilODubgQhpoyUK0AZdVJT1jKIsOXn6Nc4++G2kelTj+eUtjkdRDYhCoYxEmYpqdpZaHNdw++r7tNsfESzM3v8qT/7R/5p2s2G/umJ1c8Xl69fc36/45E/+iug97x95zouWoevpWof3oOsaGyOtD1TLEy6O53z9/Qs+f/Waq8srmvU1zW5PISXOQ6cKqqJkWgqOF3Oq028Q7n6M7e8oyyqLWacgiJyEgk9wjMzOAgKBdUPGyVJloIVDRZ25ulm9KD887/IaG9sAY0eUdGazBOJ6t8YOFlOUyKLImFyuPgXo3HomCU/NclZzMqsyjehvxnKsrJUQaJGqhyJKpoUmTgQXywk+RHoXWfXw0Am6/R5isvauq+StFUMkdgMhRGy/427zgCkKqnpOjAIbFINLm4/eWQg+TdtHedPgmU1KyukMXU6wzY7oYXAFTWuw1oCcgJkigqKuFEKBNIpJXVHJjttdC9EjVRK4PuzdZ3xXkJxGxqQ3vpQxPLb8Y1X0m9hIOyRZxiWOvDmWF4B2u02ObYUsSgQRJXV2bEmrwlqpHFvD0azmZF6i5NgNxUM8D1+LZO6pEBilKKJmWhTESc3FssCHit4ZVgIeLhu6LtkfRQR1nWMrI7EX+D4ki6Z+hSkMZT0lDgK309h9SIm3deAcUgW0SmqEhIHZRFNO6xzbPdE7BuvY7wJOBqiz22/rqGuBGBRyqJgYTSUbbncW8KmKFRyAGpEHqYcOLr7V4cQxto9dy6+K7X/FIA0Y6xyRKphkX5On6iI7qOaGUIjIydGUwmikMtiQtzekTAyFquLs2de5+Or3Mif38cOFLLf3RUQkHgJ7mM3mXk3pCnH2LexHHxEkzM6/xsn734OMsbpuTbu6Yr++4tOffch/+f73mU4GGB5wtktKVkLR9o51c48ThjoPiurlU55HBcOGh76k0pF+cAzCoGdHaCU5mhRM5udIXVJWU0JwB9pM8pHKQ6pccXgL1tokzh49Wuns2uDQSqdhRV4okIx6A6TV43d4pc8jGNW8x/bXZz5i31u0Npi6SglFjipzPEIKmUp0PK25WE4p1N/cwznQFg/P4wEEzb9XHFZK0YLaCIwOTAvF0GlECEyqgt/+2glawmAD+25g21g22z1t09HsW+5urhL97OgZzmcRdJd0FRJdyGGdQ6t0eBRlxWw2Z68063VD15e4UICYIeQcMSkolhE1U2ALNHPmlaaIK+7iPdY3KJW9QA7J9XFMSIyH9dgxSYU4OmhkaOntyvfdRjdn3cfqS0iBz7Hue4s2iYWSBI9kgpmEONDBtJYYrTma1jxZTijU2GKPMQyH+P4dn+Ct2CrQiro0mBiZKskw5NgWBb99fIIuYIiBvRrYip6N3dOKlmbTcH91jR9AFM+xDbh9IHQOgkUpjw8Dzjl01nEpSpNkUpWkX2/p+lG0KB0sIiapVuU0WIXWmlnlKOPAXbRY78hIVn5+R4go/2Qx+8q9HVtiJhxwyE3iSxaafuXb/EgbS8MXESLhINY93vhUkVkbuDg7woa0U+UCCKkSlUdriqJkfvyUiw9+B1NUX3jo3h4yJJdNRUq44VDtjl8fknIM6OiJqmToe6Kq0lseAiiNnpwwK+fMn3+H06//PvX8lPsf/kt8k9T1pdEI6fj4psELzZOzJVoreuuoqgnq/Bn73QbbD1STjoeHDYNeUFUltZbYwRFNjfMC3JBWR0mLHkqPiwUeRGYzmKylICKFKEAoFDF50In08xAEyEgiJwqCJ6tUvcMrvg0pxkO1Hb1Ph4SSmLLKg7zMWsmDvfHU11pxNJtwcTSl0PJvJJDDUsfhxB+xxceX9fAa5wM1CiiU4GQi2G49kF7MRaUpdfJQO19UDD7SDse01rHZtXz86SXbfYdTEheTBOfhufGWfmgIIWYjy1Q4TEqNkjWD0wyhJIg5gSlhEtHnkfK5RE4lsq8o+wLjKsQuoNWc3m0QMj2HcXwJx4MMDm7CIbemPoYDcyGKNDSUWePhXV+59MkwZDxoJkcf3optmSAT8Th2E1IdOssU25onR9PDMFE8PjCHsdLf9uljHD/FGFtx+LqQgmMj2K4ckXSgLjpNGSRBwrmqGGaBtjqmDY5N0/Dx52/Y9h1u0Lh2wHdJXEuIAL5nGHZvxTbBdJNSoITBupohDEnYM0SCs+gOSqmRA8gSSjNQqIgIFq0Cvcs+eiTYKWRu+fiMKhVzbNMzltgb48+YFmuU/PLYfmnSPThiMu4TK4ieKOSB6hQiCBII3w+OaVUz7Nr0Q8pIbdL2kikrqmrKyZOvYMo6/f0hfLENHacNbwXwMFUkwRkx2FT5hS34SLe+xtoBXVboev7ochEcSJ3gCwGmqPnmP/yn/NmP/jU7ZxC6xBQBYSROOMrJjLqeJEPDCNE6ynpBNT1m00vWu4D1hvuuJ5otXikm1RERgQqeodmjtTys9aZKXCGizpWPx8eYNIejxjmXwhTCoaMIMaLl4wn69gruu7wi+XvKPCzKCTXa9JnKenKIu8jVr8kt54jlTquCs8WEIhPn344ZPPYqb1OYDowcHn/PYYWU9JFcTP5VCrDBIzMz/O2BVKkEuhIs65KLecms1Hz46TXXbbpXUoSkeSwFvt0Rhw1lNcPo8oBvKiWZ6oJ+kFg7Q6pj3MRglw3V+x71nkLMDO7Oox3IbSD2JT6UxKgOla2Uj5j4QXOaUUYyEIVEkV5iKbKErhz/9LtPuoeqbJyo56QRwy/FdqzQM0tjtNjSWjGrSs4WjwmXQ5zSd3iMbU69I5b5VjUs3voz41zIhUiwAjWAHTyy8IhtIKr8jChBmemHS6NTbN8zfPjxDderCG1E2kiUniAdvt0Qh/sc2wpBJIQBpQTTiaa3CmsTbOJcwMaOSkcUJQKFGxr0rEJGiGHIyxFpaUPkSn10eH7stmXyTozp51L6Ua40ZIrjrwrrr6SMPZ5cucoJEBlPAvJpCkhJN/QcL+fItocYKItJohppTVmWTJfHbO9fEkJgfvwEXdSM225f+K5jvxYfd+fTlyHxSJvXxLu/REyf02zuab3iaq+wP/gTtqs1J+9/CyUF5fQEZQzl/AQQtOtb2vWa9WbL3kpUtaT2Ax+cgS8XaeNGgI2BtmlZliWTSjOdGHqmeFNwZD2zaYWRgaKS+H5DGALtdk1Zps216FPij95nh1gJUWFEwtkGZw/qVarQeE/CCfOwLale5fv97gfcPMpNplXjyKPEY2rJdcJEY5L601nsREmRB2eao9mEyuQB6BdG8m8nlLey7FvF12NSSFtdB0+yCIOHpnf4rOdQmscqf1zYkCJ5zsX0VPLsZMbdrufq0xUqeqKSRCURPh12UkJZJPgmWfEkhnuhFXVRotEgHMwc6tzizi3qmaeYDvhyghhAlIKwlVifRJkE7WMxI8TB7inmVhMCUiXqUdKpTayP9NvFL923dxjafIh9kcUg84AnJElRl+QLQ3g7thKjFcZojmb1IbZf8p1yMOUhzKlYIHc0Isd2XIGPDA6axuHtgBaWUgqi34IIxCiJTiNFgRaa2EukFjwrZ9zVA1cvV6jeE6UnKg/eE2OPlIGikJkVlDvL4CkKRV0IFC24PbiIil3y/5NJd0UogWCZ51MD1vWIg1xj/jGFyIdWRu8jpNgmADDkzvVw3/O9+bLQ/mo3YLK4B/luvvW1kElrQJOI/r0dEigvDVrXlOWEqp5iipLjsxc8/8bvEYLn/vJnvPnpx0yPnrG8+GpKvhn4fOtj58phtPL23Fx+zvn5Be7qR2AWXP/gj7h6+ZK9Vfzwp6+4uX7gw7/6S4qiQJuSup5iyoJv//4/5YPf/ifcvfwZ+/UtIQRMUYB1aK3B9cg6V6dKoYTi5vollUkUpcm0xpua+ZFJivpdhzKK9aZBq0tm9YLO7pF1mfh7Gf9O85R4wPPCiMfkliT4tBUkVRIXkUqhdIHKGDgxUc8C7/jlFBwSbyQlMXLV4zPfOOZp94jhynGirRRSSXbdQKElVWGS1CfxrWH84+cd8ewx2R4Yj/khVSJZct50qUbzeV1TRo9hwPaSl7dbThcVhVGHNjUi8jQ9vWz7dsDbATd0iDBQaghREaoJhdBoUxym0iF6nPUUSqcKz0ygEJhzj33qEc8jF0drZrLh9sXXcB0MIeBqh5MCI8pEcYwhFyYhc7JTu54e4ewOexDH4S1I7u1D6jcUWt7qMvIBFULCPV2whBgO22VSisfkqyS7zlHo5E34GFvxS9/li52peAtSGP9DCUVAcNtFgiTHtkPGBsOOoZe8vN1wtlAURhFiSaFKoETJElxBFJL9vcXve1y3RcSGUqdnM1QlhYgYkz0KJYTY49xAoUuyjhaIDqMt1rdE4ZEqwXmqKHBoeidx1uJcj6lEju3IrebAtxcjXp4Xt5KP3FuxlWQmxZeH9lewF+Ijvy//TaOOQBqaybRpJZL029CmCk9JlZW0kvTZdLrk/IPfxZRTYoSLD75H39yzufqElz/5j8yPn7E8/wqqnKWT8xDbjDgFT4yOMGzp7nasL18hj97n+tMfs7OSz9aCuqrwaKRWRFVhvaDbNLiw5fZf/Xd8+J+/jx5uCUj6oOkGS0QTMYjJnKqsEITDDe9tT7+9xtkN89mEsG1xSuExDF2iJQUXub27Y1vsudvseLZYYMa9dJKpppQS68NhF14Jkbf5VMaCMrtEa5TR6MzmSC/v+P/fLaYrYnzrBYn5E+Rhmk8DPi9AISh0GjaML+W0rrhYThmc53bbIulYTEpmlXm0w+GLz9yYdEAcPKQi0HQ9k6qksXC795xUktf3LV2fNpo2ty/ptxNeXyrqKqnRFUZTlwXGGN5/csTJvMZ6z8NuoO0DPujczmuUqggoEH3SgmZcNhE0nUKZChtLop5SLgPqPFI80ZRPAkdmxVL17MKeRnXoStIZh68Fpp8TYwcxEe0F2fUkY4qpchsHaG/1mzElhlFj+DcxRxMHgCEdbCO+K8ixLQwegRJJw9loldkKmlldcb6YYr3ndrtHIFh+IbbirdiKwz+Psc36Ezm2dVXSDIGbneN0onlz19D1O6Lfs7n7Od1G8eaNo67TIkxhZtTlHGOmvP/kguP5Euc0D+stbb/FZ1oYDEiV1MOS0WcaEqaVckfT7VFGYmOCLspKoURMw32piTikEoTY0rQRLWq6fsBHh0HnillkFlEeAoynWZ69HGL79sEjkhtMeEtT5G+7foVdzwghJL0BmcvmmHHdEONB1k8IiXOOxPVTGZDXVPWEZ1//R9TT40MSF0JQzU4pJycM7YrN1Udc/uxPqGZnLJ99A11OGe26xQFukDz9ym/jmjuu7ZTrP/9T+k3goSsxkwn/ze/9T6nqmuAt2/sbrl9+zn7fIUkC6rbbQnfHq6sH7h/2BCEpqhJXKKbTObowObWllbHee3Tp+P3f+S2m8yN2bcPtquOTV3f4Z2e0g+XuYUOz2dL0DdqoxNEdQfSYLH+EkJRG4b3PlWRKclKKg2hMyPclOE+UNlvfPFYTvwmPtNHXLZ3UedccgfcOI6rEWVbJRUJnndyqNFwsp8zKAkqYlIZ1M3C37di0A4u6YFIajJKH5/PwDfObH+NYdUV2bQ9C8XoXKYSg7R0vr1a4vsHEDiGyB55yNN6lpRMhWOVEcv+w5tn5MUoK9m0AaiQCKQpiTPCJlHu0idnZIrNjYqDta6SZMwSNnNToeYsuk0GtAtZ+go+Rxmv6poc+EoqIPwqo/TGynxBDB/RE0UPsibElxh7wCbc9VJyPVeGjt6BAqt9A1j0kw7zpl6suIdK2qMlQyOgQomRKuFVpuFhMmVUFEHNse+62LZtmYDEZY6sOlMbx++RvkCACFCEItm0PYuD1DkoRaDvPy6sbXLfBxB1CeLy1oDzNfoytZcUeos6xvUDJgn27B3okLVIk3FXikMKiVcxryD7HNtL2DdIUDH5AyohW+ecVGiWg7brksh2hj7CNgeACPjiULNMSzDg0FPFQ1ZIPl1FYaYRYU2xDjq1EyPilsf0Vg7TH/x7ZA6ne9rg8lUxCECKb+yWMo64nCFUxXSx471u/x/ToKZB2ugXjxgcgPOXkiNMPvsfQbXh49WMuf/RHTM8/YHb2HkW1SD9nfBSAMdMzfucP/zm3X/8F64dblosT5idPqKZLRhJzsD2f/Og/8YP/+G9Y360RwXF+MsXujji9OCFIxc31hqKeEYWmiBKpJYVSSUowCo7mBX/4h7+NF6f87KOf8O1vfZXn7xUIUbBpen5x9WNE0VIYhbOSygS2qztOzp8lC6IYqaoqea2NjXVMA4xRg/jQZecAh+CThgTiMKz8m63du7jiW/9OU1pIZ0XwnsM6ZMbWYwBtNOfzGdPSHOCCSmuKuWJRp3tyt2tZN0OufHXy03r7+31hiiaY1iU+Qtf1hHZDLyrc0KFCx7C7pzQaZVKVpZIyUMKBMytgv9vzcdNDOaFpNTIYrEsSfVJVqKmgONaYCvB57dMJ8JGoavo4wxtFeW5Qi4LiTNPqFSoK+uIJUXa4rgIfaYY9UQXESUQuDawLRDOFwRHtFtgnal3wROxhAJNodqPE5ds/f+Q3kXIfccUML0QY1/iThKpCSA0yuzxEgZaa8/mUafV2bBXFvGZRlyn57jpWjWU5qZhVBi3HhJv/iUmNMIktSKZ1jY/Qdi2xvaUXU9ywRsUNw+6K0giUUQgJSpJjG/IwK7DfPfBx0xDLBU0bkKHFuoYQLRKHEpbCBIwaVWaAXPFGBnrf4wWU0wlSQ1ko2t0dSkRKpgQ83qXtw6bZJ0kDsircW1BCzAWPyC4ukfHbpeJRKfFLsRX8cqh/+foVSdenPxzTFC/EmORDScLiImYc0CeqlCepNM3nC2Q549nX/wHzsw8OSXasWiOR6O0jlBA99eyU8lv/hHZzzf7hNa9++O85evI1JqcvKOolQqis5C/Q2vDkxXd48sJnTFJnDDI5+Kpyxje+9884Pn3Kj/70P/D5xx8xWR7jdOSZKVDTW0RxRdAVXtSooTic+MZoIoHvfucFRmliMWFQPfed59tPnlC6v+bnP/2c2RODWR5zt7/MTrKOIexZjmInZHZGdg4OByw38f6kyiulIiTcLCP4CV5IOCHjZPwdv50h6+iO/lniIOOequrRiiXJ+SmKwnC+nHI0e1wDHTE8IQS10ZRLxdIF1s3A7bblfgun85pZpRmdM8bvMr4i06ogRMGLheLzxrFf31BGi9aB+bMLnj05oS40Pka6wfGw2XN7u4bBEUIWeDcFVhY452h2Ht8LZC0xp+DOAtWJRk4EwkpiB7GPiF4QPcjJlPNnT5k+KbDzQFx4OrOj4R7mxzjRYfodgkAsAm5OEklRAnksYK1hpWGliE5neKonxu5xkBLHFzi9pGmNOB+yv4FBmh+HWWOBRDzgkWG0Yh+r3Tw4O19OOJpV6dDNjKWY39XaKMrlhMHFHNuG+43idDFjViXta4RG5oSbPaaZVYoQJS8WjpdNy369oog9Rlvmz0549mRBXYCPlm7ocmy3MHiSOF3IsfVYt6XZrvFDi5QBXUikdFRKIDWJEhcfMewYBmQhOX/6hGllkshNsHTNEc3qDohY29I0W1yfJGhDJOmf5PtzEJ6PB2D1AD0+itePg8PwS7GNGVb6268vTbplVWObZvxr8sSdQ4JVJHghfQaBkIq+Hzg7K5g//RrLi28kDOUtbm2MkaFZ4a2lnJ+kh0BXh2qrXjyhXpwzO33B5vJnPPzwZ8yOX3D03rcx1ZzHyaDIOiN5Wi1IJzgpYEIaTt77Lr9//BzxH/5f/PWHP+AP//7XuLu8ZD5Erh86Pr61VLOC6D1VVeaWP/llHS+PmE7niP01/+gbX6eMPWXYMGfF3etPCe45XmxZLiqePbngxx9+yGo7QJ74Q6oaCSOMkBr4JJShINO2lFJ5MkpOxP4RXsgP3zunjAXSg8LIGkjxkUJkTzgwxqAAYzRnyymn89S6jy1WYrOkB28c9BVacjorWdSGh33H9aZl3Ujmk4JZaUjLeOn3pmc6Dd9O5zWLyXts9i0RqIymNBqjH0V5IpH+/IjP5lNevrqjbXp8CBT1BCkrJlOJEDN6VzNMe8qvaOTTgDxTMAuIQSJaQdgHRAtGTzl7+oKZNlytXqPrgvPZOaYwuHVL2Fs2LuBsosn1qocpWBFpTc/0rELdC2IJUhq4nxF9D+wP8w4iCPX2TGR8DR5Hiu/6Gjunx+FZes5SbFP6KEx5iO35cpZjS47tuIUFRHEw/kmxrVjUBfd7y9W6Z9UEFvWEWSWz5KoGRl9AgRSRs3nBsn7CpmmJBCojKI3E6EiMDvBEpnTnSz6frfn89R1dM+CDp6iTO/d0KpGioG8tQ7OnLAqUiMiQYYVRwS4fMnpScfbeE2bGcHX5ClUWXJyfYQqFa/eEkGNrJCpIYt8DpK3UvmdaV4d+QSZaxOEdHBM7MVHcDqL18Ba+K740ul+adGeLBXfNPmG6ISBCbjejxwuV6CAh4lwKlJSSwfZMlxecf+17OeHGhM+KdALafssP/v3/hR/92Y/45/+H/yPL86f584r0caJHSE09f0I5PWHYP/Dw5ue8/uG/p1qec/Tsm5SzEyIuJShlCM5iu47BWsjosx86uv0KGS1PT2c8zBW3qy13mz3WeSgLzp/NOT+eo4PjYdPR2pHmqwlCMX/x9ynWb1h99kPqixdsH1b88Ocbjo6WSFNSKsBF2s2O8+Nj2u42aw+I5OKrdcZ1M+CuUgUrlc7W64HBpu0vgMDjCfuowBXe+bpoiCATGJXa4HFFVSQIKAaP0RojBaeLlHAfoYK3SPHx0cvuwEEFaqMpllPa2tEMjttNy0r2HM8q6sIkbi9vp51IoRSniynj4PdRsWBM0skc9GtPT5lPprx8c8f9/YaqLBmiYjmfU5ljmkLRnkjM+6Dfj9QnA9NiYAgVzpaERkMjmM1PkZVGA2Wp6cRAXUagoNspdi+viQvDVNXYOCArg1MdoQi4iYW6xJeZQzxEYqMQ+yq37BzGWSnzxiyZmDsE8Yi8vuvrQNvKdMDUzSSzzhTb8MXYLiYZKhhZCOMpl/nqjIO/x9g+XZa0Nex7uN0OrHaCo5lhUqoc2zERpQgWOnK6SB2kyP9EAoHc0gvBpNB87dkxs2nFqzd33N+vqcrIEHqWM0llNI3WtFJjtE9WSM5lfDyghMyEHMH8eJncWZSjqCRd6KiVB2HogmJ3d02cGKamxroBqQ2uS7sF1rkD42hkmsTxocxUw/HLcU4hkY8dQuak/9rwwnxxzO3r1/kbi/ySAd7jhEcd2AshaXeKVNVGCpQqCcEeSvJUoTq8tVgUH/78B7z33/8L/tn/9n+fCMZA8p4K2dspDeOq+QVPp8cM+xV3r37MZ3/1bzk6e5/5xXsU1Yx2/8CP//Tf8J//+D/w8etbyrLgg2dHnMwNrt9yvFxSVgVx9wZnOhYTwart+Z1vPuHk5IzrmzuQhsLv2HYWGwTOgVAlQzdw98mHRFWin/xjfvbHf8rtDr727e9xefmKxbymLie8/OQTmv2O2WLOYAcm0/lh116NK5QxGV86lzm8MT2WSo8q/OnURMiM+eaKnSSg/C6vpJQUDpNm8rcfd+qDD6hKMS0154txDZS3HrZ0uRCSz10izR62ssaEMyk0k0IzqwyrZuDNqkEiOZ1XHE1HAZXxb80JLMYvfJYRzk5nROLWPj2esZhU/MJorq7vmJ48w5gZRs/wC0u8EITTDdOzgRfyU05Ux94s2FUL9rMFvZ9QndYoqWn2gWp6Qi0194OiNoZub1h9vme+mOBm4OrI4uyYXrbE/TUzs2M+D2zlnOAEcQ9xHZCNIcbxlUpDloMUb74nQuYXVLzFpX2nsYUowmPKH+2F8v8MPqBKw7TSnC+mFGpMH/GXYhtzbNUvxTZhmJPCMCkM80qwaiOX6wEZI6fzkqOZyrENJJzVI3ApN4jHw0iKMS+kOBda8Oy4Zllf8Avjubp+xfTkAlMYjAh4G4mDJXQblElaISidqIAiQydKUFUGpQSti9TTBRNjuO8EdWXoomG12TMPE5yIuBBZHB3TtyX2/i5ts+b7EQ8a/CGt/T7eZdISznisjLEVh2T9a7MXlotFjlXCI0NuJWNMBn1OxJwQ5OEE0KZkv93hui2721dMj59gJnOilPzsh3/OL37y16AdlBMuX32M63bo2emhfBdZ3idxdDNGIg3F7Iyn3/wD2vVrNtef8rM//deI6Li9/Jj/+Md/yetVTz90fOdrT7DbnjYrRBlzilKa02fPsTawWa9wPrI8PuWjn/0ctMoUj8jRrKIoJ+y2DcIONK9+jI2ak6/8I7SesPzK73Dy/kc8e+85MvQU0xkxpgnw8mRJ2Ht61+H9JNNn8k67zI6+MSXZEFM9nrA2mYwYjSHEiAshV7z5mUXwzreAx2Sbc15K/4/VjvOe0hQ8PZ5QGZlhiFHwKJ3jLkQ+udrw+tUN3/36E46PZowD21RwPL7GE6MpForlpOJh13OzbljtHMfzmllVUWhNRGahmLFqHvGxcMA+RYQQFM4LBIqLsznrZkGhZvgwgSWoi4g4s6iTnqNyy1PTMwsbiuAoZcSIwM5I5DJwtigRu8CbKwgdFMbQ7i32dk0xlMhNJGqBnpZApFqUVEYxae45Ew1uUdCe1sitIK6ATYHoK8jsiSjCo/WNSDOSR6PR38wg7XEw+zas8agd4HwSbH+MbU4wjxMiXAh8crXm9atbvvv15xwfzVE57uMgfNxTnRSawmiWE8XDLnC9aVjtIsdzzawWFDoQcYRoIb61lccXce0UW4/zHiECF2cL1s2WQln80EPoUWJA0CFoEbKmKCdZVDxkQZoRs/aczZPWwpt1StZlbWj6HrtbU5RlWlURAm1KCFCUNbPZgr7ZPPZyktyhPHZfI4oRD9TPPHA7xFb9jQPsl68vTbqT6ezwoIyNXrL5IFWtMmm9OudT2xAFk/kzhiBZvfoxP//hnzB0ju/8w/+G6cVzvv/v/m/89BeviBiKaoYp0prhSMSXyqTvk4HqtznBUoDQJcXsArnd0q7+HbevP+ejz695edvhhWIxmzIrsi+UDyyWS15++glPX7xHWVVc3lxSz+bMJhfc3dyCgOlkQrvbcjSvmJhsPGk3DN0aqZeI6XOEOWF7+xkvP/6czXrHvofp+QcIKbj69FOiBKMM3c2GrmvRqqKeTDMnFJy3ackjBy85L4wvSXbacA4pVXoh8wGWIIiYzUDf3RVGcY7cPo4Y+YjrxhiojWBWJiPGR/7lSBVKqlWDjXz25hrbdfzh7/82VSEPB2X6ex9FXZQQ1FpQHU04mU1Z7SXXa7hda04Xx0yrGVon7QwfPOvtnjc397S7NcH3KKORuqKPms4rzGQCRcFDVbGpJWIpiecRfySZvfeEkw/e4zheYcKEoXtgswtsbME2GvqomCGYGcFd74nOszCaCyP4659cY+/XLItk9yRJixWNa7C7hkXYMzeOmj0z3TPMJoiZIMwlTARxmBPjDCUTtSmpVpH+LUTq/khp8DcxSEvP2KMYz8hhhWwNFTy1FsxKc9CMiHnVe6zlQoDBDnz25jW2a/nD3/9dqkIcYhkP1akHJEoEai2pjgwnM8Fq33C92XK7dpwuCqaVQOnst+cDq23H5c0DzX5H9BZlCqQ29IGkd10UICUPLWyGPrf5AicUs9OnzGZfJ7iACzB0Le1uw2B7iB4TI1oIZkZxtx1SbGvNkyn88CfX2O2K5SzHVmu01uz3DX3X4WyS/Ezvnjywwwhjp5d+Bnno3kfHCIhC4oM/HG5fNof50qS7W3+GUjH7VSVQPvqYZeIgoBJ9J7hkWULk5Nm3MDrwkx/8e37+018AmoeHO07Ozthu1nz+8hVdP/DiyTH392t2q3uKyZJRnCRmCTXi40Za2qmOfPbzH/L9f/cvuXv1EwiO3WrFtveoqmK72fP8dMnZ6RHB9fTtQD1bJpy577i/e6AfBp48XbDdbLi5uedoMUtDtFJzPK/A9bxZ7xAicnJ2Qvns99j+6C9Z/eS/cPHkgkkl+N1/8Luoeoobaq4++RHd+g3z2YTX1w9IIi5vRan5Emtt0l8IaSChMy/XOpsl4tIyRpJ7zG12jNmtYzxVD/3pO7sOSy8iHES5c8mbOYoCOzhcpgBqLQ+YfIiSfWvZNZa2HVBScvOw5WHd8ex8lv4efG7LHuGIkVYjEFSm5MlizqKecL83XO80KhhmZxpTKG7ud/z88xtWVzcMbQMe5ssz9KSEuUYsFbMnBrWUSGWozkp85RnKAVkKZk8q/LBm3e7RhaZvS1pZY6dzYiwZfAlB0jSOV3d7ZigWhWImJCfKERYzJmrG7XqLkJK6NOi5pJEDcyQz6zG+Y6Jb1tURfgJiBswlYjcl+iVC9BAGYrRE4fItDoyqVeOSyLu+0uA1Dc8eX/wwwo8gktKdC0lE3ihxIBGFCPu2Y9f0tO0eJSPXDyse1g3PzpeHaMZcQecxLGk5JCX7ysCThWFR19zv9lxvdqhtYFpJjJbcrnf87OOXrO9uGIY2YbAn5+hiAjLNQqbCoHWy76rKAu8dw2CRUlFNFuzbgb7tKApD01qQFcV0AtFlxpCk6XJsa8Wy0syM4rRwxNMZk/mc29UWIQV1mTQn1iGitSDYDucjOsOCMVfn4/CYEWYJacAd8kD68d0ZY/trJt1arCmNYBjGyiW1Az4KgrdEoQiZn4uA6WzJs698jc9+8C/57JPP6HqLkJGbhweuV2seVhuUCHz1vSc0TcMPPvwJ3/hP/47v/sOWsp5ydPoMaRKHME3vPTEO9O2W7//bf8n/9f/8f2K72xOEop7O6buedvAcHS2ZTSqOF8nh4P7mjumspiw0+/s9XiistcQg2G/WdJ1l23ouns6QwwZjJEZpOtsjlEGUJYt5hbBrTpeKv/7LPyN032Fx9h4hbum6Pbubl6yuP8fZgdcvXzOESBgsth1ozJ75caAoS7x3SK3JAgtEIVDaYAS44DNtDBJEkwwOJQqpVG7Tf82370uulBAf0+HYUaRflZRaE5yjt5673YAb4PRowawyWBf54c9eslntODk9oq4m9J2ltck99W2h58eBghgb3vyVRsgJk/KYYjqlm0UuxY6fuFu6GNiJDfv5NegOMUBVLvFRI2aRcBwozxX9uaU8jyyPDabcYdt7lLecTWpq3bPe3KGNYBdqXFnSOEMsl3Re43pPs/O8cY5pqXiiCuZohr1He1A2UgrFVNUIA4WS7PodrnJUJlIMLdrvMHJDUZzSzKr02SYRVZXE/YwYEh9WMhBjn2t/f6AWCcFBa/ndxnYcPY5Dn3z6kbqOUguCsym22xZnHadHU2aVxjrLD3/2MZvVmuPTE+qqoO8CrXVvWU+NsFhEZMw2fZcAeTAmZGBSRgpd0s0kl/cbfvrqls4GdtsN+9tL8D0CKGcLfBAI7wkxCd4Mg4WomNY1IVi6tmWwjqqeIYWkbTqM0fggMGWFdx5TFjjvCF1L00XerB3TSnExS8yZwfsk0C4ipVZMJ3XCkRXsNjtsCBht8EOHdT7rjCTYi9HJWuaZVoYzRnnHcQRJHssgxMEC62+7vjTpGgmTScFm7x6Dmtsi713iQhMPxoPf/t0/wG9fc3d9xXbX4H0Cy4fB03tH3w8YrXDest01FGXBv/nv/x/80R/9K5yFr33j27z/lW/wtW99l9PTc8qqZHv3CT/8j/93/vV/+DNssJiqpO0DbT9kipVl33TMas1q2/KNsuLo9ITFYkEhITjHYlahZaRtOvr9Dh8VdVkmwvR+QCpo2j239xt2NiKLKUrC+vM/JYSCJxfnfPyzv8T+9Cf4BJWxWd/StjsgJq6gjdzf3NM7C9owDD1aG4RQKQhKPbZ+Id2zVPWk9i9xZ+Ohwh/b+jGe7/SKCS4eDS9jfqNCBCFhmUnyN5uO1zdr9rue6/uW959eYAPcPDQ0m4bL11dUkwJd1QlyyrhvjInw/kUcOI7FOyFqhKgRZkI8ijSzljvR0M4iu3ZLZ9ZQdIg+IntBMZ/hOoFaauSpoHzPMOgVyyPLi3qH2XzMvPQEM6MJJQ9bSVCGqBesekkwMzpVEvSE/a4l9BFCZF5JfBMQdqC1kt1Nw27TEXuIzrKQiqBg23YMyjGvNNr2SNeg/RYjt1RlSzspYSYQ84ivI6KZJhgmJu2BpGqf5ERD5nImRarfxIkaCPiDy0f0SZAlxMRnT7H13GwaXt/cs9/uub6b8v7TE2wYuHlY02zWXL5+QzmZYKpF5uHzS7ENj1N9kmCNyPi7EGkeE4Ol2acV+dYGtusN/W4FrkOIiBSKsprhgkDphMEWhWG3b2FSopRks9ljCsOinqRNt+0eKTVal3SdwxQ1KEHQmr7fEkjGufOJwrcB6Qe6XrPbN2ybxJ+O3jKvko7HdtcwOM+kLhn6DusCziVx9FFk7bBNmJkh49LQ29g05MP0vyK2X85emJxwtGi5utof/uoxqwcfkuxeBBEFp0czXpzO2G9uuL6+TtWwSC65gXH6rCjLguD9YWV437b4nWOwgeav/5y//qs/YTadMJ/POF3M2Nxf8ur6gU0XMEVJUZcMvmOwnsKkB2u72zL0hqYreP/BclxXRO8Z+gFpKoQpmBUa2w+gFMoGFtOC2giq4yV+aBEx0IdIWVZgKvrtmom2PHz2U4ZYMik8Lz/7KffrPdVsQTmdc3x2hrMB5yK3P/0E6TtqpSgLkXHqRLVLtuB5MSRmYXISK0HItM2XqLmS4NPLOVp2x9TBvdNrZKIgY+IIx8dORkvJyWJC5yKvbx+4vVsTvcQO0LQBpQuchd022d4LL8B6VusG/+wYqWXGZTn0s2Ic1ORLCI0LBVf7FT9fv+RuuSO8iGjVUM4Gogn4k0i/tYgwwSxLVCexxlM+8Tx5uubIvuRJuOR5e0mx+4jT5RRbnfLRViP8kqJ6zn2c08sZTp7gnCI0Ad94pBNMyinnleZWwuXViiM5R0fFbLpkMkzQXRo63W0bVqJHHhWIuId+Ty0GyrCn9FumsmVbL3BTiVxI4jzCrkQMeeMrRCKOxEntGQ0pE4z+7pPuqJWSYpsw3KRPkAxkTxZ1ju09t3d3RO+xtkt6BVpirWW33aT31XnEMLBeb3HPzpDZxNMfurORcUIOdsL0nfdc3d7z808+4269w8eA9z75prkepQW2H5BlgSlKFPJQXRZGM6krQoi0bUfX9pRliVaG1XaL9zEN0GKClmQ2vA0hGWRKIZhMZ5xPNDc9XN6tOVokbZjZcsl0OkErifORu82eh32ijHnnUn4QEh8t1gcmQhxmE6Pf3SOvBkYbrUdu9OP/+7XZC0oIFlMDefssXYIQ8/QyAlKwOD7mO9/5gB99/1+w7wMP64YYJR6Vtz1C3m4qUErjvM2i5jprEkiUBGsHYnC0XRILjrbl6nbN3aalbR31VLIsZwjjiUNS+wohte2ISNNbPvz4irB/4GvPj/n2N57jnGO92fHi+VOeVwU39xuCd1RlQbvbICTUZcVgBxJ9VyY3gutLlt/8KqaQrF5/hmscctjR7Tb4YAm2xVRTegu3l7fsdmtmU0U5mVIdL7EZc0ntZFqrlULgY0BIjZYggiN1ChFiohBprQ+cyJg5tO++Dc2uvLnyHk9UQWRe10ynE169eWD1sMFbh8DgnGfftIg4MAwRRMVkWhFiz2a15k15zdGy4mhRoFVgPikZOev5W+JzadT2gZ+/esOPtp/RPmsIJ56TYuA99wrRrRhEja2P2RY1vp6i54GuCYiw573Fnt9SKxbtT3nhXnK83WI/3lBVPYuv7LESiBdodcx9BBsniL1GOEHoLcYpVAhIYdgPEVlU7IYt+/Wap3qOEQU2RIbGs+ssa9fi6sCw7wlhxbkcUK6lsDuM2FD5LXV5ym5ewQzkUhC2wK5A9BEhPURPlI4QOkYWZ6r4fwOgbq42ZXolGGl4Qgjmk5LJtM6xfcDbAQE5tml12Q4DCJWH6JHNesWbyzccLWYcLedopZhPqrfccmOGHdNj1PaWX3z6kh/9+Ce0bUPwPstqCrq2R0uBKcsEsVWTRLNyHjf0lLMpQioG30MIqCwOZG1ACEf0gegDWmtsUAglkcIQCdgQk8hWDEhj2DtQZcXuYc/+ds3T4zlFYbAxMnjPru1Z7zq8j8m6q2uREpyDYCNWeHyIGC3zdlnITIZxDJpcVJJpb3xry/NXx/ZLk65zDXWpMCa7/fKI6woRUSIyrSf8wT/9X9Jd/xWvLi/Z7gdcFLgo8DHhsgiZBklaMJ/P2O5ajHGHlcSYk0CpFUYpykJTSMHl7T3dEKgnU6xr2PeOpRBUZUF0nvXDDqkVk7KkHwa0Kdg3ez795A03D1vu1juOasG3vvk+9XTO9qFFRU9dKKppje0bJuWEogj0ztC1Aw87B8rQDNA3LV/93v8Epf+YH//Ff2Fzc0e77rm73zOfT5ku56w3lvuba06Whtm8ppgesfck+EUk6/WYJ57weAr6mBp8ISJKprXBw0JLzNVJNk08wAzv6srF0PjvhPul7bgXT87YdIGmaRmGPlXF40DPOUKIeA9SFUSSe4aQks1ux1/88MdIYZFYnpydcnK85PT4iGlVp/sA3O0cH35yw+u7HvdBj7pQyNOBU3nJs/ApRmzZ+QrntizNEduQ6HT92TGqbfjqZMsFt0zdJcduj1oL/EOJlSDnlvI4UOlUNQ09OCsJG4cEus2OQicdhxgkl6se5QKT2Yzdes3Hl9eUjYBtJDaRpuvY1z1RRwZhWajUrrp2SwwdUXZE16JKiyxrYhERhUBWJCUVZ4hBM2ocSDG+wGOy+s0A9iFXomOVFkniRS+enLHt/FuxDb8UW4/3Pm+XpQQsRGSz2/IXP/wwbWwi34rtkklVoXWSX73f9Xz4ySWvP/sFduhQWhB9SIwNIZEysReksyhT4ewAMVBWZXLzmNQEJN4FjDEJljMO60DKxGJSUiW+uw1EIehtGuJ3+z1Gh7ThieRy06PwTKY5tq+uKdU4oI803cC+S1h77xxSpS6zbVIhJ2XMFk/FYegpxLgwn2G5g+noo3Ic4//9kvP0y0XMI9TlNCVdFxHhkTYihWRelfzh//x/w3Jm+B/+hw9pOofUhtgN6cSQ48OVpNKUkBRFwWyaWlDnBrq2oSzSyqcxGqMiRmv6vqfZt+y6wGQ25+jkhLuHfUoW3rHdrKmqgu2+YzqZ0ncNto8MXaKx7dqBn31+lwwhixlFNcPtH0BKZtOS3X4HAoqqoi7g/v6O17d7NvuB99674GHT0bvI+vaK0/d/i+8qQxB/gf/sls+uW5quT7YxnWN5NKHUkXo2B1ngOosfH4C075Aw07ydlmx8xsDlKiFEhFIJ65KaEBxCJH3T4NzfGaNf78p2I4f1yRTs+WJJPZ3y8m7DvmmzCMho1+MYzQQFSWc36W54CAFrE5zifQdhoOksH7+8pSxnTOoFVTUjyIqH7UDTFPhTgTgWmFOFmXrqsKWkoVYW5wNNDyZAGTuq+ZxpVRKrdDhtfYnX58wmE6b1FmYRHyObkxmv/JIb/T4bc0EQx0hvQEucHQhhAFFitMa7QBCa1aYjNj1yomhKx6rriMahFwpzoZg8KxHPYL6MzDqH2zb0QVFQ01HThILOG+ggdhE6oItJXCfaNNmXeR2XEVHI9Lx3P0cDHhPtoc0QMDvEdsd+P8aWLMwT4EAbS3SpGJMUJDFg7ZDmOC7JADRdw8cvX1KWJZO6pqpqgtQ8bBua7Qo3dEgBRitEUATv0iKQUlhvGfoBHSDEjtgfUVQ1lGXGWwNGS8pCE5A4XyRcOkaEkChjkEZTJlQLSHkk+A6hDUarJMIlc2xthxSKpnesup4YfNKc0IrJJDmJlMbQ7Pest03y2ss8ZB9GlsY4m0jynYfOME+6U2xT5T/e9S+rk74cXlAVhQzUlaZrQxLhJpXVUku+cnHMQg988sPvc3V1Sz9YhAgMPuaNqggqmdNFkd0JhERPK8qqou1bJpNZEoyxA4KAUQohYNu0RJFkBZ3zSA3We6z1lEYnfKgyuNimpcKR+Oo9Wib1MwToasLHl2teX91zOhH87u98g6732KFHKs1u34GF7XbLbt8ynxbEELE+EPWMz3/6XzCTGcvllL/3j38fWf+Cjf2ITRsIugLj6Ic0TbUuDeReXe84eT5JwzCZliNC+Fs0FCKZEpdghuhzkKXKHnEpsSXzmnd3iZgmzzFX10LCZDIhFhM+uVzRDR2267LBdJ5QH9wmIlqClTFDO0nERzASIBK2Z50gxrTI0LmI6RLlbLcHXzviPGDmCjkXLMqBqmswoUPRUlAknYCgsb5HbT/H2g6Hpl2WbIopm3DGbpizLJ9Qv29pu4GtWHIZalrzhLU7YudLpNIEk9ptUxm00tjBst12TKcFgw203qNVJJ7V9NpiJz2lhDABfaEwC0cVV4jmDu86gq6wShPqU3o5xXtNaCK0QBMRnQDviFiESH5ejwsmj4sRv4E6NyXR+AgpCCGYTqdQTPjkck039Ax9m60x3+LD5+gqKbFyTCRpYi+ISXclc1AS5RGsd3TOYjoLCHa7DX7o8xp5on8ZrejdkPDl8W8IHh88wXu67X2iWWJgeYQuSmIIDH2PKSsm0yl926VhoEiMAuuyi7cyuBCQImBM4tzaoWe7a5nO5ww+0HYBLSLRTOhbjx0GyijwSIxSSALWOdqmxToH2iSRp1ohZOaBHPC+jNWKfH9HN52M9z6O1L48tr9S2jH6wHxaslpbhE/bQlopjk6f8eyr7/HTv/x/8/NffMxmm2gdITpckIcELUKa0AsBgaQ7cFjZEzWxTJQz6y1du6e1jm69Zbtr6W1ktWlZnpywmM4pdh1392vOT6YYJfBEysLQ95b5tEoYTZ6W+2w5XSjBer2lbVs+x+NUxYsTQ10oTpaGtmno9p6HTYsNcHy8xLuURKPUPP+t3+bH3/+3vP68QJQzNl1gfrRg3a64ulrRWYchablu9xtuHzruO8/pi8i4TjBGQeq0shiCOww5kk9cCnCER6tnnx5RJSU+vmM93UzzGTHnSV3xlfee8YubLZcPD4T84ox78eNDl/5MQKhk2+PdkK251cgiz3xeDcIQxQShFgixwPkJLoKYFnBicfMBMRXoqWChOqayp4g9YthTyIDQEkmDjwbtN3Srln0XkMM57dEZNp5jhGZRLBC64MENNF6xkwqpl2ytxlEipKCoBL2LhOBwIRKtww8DYhJ572LJ57eB1WZLT8tQ94SyIxQCP9NMJ54q7NG7N8TmAW006CmxFFg1o4kl3kpkD/QC+sRkAQsMCGGJOEaBoVEt77FJfddXzGu/Y2zrHNsdlw+rHFv3Vmwf114hCbyMnYAa5T3lW8S//CyLzMhJOtoWNwyZ4hlww4AIUBUm2U7lytkOSRZAZa2RVE1bmtUdXTdgh5bp0Rk2RowQVIVG6AJrPd67VIwYzWBt+t4yUkhBbz3eWRzJQ9E7ixA5tleB1f2Wvu0Ymp7Q93hjMaZAm6S90e4amqZHmAKlDWWpkgFlHBgPnvH6gqfjYSA6/rpIM5i3EvDfdn1p0vW+BwSL2RTBDqWS9boqSr73e/+M8/Nj/uovvs/N3QrnXBa+yQMTJZEZyzJFwvPCwcoileFaBITSyTE4GqqiSDy+/RvWu566nmFKw9XNhvnRGUdHCz7+6HOWy5qiLEEXqDpSFYpZIWmalt4OaJ2DbD0xtAjhsMOA1pqPXt1wdQXf+uCE955fcHP3QN9beh8oSk09m9M1LddX19i+5+S9F/yj/8U/57/8+3/FH//pX3F5b7FIpC4oK0HvI/t2YPtmi5ZQlJpvffWc2WSKECodNIeV1jTxlDL9OkEQcQgUPrrUrvhEZfHeI0XEx99ED5opPUBVV3z1+ROi0TT7PcEOB35nzJVs2mDLe/RCIkRaYhB4vM8k8uDzanP6WsoKLecg5kh1hNUBaxrkAspnBfqpJBy31GrHTOyYyJ4yusxplShhspuuQ/gNlRU0XWC7KbjeS1p1RH3xFWb2Kf0KVvcNpjQEAcYpHBFdaGRZ4uKA8z1Dt8faSGVKgh3SAs1C8/zFMWIuuNkMyNZT2JbSrZg6y3KAKjTE5p6iCBRaY6opKE3vKzpvEJ1AdiJBDG1ExIEoegSWBMu43Fmk7ktkbeDfCLyQ82JAMqknObYFzb7Jsc2zmRBybN+ax+fkYQqTY5tgrbGjEWL83BItNYi02GMHlzpHAVVZ4lUSnEoLOKNHYJoFSdKvhTx5cz7grMV2Dc3mnm6/RyjNydNnCJlsdIa+xxiDLoqUN5RAG4U05rCMZNstjkhVFQTb03UDdaF5fnGMQHJ95QgxkQDapmdQnqoq6IOnazpEUSG1pqwMhQL8I+Z9cDTO3cPoCpLu9/hr+T6m9blfnzIWQ0TpmtlkQllqvI+IaPjGt/4+z7/+HfywYb5cEmNycXXEVLWRzBV9JClojeZ1MWFEI54pRXLTlErmX3b4fkXX9AQXuHvYMl0sUEPHw2bHpNLE6Gl2DfWkpu96hq6nsBbvDXFoeWgdAp8Sm/cMIqBkoO8sxdwQouBu11LcNDy/3zP0Qyb1K+5WPcf3OyazGYvlkqbtiFHQNR3f/r3/MZOjc3704c/5D9//OS9vG6Qy1KXgeFmwXEyo65KqniLrE/ahyuLbJkEhZApYSDjoaG8upUnnok/Vrdap5Q8h9f0xeJC/yiTw17gEGFPwjfefM5nW/OTlHV3TZIyARHVK50LuleJIEklVeYgURiFlhQ8Wa/vM1zaJziMrkBOknhNrxVB0+InHzQaq05LiiSJOPAu2zEWLtjtE3DExkf2wpzQG7y3Bd0hnmArNNgp2HlZesemhftjSuRI2Nb6B8kzhishQe0Id0McKmeSJsa6nb7cYmTy4fD9gZnB3v6V+UnH8tKY6WRBWa+TDjmr7ioVq0T4iooMyE+KlQkhFFwt2TtMNiklOuLQgLRBbCC3kpBuDOyyNQNZdHWl77/xKScCYkm+8/+JXxDY9k+RBaoptehcLI5CyxoeAHWyykZciaw5IyPcihsgwDHjncd5SlSWFTr5jqR1XqfiJCQKww4A0Jc4HvA9ZACrr4XqP8+lz7h9S64+piTG9F4PP0EaIeUsypHnC0NLvN5iiIFYGb3sKFbl72FJPKo4WE4SQrMqS3cM9/TaglMjzCI8ui3QwSJUU12LEOwfBv0UQG30Lx/yVB+NxhBJE/jrTOL4ktF/+NsskxzabzKkKTQzw4r2/xzd++/eQwXLz2Ydcff6GwQa8TYklBTKdKIJsejiuEIeY9QhCZpvlbQ+fJAVtv2F1/0A7BGaLBTNtULogRLi/XxGParrB0g2OZ0+P6UTHy5sH9kTkpMDEgO1aJrXGuWSZ4ZzFFKTKLJMKo/PcPDT82V99yrQIPHlywmrbcnm3B3nNB+/B7/7ud5gvZoRhB77n5vKazbZnMp3x93/nBadvVtw87NFS8vRinjQ4dQGmpj46YuILdj0HbCzmQYBUAqJ9y34+rTkrIYkqD6dcptnF1P69a1eX1DEKTD1l5yWrhz03d/cEP2SCdz4giXnyHhAyMVbIdkZJ8T8ZaTqfjA1jdBnWkcSoEdRgDK4eiDOPOhJwYuBCII8cE7di6tZMzZap6jF9Q12AjRYVSxxpoKHiDhE1lShZRUkbp8hVSbjquP/kJeESJvUR6mvPcfWAOhdwCl5axFRjGRhshyoNBJ2rrIgJge3g2N3fsygVz6qG5ekAfkNhr6j6G6TU2KhovGDwFbGcYn3JZog87Af6GJm2CccVvQDrgI6QcIZU5cpR9Do7rIwH8G8AXxBSIqKgqGfsvGZ133Bz95A2SMPIqw3jGZoSo0wH/agVK6REybSw4LxDqyRD6jMkltTvFBBxLmlMJK2CAoQg5qreO4cyOvkn9gOmKBjeKroij1QzkTU/hNSJDWE77i9fEoRmsjhBThPbQeYu2dsBIRXWpg5GGQ1aZ2PIgBGRrXXsrh+o64pJWVCcLpHOsrE9ru9Q+Xm23hG8QJfJLNYOPcN+w6R63Ap9NOH8ombGAVbgi3DDl8X2y5NuTGVzNXvCYnnH2fkz3vvWPyB0K376n/+Iv/zz/8SryxsG59MGto8YqfKN1llX4C190aRijYjjWl0aEDlvCd7hu5bNrqVzketX95ycnnBxsaSu4dX1K06Op9SlTspCfcPSWKoLzcevdngbmBcp0dvg8FEghCF6j5Rl0t/Uin4YaNoBhggh0DV7VvsBNzjWrWXSpmGga3bc396xnBjsfg9Scvew4pOP3hAJnJwumC+mdE2HImKHDnxKOP/tH/wTynLJH//xn3C/afOWi8s20ele+OAOlQIhZMxKHgwAEz1l7ALe7dsppGRWVZycLrle71ivHmibHcHZx6FKyGUtIm8XJWgh4tMyhxSZGp8ci5WUEA3EkKojZ/BR4OjpRA9lwBY90Vj0dMJ8AtPOQbdC6B49VtNSIlTib2tTIb1jlLiMQtIHyWA1uhEMNz32pSXe7fD6Bo2iPzZU5QQ5K7C9Jw49Aw3OduhCoyjwNg2CI5FnF3M+svds795wUtxS8ZpFeMOyvEPZS5oONlYj44yolgyiYhcitx089CrNLHYCGpEGaX4A0SPlgBDh0JqnRDe2q78h2gIgpGJ+iO2W9WpF2+xT5TZWYZnyOQ6GYl5FHFeGpZSHfZwU23j4sz54BucSPm4tXT9AiNjBEr1DTyeUVZ1Wjbs2zzFUGsRmkwDvPcqUmQ0RDnOPVIikbnnoh8TbR+Bsj1bQBUldp2Un6yxRQN82uL5Da4XKppujK8vTszkfv3rg5uaBujAkUS5HWSZ4aegbvO2z2JZGiPTzuW5PsC2xnjOOGMchIjx63IXxvo0nB4/sri+7fgW84JDFEnPyVb79D8+YThcI19Lubrm8/AV39yucdXl4JZHjiU46OZPfUPoWQoRUt6ikUOV9yEl33ENPymBCao6WE1zc8NmrKyKGsgQl0trqV16cUWiB6LfUtaX3HuE9R7VBRIupVKows7K7rDQ2pBtlnadrLfebAVNElEot/aubLe2+pxkCfVR8+5tfoTQC1+358C//Em0KLi8vub3fs9k3OO+ZzmZoFbMAtEfpChsV/SC4enXFP/tf/bccn1zw//wX/x2Xd1tiSOwPKVWOYR6WZQ6vFDIVkaT2fTzw8B71juEFrQ3vP73g6GjOenfJfrfF2ZxwD4MV8iAwTcSlfKTBJFEVnzsVkTnGJk+6JTKCUlMGX9KGAdsPqD5ioqZre/q7Pd1iQVGc8rC7Y2oFQi2J6pQgJFstsXqG1XO2PtI5idVzbqWhEzVROuxcEt8TSdf5YYoPms3ZHX6m0U+fMHsxpZUDcQi4kJYApFZMqpJu29P4Bl969ELw7dNjhtUa9/KW7epnTPxLFFdMRYfVNTGUdK7iYShZ9QUPLHjgBB+OmW1r5AOwisR9xnNjhhViSPzSmPDTKEKylBo5nb8BdOGLsb1iv9vgrMuJYZzCpwQiRvxxPOzJqnZxnJ2N+rAixxZkVChlGKyj7TrsYFEiuVB0dqDf76nKgqKsaXYNbkjaI1oVKFGgjEBqg9Al2oNzFqmL/F6IzGSKRJkkRpWUBDewub/GozHqgtl0SrsfiCHg3ZA2PMfYdj3NvsEfe4wSfPODM17f7njz8g3d6gHhE1NIC/A68bWjc/ihxfdNuj8SqlnS4U73IRwQg3FElu7R42Zh0sdOWO+vWnr58kFalFQnX0eSBM2j7cAPTI9f8Pf+4T/jo59/xmbfpSFLdphLg6OQHBiiAPkYNCX1QZBbSIFUOv0Y0aGVICqNKTSyMDx7/gTMhleXV5wczyBGtAhoqVlODKUThLajbQamBgoZkpuDVIQw4Hxk2zREXaGkz2uI6WEzpaFQinE1GSESXUSAj4rNtmNSV3z3W79F7Hd8/4/+jOvbFdc3t1gP5WRCNwSmkyL9fFIRpQZRstsJ/u0f/Tn393v+4J/8Ac/Oj7m9X+OAENJgIiLROh0yISYmgRSKKLO0IiJVSDJp8jo3/Ne/df8V15OzUy5OFsmKexQSj4/JYWQbylH3VUSShdtbAs8xEoVmND0UQqd/pEJESaTGeYm1jqg9dj8gakVVVrhNQ79y7E4nhLikdk3G7y7Ye8dO1OzDgt7P2UTJtnd4jtn6QNA1gh7mAWqJOLHIkDaeKDqc9/jzmnAyJdi0pi5DGgB52+GLkmqmkVoyGIuYRQrRcrGA6ddO8K+PqO9eEe7uabs1Q3FCL2fs4oS1ueC+eI9NvEDuJ0xaRXHvEQ8CuZXEfiDRFxxJkD+34iKLCeVeVYz3+x2vdwNcnJ18MbZpapYr7VFqc+wyM4toVPbjUZIzZonRsesafcNETDRCF8E6T/QO6x1CG6q6wnUdbhhQRUmMEufTZqsuKpwLIAwuGIQXuChx/UCBzMJQ6sANJqRNNaEFWkFwlmFocJMJYTojZPOE0VHbdx2+LKkKjVTJwQZmhOA5WdSUX3ufy9cFm7tbmvtbwtAhlcjC4xFhDLpIdDFjNHUhKYQ/FI/xEKx8n2I8JGLEo1LbyHv+teGF+vzvIXRF8+rHmOUFRhcgFUO345MPf0DT9Qip0BnHJZf2PoZEzfEelXm3hS7wMSWZMG5oZS3ZpDeQqGODh0U9pShr2h7apuPhfsViPqFre1SMHE0UioiLERUCT04qytIgy4IooOp7YvRYB+uuZz7V9IPHEjFaoZViNi1QwmEDuMHR9mmTZxgsu3ZgNp/TNj2FLhiE5uOX1wzWU9cFIQiUkrTtwHRSoowmqoJto9jbAaLnhz/7hJdvrpnMJrgsjRkj+OgzfpYEQsQoPROTDoIfQ5mrECFVpo+9u+uDZ2dorRkGjxQj5vEodJ2nnhAlmZaYfk3kpYogQag0WBWpfQSFkAVETYwaGw2d9/hg0VIh9QThPKoTBBT9bUs0Nb2vKZ2gKDRFNWW72fDQSPbmmE4dsY8Vm65D2jm9Hai1wcQ9U7GiLgdKvWOuLdoYBjFhZQ1R7fBdi5dzBDXCgm8brOtBRmbzGcfnx5i5IWpLFRu03TDxOxZHhkrNEfGE/i5gvaBFM0yf0lffwPICc1tgbgXFGsSdhTXEbUCElhDTAE0IjxCR4H1iquS457DmJYl3D+p+8OwcrRX9EHJcxti+5SBBSsYCmT9I+ncIPqtkyYPN1IhZipzcYgQboBuShbrWBlkU2eVaEqSi73oMaUnBu4AuNKaq2a639G2LMMl+PkaBsw6l02JNDOPsB4RKeL4Qoyt1+jn6/YqNEESZmAYiRnzfYG0P5NieHGGMwTlHQDMMDuEdx0dztExJtFk/MDRbJJFiOqOoKozRSJEs20uVhKmS61F6Nw6C65mbG3wy6B1hmnSPI2lm+nfH9suXI+bnRDfw2cd/RbNu+Obv/hPqowU//8Ef8Vc/+EFqW7xLtC8h0LpI4HsIOGfzAwfaqGRkKRQhpAcxBo+PDnJr7Z1js+/4xcsVXzfHvJhNsO0aoxTnRzUPmx1aJOzofK6oFQQXmE0N9bRESk1RV4BDiSll06GUo+oFnoAVaWW1qioKXHa9jbSdRRDZdQPIgrKuEcWM21XP7f3HGCm4XXV4FKvtliA1KKhEIDjL3Wrg+PSUTSP47OoeU5Xc325xpx6hNLshHSgh+IPlh9bpIIoSVNancM7lByyD9T5mzHfc6X53l5CKh/3Ax2/uePnqFW4YUmWdJQeTrXQeggqZbUneOr3lmIhHzCEl4eAlCEMIBusl/bAnSEuwYJxGU1BgiEOgv9shKk2rKu61pggVgkBTHnPjDate07sjwlDiVh26FaAFVgdmleXUX/FCPXAhX3PhHtBRstELXocj1sNT7rcb9u6UpnyBtBVD2xF9A0ZSHU2RlcRUjrqUmH5LFfaE5o529Qoz3DFFUsxPaIsZ1+4ZvThlK07o7w3qJYQ3gbk6YiorNtsrwrAmsAd6YrS5+4sZKko2NRAzVYtcdb7jwAJSKh72lo/f3PLy1esUW+8ZtT3Sso7MsRWHFjlmXQzkSIbSj/CHSM9jwl1Thdu3HcFZghIYWaCLgqIoiQH6Zo/QBTFKgk/FRIgFojqCUOD6Dpm9AkUxxQNCFY9+gt4hdJI3RaSlipAFc2zfEcID1kXcfI4qDEPfEfsGpKSaTtJsRESE1gx90kXYNQ3b1Zq+tyitmZ0c42YTghvSfVAquytCjI758ohpXbG5uyG4/mC++kgXe9S9HgeSSeT8rQPt77i+fA1YJIxn1+z59PNPuLu/59mLF9zvrkgUXI0yacIu87RTKEWhDFIIhtgnO29SkJ1zJMuOLCooMgYSAr21OO+Yzmp+8dkbpiXUGj7bbPjg6Snn7xtW2w6hNUEqhhAQMTI/nqNEROiCojJEFEidsZWewTsCisE6CqMR0WNkUsEarKV3aUhko0BqhS4MP/rFJS8vV7z5/DXX9yt8jEwKwXvnJ8wWE4qyQgWHR1IaRRsqPrq8h2B5/ekDVRGZFVO6rqWqJ8nqJAqQEkUSwIk4UrGfOgKdLdhH6E0w6tz+//AG/h3X7a7jo1fX3N/dMfRZNOiQBPKUPRPjRYY80pXNCjOzQYh0YEgkAk0USWsgUOBlIIi0F+97y/Zmw8RNMCwQBnzjYQbV0ZwheB6ExNqBQVfcKsNu1yD7krjVyFWNXzvCNBKXUNaWc3HHN+PHXKyuMJ94hJNMn1wzPTHcTO4QwfFgLbu+JuxKQtcR1YAuBfWsRGBxuz0+SrR4QPZ3FHZN6TaE1TW2cUmaszYEMWfrpuy6mnAZiZ96xKvI0bMJXzs/49L2XL+5p+9agu+IcSCODQMhLcOQXRqyd14YV7T+/xHbEdqIpO4lm54+xjY9ZCG+tZ0mRl7tWMGR5hKRxGIYeeTWsd3vmUwmGJmm/aOFVz1bps1UUdI7BboCLfBtD8LgkUg9IYQk6i9kVuQTaSCu5KhHEnCDJViLi6lwszY5CQuhCLYjhgGtBEVVYz1stw0upJlS39s0MHOWdvOAVBpTmLzcUWCtReR84oRHxMDRYspXnz/lalJyfXlF3+1SsRhjPkCzhHsYmVgqxzZmg4Jfs9JN1Ytlu13TtC2b7Z5X1284Pzvj29/+LV6+esn19T0+JBPJBB+FrEGeTg+l0kpryL5qUqoclEfx7G6wfPb5FbPZhK8+P+FPfvARn79WvHdeo0Tg6nZD9WLJ+dkxQZZp5U/WaJlcDfA9ZV1TVDXeWyKWIni6PrEihgDzqaTdjp9N4odAQKKUZ9fYBB1UkqH3fPjzzxPpu9tytigY+oHbVc+utXzvOzWzmSL6CLLECcN9K2m6nt12x2dvbvjeN47xzRZLj+Ccuq4g3xt0MtSLPoCSuQXMlkhSZrPPhMFFn5Xrf7337++8Sq0oS/2IU8XRJFAcKDwp/o+DF5E1WYFDRR5jROQEjdAQNcgSYRTROaROWF7UBV3n6NctRhr8JIKWsFOYskJNChob6RUMVtM+DMRrCUOBWGvivU//XkTCV6AUlqf6ntOHN8i/9LQ/hOgi6qJl+vf26G9ausWUK7Hkzvf0G0vIm2FFIVjOSqaiZ1lHRPeA694QwxXD5pJpd4+JFr93oALMBVYUNMxga1A3EfkmIu7uuB42nJQf8MGzihAqXn3WEmOf/MDy8FaMmDhv6S9kAWzeMSvlMbYqU6dIywwZSw4HEJJHWCGOCfbt2OaKLvoDm4bsRjHGXQqBLmtijHQh0HctRpd5qK5AaIypUaZmcBJPhQuC4AWgQVc5Z0hETJ834khqhDpV51KmxSIfk09a9InxMIpHecswtIl14x1GSybTKUJKyrqk6QaGbksIge1mi+9ahCRtrEWPNFlBcewAxmG/t1y/ueJkPuOD508IkRxbd9BDlvnPCSGyv9ujquBIk/27ri9Nuvb+M9a3r3i4u6cfsujFEPn81SXThzXPnj+hKAwvX98QSXbrWiUw3DubaRgir7smF9z0wCmGoU/VqHe8/Pw1L6/XfGf6jGUlOFmWrLcN719MeXY65dM3G3ZNzdB5pOzpZImuDaJYEG1LUc7R5SwR8dkiZMAFxWbdoUUSOD47WxLkHpBsuoAIlhDACFhUAusTrrXe7InRMqkFX3vxjFIE2u2GpycTUCVaZqcMXSKFZtvCarPHhcD9Zo8xgtOZIvZblC7ZbyVCniVNCdIDKfLDmx7ykBSOEBmw92kYBSCT0d07hnSZlobnJ0fcXN8lOxwBMSYBFnVAcJN+hhQeL8ZBy2NlFKODqDPmp1DSEEJF0BpRC6QD4SVCgzEKXR7R7VZsblcUJzXUgthEQhXRU4XQil5r+p0l3DpYl9Bo5EogH3LidYbQgO0dpdyiHzzhk8DLm4jXig96RXEsqZ97FosdJUPixdpIlDERaZyj3++YCcnieMJiVuOuArubaxZux77Zo1ygrpK4T09BK6Z0YYpYR8Q96G0H7hWb+4YPf/Q5D8+fUNUlpgDvUnWfho3pTo6NwlsNw2+CuJBiW2ienxxzc31H3+XY5mZXZUeWNKhNDAV/cOcdefPiwOMdqW1KCkKQh+m8zLY6QkqMFGh9RLtZs1mvKOop5L+fINDSILQhRpOrVQ+qAqGRMok7JVEoQ4wwDB1KxkyVDDgfMUYfpFHFW+/PodDLXVr0jn6/RwiYHM+ZzQzXVwO319c4F+jaBgEUZZEKibwFmnY9AkKCJoId2Nxf8uGPeh6evUc1mWCKGm9tjm0uTA6DyVz3jgfXr4jRlybd+6tf8Cf/7l/x8LCh7RP24UPyjx+2W7Y/2/Pk7IzvfvtbvLq8Yr3aYm1SnCKCjB5pdPLZUibTxRJmAknm7fLyhtv7HUoJbN9Qm8islHy27nh9tWU20Xz9/RPO5mlN9dXtQLsveH4+4/R4gVQzZGHog0LpSdqTdoG+37DZOo6OS6aTiroueHZu0gaa3+OkYP+QHCcGAbURNN4hZaQwFXVRsdl6Yhhodz2zyvCVD45QKrVJuqhoekvrAnVdE8OCly+vee9sysXRlIe7NU3bMzk22K4hapOYGdlifVyMGHWMpEjC5yO2FmLiPOev/r97837F1Q6O1zcPDH134AOnEz+v8OYljRhD4juPWJ+Qhxcx1W4SIQxCGEIoiEITyoiYgPARvMfUGlOlTcBQ1tjW06sOMyvxJiDEQNQVQSX9higEEYWuamSrUKSFAh8DsdfQCFbhhCtOeH56TfGi4ey1R0UwTwXyuaA/mfEgj9mFGbYFWg8iKWTZjac7NwzFEXdOYWWNF2dshmOKXcNSvsdxseOkbgnS8HP/Pi/lC/xwhNlIZBMQfUMIDUIM9O2Gl5/uKasS8FkUPjEDwjj9ZxQOGldJ35p8v+OrtZ7XN/cMfYL2okhSh4kjn7fISEMsPx4KchTHSV9nz+9DJZfWsUNmDCQGA8FjjMIYQ/CSUNU4t08VbzFJ3ZztiWVNIN0PYiBKiS5rpEqa2UKBd4GYSezRS4IfIJuyBu+TG/ZIW1OamJOu9w68zfKx6cCLhLSK7NK8SIuIsz3tbp/YF0pnKp9IB6SWaQgvIpIk2p6kKKFv97z89GPKuspDxIzfhuSNdojt2BDmgdsj+PC3X1+adAfrWW22dIOjd+HA5TMq4UHN0PPpq9c86c44PzkiOsv13QbrfLYUT1sp6c+Jw8kPoHTBfvfAm6trVjtHBLreURvNB8+O8P6e1W6HEDVaSXQ0TEtDVQxsu4HL+y2qrJnMDH2j0f2GZQfHT04Je2j3HUWVkpnJfNzVpqOalOiioFTwXECIno0VVBL2LtB2jhjh888/5WhRUhYFhEA/dFT3HadHVSLhO007OIyQ6EJT6iOePjnhg2czylmB2TSUw544tES5J8ijZGljPV4JlB4ny4lm4r1LyY+IED6ZWIqM7f7ar+Dffn1yecfV1c0BowIOmz5SpYWWEQ4aMWYZ01At5gooJeW0eRZJWLqcCphE4iRhcL1YoXVFuTjBo+iio5jXWOMZzJD8oKRDiRphdNrckslnTHcGoZK4EkIgdFrO8G1gHy54Vf4WL8yK59/6lPp+wFgJ31H4r0quizOu4zkrN8XuHH5vQQRUFOhWUjSS7i7wZhO4qyV2X+Pk+zgnmMQNpzKwEB1eVPwifJVXmwXi0lHea8L9nn53j1IeZ3u8d9RVzdAlJaxEFkgVI6TqaWRuIWO2LsvWL7+BrDvG1ntPyDKFSigEGql0kg2Naa4QgicSUDHCCBeJeDhwk15swvClyodtCDg70O1WaD+hPD7BB0nX24SnusAw9GnAKhyqqBBGQUhdnCo02iR4Suu0eisyQyD4zGF3Oq2fhzQDSmvlMn/GVG8HZwHwbkiC51qgtaRQAj/0bIY+5ZjNCi0j3g3EGKjqGhwEnQoa21tETFoioW/omw0qS4F676krGLqx6HlrizCKJMAjRMZ48y/HcLD1+buuX5F0LcPgCC7xHWNItBcfQg6kxOO5vL/nfv3A8mjB2emCzbbF+/T7fEgbTD5EiqJKL7oPDHbgYbWitx4pPev9wOWtomlKjPIspxUvLgpmxvOw7tntG0SMVIVBqUBAsNpZqpnhft0wlZL+fk01nySh7RA5PlnQNUNWJBLsekfQRcbXJIv5jOA7usYSC4nM+pz7fcfFxRGFSrQu72HXNHTtCn/yPq3T2KFBk1xDlSmIMfLd73wLKRWddLTxgUhHHAZMZRn6PcOgmE+nCJke+tHKOcZAcANxpPgImRZThH6ka73D6269wjmLiOHgXBpJVJqkLJUGA4HseopIsEim8ISYKqX0+ChiNGAUsQYmJI0FZREL6NhRmJpQFHgXCQyUp0tsOcHrAV1H5ARiGfGhRyqFnhSwl0iVbegRCJWl9BpJ2E25nH7Ap+Ke+Ysdi7//BgZB+IriZnbKq/iMK3/CZpgQmwCdR4iAUgaxg/0nt/T1ltYOdHZPMA5RRIR5QVl9wFo5psZho+GuWRKvDeoyIq5a+qsHYhgYuh3WdsyOjpO8YFRI5Dj/zjhuyJVQksZM1Nd80B6KkHd73a3WiQkTszpWTHKSUmmULBFCIYXOMouJT5wU0NI9CvHxIH47yYz/9iFZbUkJXbOlqGqCKvExEvqOcnaELcFbh8an5RDh8T4JoptSpc00Akon1wUhFKIwOJvEsiIgs1QAIQ3dJdl7TIbMiMhSkzFprShlECKyf7hjaHa07UDX7NP6M8mqSJoKbZIrcUDgXUAalfBZ29Lv1kQhGfYN1g7Mjk5wwSOjfFyEYKSHjWdszIWI+GJsvyRGX5p033zyU/ohbX1lmDgR+EdCsZSIGAkE2sFh71ZMJxXL+ZT1ZpdAbyGJUiQFdmlARYbecnt9y9XNCqU1C62ZF2CHPZ9c7vjGBxdcHAtOZwYRBj57tSHKgvfPK653LecnM6QpaPrIejegJZhJhRSKu02LERJRVAQhqOZp1VjoknIScEhmJ8c8POxw1nO6mHEcIvcPLbKNDNYhpeTkaMnN7R3feP8J1zf3TI5nnEwMMwNd36NESkhKglGa6D1CBmLwNNYj5hfsmpaytxRhoCpL9kNg37ZUMVKVWYM2xmwbrfK0OFUTqTsImUv5bkdp88kMoxTr1QqsPdCYEuacGuHR1SOd5DIvUWRhkpD4uaCJ0SBkQSwFogZfeTrVUhxpprNjVnevWbt76uUZUhmGtkEVPcXxjFgVRNEhqojSPq38VgWUGicjSku0TFrMQfm0dLHX8BC4mx3zUf0Bddnwza82VFhWs2d8Hp7ymve4CSf0jcZvLGE/HGhw6MD+4Q6hJNvdFicCUUEQDlMXuOMj4skJTamJThCvIuo6UtympOubBmdXNJt7zGwOsqR3adW30DoNkbKzchpeJbpWFAIRRr5nfnHlu8+68+kMrRWb1RpvbeJUoxGkzxbQSFEghESKZA+vUrWRqsi8ipu+jhx2JEgJt2tbCq2Zzo9Z3VyyfrinPjpH6oKha1B9RzGdE4uCOPQIUtIVCoxSKC1wIQnOaJ0ZABmrHTci7RAIMUk5HvjqhUH6LIkZHDF6QnAE26fYigR57Nf3SCHZbre4zCwIbsCYgmp+hKqWWf85URAjASNBDC3eW5zzNJs1ZrYEWdE7B1gKbQ6fJb0s4i2lQPLE463Yir87tl+adD/7+COcT/zM0d9LCcm46jZm/IRgBJzr2e4S104bjVQ+OwKnBBN8zzB0rDdbLh+2TKcTitjx6mpNXSjOz46ZWMkHZyX0Q+IBesdyqrhaO3RRc3Gu2XWSpydHRN0xnRSUWlOUBVVVEdzAMPQUyyd4O1AZz+ADXkw4OpkTkSipWcoZfdcwSMHspCbIDfu4Z+0LfITORt5//xmrbcfDtuV3vvWE7W5H++nnPHnvfVyoEr4rR5wuTVO9tRRFCfWEfvkUsb+k2XcUQVMZQwwDtm0hLCirOmGkmdcX/JASndaHaiOE5EDxLq/76zumsxknJ+esN2uGdp+n7ONQIq81jiugucoNpIFbErzREFQaoApJLMAZz86t6dWe6ekSJSqUmNC7BlMNmGXNsNnSqy3CKIpJhSpLTCkxwqKMBxnoZECpJDJdSEmUAStcolitFf4y4AvNy2fPqI6LdLjaNfc84zIccx3O2A5LxE5AH4hD3ugLkX5oaffZUbasqeo5wQr6vkOuAvZNjzsOqFoSh4DZCFhFxG1Lf70l+B1Du8J5i1EF3RAOVDAhQGf507ENTqaQiR4W5dsv5Lj5926v++vbHNsT1pstQ2sRjPoHEiEKYtSEqHJsJQJLGIXqhUwwTwhv0Z8ELnh2mzX9fs90cYwqK1RZJwx36DFlydBIumaTaKNljSyL5GNGoDIyL0eFbG+eoICIYMj2VGQ5yVThBkxdEUSVsOEs/kRIVLUgJURNJMc2Rvq2pW1apNLoqqaq5oQo6PsGGQN26CmcR+ukVmh0wn2k7RLdLwSGtsF5h1GGbkhD0RAiAofW+tChRGA0/CSmWUTqBH91bL806a4321zSj9sYIlc4+RWMoyJVyGB9GrRJqbE+BUsGRwwSF3tESP5Hm11DWRiwDc71nB2VPDSSUJ5wPnMUfoePEVNoVvuWs5MF5Vwh6xnLWtE/tIQoOT0+oipU9k0yKKGIIhlgSqnwxoKEeV0jpEG5dANjAFMU2KqGmNgDqlggyw36fkcXBM+fnSCi4rPP7/jm19/jaDnjznr2uy331294+vwFVtQpAN6m1lypBLKH5F4xXyzZ2I6rm3um5Yqy1BTGJFk6IkqpJAwk0uT4baK6zLhpiP6dU4uGocetLFVdM58taKRk6BrEuC2IyLS1NFwbT/DR7yAdFAKETjicAcpAG1sa9oiJw00iQSu0rHHNnlAPqHmBmS7wvkHMJQMtct8incLUJdpISlHgpEIagZFQxnTAB+mSbdFK4UKHLBS2WHB5fIqrp5iyYWVrVrFgvzeEe4vYKuglMlRge8IQ8NLx/2nvTJYsOY4remLMyDfU0GiQkEwS9SNc6tO14y9wIclgMiMFdNUbM2NyLjxeVQskATNao1fv7qusKj3Tw8P9+r3J7PE+EUuiXQ35WrCLZZr2RGOxPzqM6UQBswhyutKvryBHpL/S2hUXIn7e0USdZPWK2UnhtjKrvVyjzGxuLpEi9X3t9lfo6ea8UF8yKW1GbFfy0jHi6RKwBFr39O7eKj5dRbefxVb/3vdNSMP1snA5nzHSqCJ0HD7O1Kvq9Do/ETYPtOUC1nBdFqRk/LQS5j0uBIJzQ5DGE5xhskZdXyyULlAbdVmwXtkw0zTRvaXXmd5WaFVHfC1jnC5v2DhBz0PPpZF2e3xMxCnRxLCuRa3et3uiU6EjQyc6LRWlFR3cGaWttdZxIeHTnoYbvWDBmkpiUOqsHbF95zBj3vV2b6yKv4efd45o6oDZWqNhVMlnaMLKZ5WRQxBzcxgYp3wdH63zb1UTvfHycqDUTq+V9VJ52m+ZNw/YncX7QApCrnpVO51WpnnD62qZ90+In2hN+PbZk6LFB4P3Hu8CvXdqWYe3mB3T0YQglNJIacM8O9U7aI2cM9MUVPe3FaYYcS4QYmJphRQjf/rzK7/7lw989+1HRDprc6Q08+lw5enhhW9+k3g5K5/25hLqnR3LBhCdYdo9w8tCbiuTaNIP3hK9GapKuj8uRjWI+1CiAqVwafXxpb9Obfafz0eW65XHp2c22w2HF3UWaK2O/v1Isk6tgwwG6wJKM3D0rnrA3RtWWTnnA2wbsjG0qUPy2DAh1rFwxNNx+0DyO0KMUDPttMA105qH7RYbNwTjtX2jRrpEA92puEk7GSgV+xRxc2DdR77/8K/42bIcM/VQsMdO/bFhV4dcK6Z6ZM06WHKWXhq1Xsn5DNXSs6EtQo8ON88gCz5C8I1WF6ScMHYhJZXkPB8y6fGZmHasS6HUjrGRbgK1D/NE+ezaafSZv4ktCIgRfhVjSrRAOl9OLMvK49Nv2GwTh5dF/88hbaDC+WBcR4mCdmihKPOoDzkV6bCuC+fjK7SGmME28B4Tosb2csR3wYWJsH/S1l5Va/d6Per3td0Tp0QwaA5pHTGBGHSw16rQaoFWsZM6OBhnoTnCFFQxzkeM6+RLGQtWuhwx6Mi8OQu3K/l8BWvGMkenB4ebNkDHW+3rtlbHIehIyY7YnjS28451WSm1YaynG6ttEWuwItz20sxIvp836N896v42flm+aqwvarU7+LYGnLFaFXkPNzFg7+i3U9/qy9eNIVjVMD0cD7wcTxxOC+V6IQWo7hFnt+y2SlouayVfV5x3XM6FD7990q0RicjSeNhvSNHRWhn8Oh3wWes+qyLQtoZVA0Vj1fDRWTdEbzrBq1aw8055iNLxwfH8/ERHmRTfffPIdr/B0fn+f3/gvFQed4lp7pTaqC2r9YuZcG5I45mOjwFpQiuZ/Tbx77/7Zz69HDgdDiQMbhWs67rjHSIAzmqLobaih5oZe+gC9rY6+oVwe0a1d0pdeX35kXmzIaUZEJbreczzxrN86zEzvsbbEOh2qguX64WSFnrJ2GrpUrAmEFIiuY+U9YBYoTcVocbq2MmEAMuF3jrl2jD+EUOEfKEunnLMPPQJNyg+rTbsJmKKINVAhvVUEB/UOLUI1gTitKcXoRsQGuAwrQ4rGcf5cCG4Gdc8/dqQbMiXV2Jv+ElnFaYWpFxB6nhuVm8Hz09Muz0uWFpxFBcoTShNvdj8jQHQBTF9iD6Nhz+upr3pcOhLwwy/Oo1t5vXlE/P8gZQ2QGO5aEFgnBqOamw1ltxchMefZTFU6VzOF12/rVXnOa1gfSBOM/3pI+V0QIWZCrZ1nA0YwIVIXc60VsjXEzFYcA5ypYqjkHl43I3YaqVqY7zd3UHQleEUsEa1vqwPxM2eTh9UtuFmcrMJsoHz5UJIGy1iRrsin16JTvDTpOVDrUitg9+lrZaU7E9ia0dsO6WpA4wzg9XRhy2SfefqMpg++hj/wZ7ud//2W77/7z/pxFMY7rajxyhCL3WcJn20FkbP16jVohomqHZsrZ3/++HAlCLLnz+pFfrDR0IMo2p1XM8Z74UeHK+HTJwnstlCmAhG2EyBGDRJWqtVqnQGnaWjAwPVcbCWYQU0NqUFPRCaXjfwgKi+rwuemgtTnAadppP2kVwa65LJXVjWC/Nk2e62+G3i6WmmiyFMEaUVOix6MFnR3++8wxiHt5ZNmjg/PLCsWV+YuMHakfCHm4RBIyZ0Wm3j5/nZU/MfQu+jB6XvXGuF0/EV5z0xRiRthj22jEHBeJPodGu0jTN4i10667pSJGNmjUKrGXM546RC0Gts3D7gdrPu0ecztVY8unrp5y2Slbje84JhS81XTIvUrFbqzvW3AeM0T1TK2LTSd6znBcQrvUyEEAItQnMqqWicp68Z7wJlLczbHbY76qXhYySvC1UMpXWSNdheKE0Xgqy5uXwYrIt8+PCNxsVUMpW1F8RErT2cU1twW/HBKgXubezN6AfK25T+i+P/xVZoLXM6veJ8I8QHfXYFxh6/Jti32Kpg/ltse2Nd87Bih260GjWXM65UsMrYiNsH3LSh9WHTU+sYeAlh3tLyikG3yvycqOWqhVQz5DUo+2fcrKY0UfP4RkGdlPMVxlDNIIQYqKJi//pOeHpb8D5QStbYOhW88XEirxeqQG6dZAXbK6UpHdKOdoGzWuk/h49ayL3FtiLGjdhaHbQbfWew7j223FhAGtufG33/bNL9/e//gz/84T/5rz/+D6UpDavLqL5QwYe3tT8BQ8X6SXtErWplOQTLP728glTyUolWdG133jPHQJpU/HoxnSkGlkUTjQ1bmpnZzTMOJUmHELUPO/ayO12Fyl3QQ0HABkvrem1wNlJrQdOBJkGrDRmlIJl3+xwjglS9V1nriF51fC/XlX/69iNIpdcrU5oI0w6phTVnWoPJqtJS8H6cvHIrCglWlc3mpwRGBaJvlBfnVOaxVEPLqsEK6P9o4hiifeGkO0jwxgzfihvxu2R6q4Q44ZIOSbTHfLtG6UXUGV39bUWtWs690B8yYJjmPTkWcm3I8RPzww6/3yMpYlNC6ko7/oD3YFKCIlgsYbsnmMZSizrKooyJKVr6caW3BWc63hqs0YPytg6aUiSXA5MPED1taK16PyPzRF4aUnTxRJoO6aaYuLyc2OyekMVQXSVMe0yYMI4hp6nPvQn4cVsyoiuuoIJHyQvZdZZSaGOz0Dinfcfaleo21ksHwUiHN182or8Q2z5ieyHEPW5KLMuNsfD3YtvIa+F8Or2JwkzznlwquXZk+cS83eHTI+IjNiTaWqjHF7x32LSFfMVi8ds93gi9FlpWCpvzhuTUIaJLxxl5j20csTUjtscD01bZMq1kRAwhJpgnsvwkttYypcTldGbz8IyIUGsmzHtsmDEuUOv6k9ja94H2uLlpbPuIrdCspeO1XdoKphaGKqyudJt3+tgvxdb8lS34HXfccccdvxp+Pd+QO+644447/gr3pHvHHXfc8RVxT7p33HHHHV8R96R7xx133PEVcU+6d9xxxx1fEfeke8cdd9zxFfEXGqT7xIalkkgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/catdog.png')\n", + "dog_cat_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_cat_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# cat - the predicted class\n", + "cat = generate_visualization(dog_cat_image)\n", + "\n", + "# dog \n", + "# generate visualization for class 243: 'bull mastiff'\n", + "dog = generate_visualization(dog_cat_image, class_index=243)\n", + "\n", + "\n", + "axs[1].imshow(cat);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(dog);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tusker-Zebra" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t101 : tusker \t\tvalue = 11.216\t prob = 37.9%\n", + "\t340 : zebra \t\tvalue = 10.973\t prob = 29.7%\n", + "\t386 : African elephant, Loxodonta africana\t\tvalue = 10.747\t prob = 23.7%\n", + "\t385 : Indian elephant, Elephas maximus \t\tvalue = 9.547\t prob = 7.2%\n", + "\t343 : warthog \t\tvalue = 5.566\t prob = 0.1%\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/el2.png')\n", + "tusker_zebra_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(tusker_zebra_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# tusker - the predicted class\n", + "tusker = generate_visualization(tusker_zebra_image)\n", + "\n", + "# zebra \n", + "# generate visualization for class 340: 'zebra'\n", + "zebra = generate_visualization(tusker_zebra_image, class_index=340)\n", + "\n", + "\n", + "axs[1].imshow(tusker);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(zebra);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 classes:\n", + "\t161 : basset, basset hound \t\tvalue = 10.514\t prob = 78.8%\n", + "\t163 : bloodhound, sleuthhound \t\tvalue = 8.604\t prob = 11.7%\n", + "\t166 : Walker hound, Walker foxhound\t\tvalue = 7.446\t prob = 3.7%\n", + "\t162 : beagle \t\tvalue = 5.561\t prob = 0.6%\n", + "\t168 : redbone \t\tvalue = 5.249\t prob = 0.4%\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = Image.open('samples/dogbird.png')\n", + "dog_bird_image = transform(image)\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "axs[0].imshow(image);\n", + "axs[0].axis('off');\n", + "\n", + "output = model(dog_bird_image.unsqueeze(0).cuda())\n", + "print_top_classes(output)\n", + "\n", + "# basset - the predicted class\n", + "basset = generate_visualization(dog_bird_image, class_index=161)\n", + "\n", + "# generate visualization for class 87: 'African grey, African gray, Psittacus erithacus (grey parrot)'\n", + "parrot = generate_visualization(dog_bird_image, class_index=87)\n", + "\n", + "\n", + "axs[1].imshow(basset);\n", + "axs[1].axis('off');\n", + "axs[2].imshow(parrot);\n", + "axs[2].axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.6.9" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Transformer-Explainability/method-page-001.jpg b/Transformer-Explainability/method-page-001.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2274140d55ac5f9eddb249ae188e185003abd156 Binary files /dev/null and b/Transformer-Explainability/method-page-001.jpg differ diff --git a/Transformer-Explainability/modules/__init__.py b/Transformer-Explainability/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/modules/layers_lrp.py b/Transformer-Explainability/modules/layers_lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..0724c3bc4534dcdd4a402c294d4d3a9d45ddbe00 --- /dev/null +++ b/Transformer-Explainability/modules/layers_lrp.py @@ -0,0 +1,335 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = [ + "forward_hook", + "Clone", + "Add", + "Cat", + "ReLU", + "GELU", + "Dropout", + "BatchNorm2d", + "Linear", + "MaxPool2d", + "AdaptiveAvgPool2d", + "AvgPool2d", + "Conv2d", + "Sequential", + "safe_divide", + "einsum", + "Softmax", + "IndexSelect", + "LayerNorm", + "AddEye", +] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + + +class ReLU(nn.ReLU, RelProp): + pass + + +class GELU(nn.GELU, RelProp): + pass + + +class Softmax(nn.Softmax, RelProp): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class Dropout(nn.Dropout, RelProp): + pass + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__("dim", dim) + self.__setattr__("indices", indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__("num", num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__("dim", dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + ( + self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + + self.eps + ).pow(0.5) + ) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * torch.autograd.grad(Z1, x1, S1)[0] + C2 = x2 * torch.autograd.grad(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] + - 2 * self.padding[0] + + self.kernel_size[0] + ) + + return F.conv_transpose2d( + DY, + weight, + stride=self.stride, + padding=self.padding, + output_padding=output_padding, + ) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = ( + self.X * 0 + + torch.min( + torch.min( + torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + H = ( + self.X * 0 + + torch.max( + torch.max( + torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + Za = ( + torch.conv2d( + X, self.weight, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + L, pw, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + H, nw, bias=None, stride=self.stride, padding=self.padding + ) + + 1e-9 + ) + + S = R / Za + C = ( + X * self.gradprop2(S, self.weight) + - L * self.gradprop2(S, pw) + - H * self.gradprop2(S, nw) + ) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d( + x1, w1, bias=None, stride=self.stride, padding=self.padding + ) + Z2 = F.conv2d( + x2, w2, bias=None, stride=self.stride, padding=self.padding + ) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R diff --git a/Transformer-Explainability/modules/layers_ours.py b/Transformer-Explainability/modules/layers_ours.py new file mode 100644 index 0000000000000000000000000000000000000000..dd2beaca8847bc3eb8ffa61f3156e71af8169f79 --- /dev/null +++ b/Transformer-Explainability/modules/layers_ours.py @@ -0,0 +1,356 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = [ + "forward_hook", + "Clone", + "Add", + "Cat", + "ReLU", + "GELU", + "Dropout", + "BatchNorm2d", + "Linear", + "MaxPool2d", + "AdaptiveAvgPool2d", + "AvgPool2d", + "Conv2d", + "Sequential", + "safe_divide", + "einsum", + "Softmax", + "IndexSelect", + "LayerNorm", + "AddEye", +] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + + +class ReLU(nn.ReLU, RelProp): + pass + + +class GELU(nn.GELU, RelProp): + pass + + +class Softmax(nn.Softmax, RelProp): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class Dropout(nn.Dropout, RelProp): + pass + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + + +class LayerNorm(nn.LayerNorm, RelProp): + pass + + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + a = self.X[0] * C[0] + b = self.X[1] * C[1] + + a_sum = a.sum() + b_sum = b.sum() + + a_fact = safe_divide(a_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + b_fact = safe_divide(b_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + + a = a * safe_divide(a_fact, a.sum()) + b = b * safe_divide(b_fact, b.sum()) + + outputs = [a, b] + + return outputs + + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__("dim", dim) + self.__setattr__("indices", indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__("num", num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__("dim", dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + ( + self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + + self.eps + ).pow(0.5) + ) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1 + Z2) + S2 = safe_divide(R, Z1 + Z2) + C1 = x1 * torch.autograd.grad(Z1, x1, S1)[0] + C2 = x2 * torch.autograd.grad(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] + - 2 * self.padding[0] + + self.kernel_size[0] + ) + + return F.conv_transpose2d( + DY, + weight, + stride=self.stride, + padding=self.padding, + output_padding=output_padding, + ) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = ( + self.X * 0 + + torch.min( + torch.min( + torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + H = ( + self.X * 0 + + torch.max( + torch.max( + torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True + )[0], + dim=3, + keepdim=True, + )[0] + ) + Za = ( + torch.conv2d( + X, self.weight, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + L, pw, bias=None, stride=self.stride, padding=self.padding + ) + - torch.conv2d( + H, nw, bias=None, stride=self.stride, padding=self.padding + ) + + 1e-9 + ) + + S = R / Za + C = ( + X * self.gradprop2(S, self.weight) + - L * self.gradprop2(S, pw) + - H * self.gradprop2(S, nw) + ) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d( + x1, w1, bias=None, stride=self.stride, padding=self.padding + ) + Z2 = F.conv2d( + x2, w2, bias=None, stride=self.stride, padding=self.padding + ) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R diff --git a/Transformer-Explainability/new_work.jpg b/Transformer-Explainability/new_work.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99e31cd5c62dc8db5d31311b72fbd1f992e8816d Binary files /dev/null and b/Transformer-Explainability/new_work.jpg differ diff --git a/Transformer-Explainability/requirements.txt b/Transformer-Explainability/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..70785af19eb945cba188d6d4a7530a815ba29b0b --- /dev/null +++ b/Transformer-Explainability/requirements.txt @@ -0,0 +1,15 @@ +Pillow>=8.1.1 +einops == 0.3.0 +h5py == 2.8.0 +imageio == 2.9.0 +matplotlib == 3.3.2 +opencv_python +scikit_image == 0.17.2 +scipy == 1.5.2 +sklearn +torch == 1.7.0 +torchvision == 0.8.1 +tqdm == 4.51.0 +transformers == 3.5.1 +utils == 1.0.1 +Pygments>=2.7.4 diff --git a/Transformer-Explainability/samples/CLS2IDX.py b/Transformer-Explainability/samples/CLS2IDX.py new file mode 100644 index 0000000000000000000000000000000000000000..af5399c9778be19ecc5e940fe9191d6f9b71f7d6 --- /dev/null +++ b/Transformer-Explainability/samples/CLS2IDX.py @@ -0,0 +1,1002 @@ +CLS2IDX = { + 0: "tench, Tinca tinca", + 1: "goldfish, Carassius auratus", + 2: "great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias", + 3: "tiger shark, Galeocerdo cuvieri", + 4: "hammerhead, hammerhead shark", + 5: "electric ray, crampfish, numbfish, torpedo", + 6: "stingray", + 7: "cock", + 8: "hen", + 9: "ostrich, Struthio camelus", + 10: "brambling, Fringilla montifringilla", + 11: "goldfinch, Carduelis carduelis", + 12: "house finch, linnet, Carpodacus mexicanus", + 13: "junco, snowbird", + 14: "indigo bunting, indigo finch, indigo bird, Passerina cyanea", + 15: "robin, American robin, Turdus migratorius", + 16: "bulbul", + 17: "jay", + 18: "magpie", + 19: "chickadee", + 20: "water ouzel, dipper", + 21: "kite", + 22: "bald eagle, American eagle, Haliaeetus leucocephalus", + 23: "vulture", + 24: "great grey owl, great gray owl, Strix nebulosa", + 25: "European fire salamander, Salamandra salamandra", + 26: "common newt, Triturus vulgaris", + 27: "eft", + 28: "spotted salamander, Ambystoma maculatum", + 29: "axolotl, mud puppy, Ambystoma mexicanum", + 30: "bullfrog, Rana catesbeiana", + 31: "tree frog, tree-frog", + 32: "tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui", + 33: "loggerhead, loggerhead turtle, Caretta caretta", + 34: "leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea", + 35: "mud turtle", + 36: "terrapin", + 37: "box turtle, box tortoise", + 38: "banded gecko", + 39: "common iguana, iguana, Iguana iguana", + 40: "American chameleon, anole, Anolis carolinensis", + 41: "whiptail, whiptail lizard", + 42: "agama", + 43: "frilled lizard, Chlamydosaurus kingi", + 44: "alligator lizard", + 45: "Gila monster, Heloderma suspectum", + 46: "green lizard, Lacerta viridis", + 47: "African chameleon, Chamaeleo chamaeleon", + 48: "Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis", + 49: "African crocodile, Nile crocodile, Crocodylus niloticus", + 50: "American alligator, Alligator mississipiensis", + 51: "triceratops", + 52: "thunder snake, worm snake, Carphophis amoenus", + 53: "ringneck snake, ring-necked snake, ring snake", + 54: "hognose snake, puff adder, sand viper", + 55: "green snake, grass snake", + 56: "king snake, kingsnake", + 57: "garter snake, grass snake", + 58: "water snake", + 59: "vine snake", + 60: "night snake, Hypsiglena torquata", + 61: "boa constrictor, Constrictor constrictor", + 62: "rock python, rock snake, Python sebae", + 63: "Indian cobra, Naja naja", + 64: "green mamba", + 65: "sea snake", + 66: "horned viper, cerastes, sand viper, horned asp, Cerastes cornutus", + 67: "diamondback, diamondback rattlesnake, Crotalus adamanteus", + 68: "sidewinder, horned rattlesnake, Crotalus cerastes", + 69: "trilobite", + 70: "harvestman, daddy longlegs, Phalangium opilio", + 71: "scorpion", + 72: "black and gold garden spider, Argiope aurantia", + 73: "barn spider, Araneus cavaticus", + 74: "garden spider, Aranea diademata", + 75: "black widow, Latrodectus mactans", + 76: "tarantula", + 77: "wolf spider, hunting spider", + 78: "tick", + 79: "centipede", + 80: "black grouse", + 81: "ptarmigan", + 82: "ruffed grouse, partridge, Bonasa umbellus", + 83: "prairie chicken, prairie grouse, prairie fowl", + 84: "peacock", + 85: "quail", + 86: "partridge", + 87: "African grey, African gray, Psittacus erithacus", + 88: "macaw", + 89: "sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita", + 90: "lorikeet", + 91: "coucal", + 92: "bee eater", + 93: "hornbill", + 94: "hummingbird", + 95: "jacamar", + 96: "toucan", + 97: "drake", + 98: "red-breasted merganser, Mergus serrator", + 99: "goose", + 100: "black swan, Cygnus atratus", + 101: "tusker", + 102: "echidna, spiny anteater, anteater", + 103: "platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus", + 104: "wallaby, brush kangaroo", + 105: "koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus", + 106: "wombat", + 107: "jellyfish", + 108: "sea anemone, anemone", + 109: "brain coral", + 110: "flatworm, platyhelminth", + 111: "nematode, nematode worm, roundworm", + 112: "conch", + 113: "snail", + 114: "slug", + 115: "sea slug, nudibranch", + 116: "chiton, coat-of-mail shell, sea cradle, polyplacophore", + 117: "chambered nautilus, pearly nautilus, nautilus", + 118: "Dungeness crab, Cancer magister", + 119: "rock crab, Cancer irroratus", + 120: "fiddler crab", + 121: "king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica", + 122: "American lobster, Northern lobster, Maine lobster, Homarus americanus", + 123: "spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish", + 124: "crayfish, crawfish, crawdad, crawdaddy", + 125: "hermit crab", + 126: "isopod", + 127: "white stork, Ciconia ciconia", + 128: "black stork, Ciconia nigra", + 129: "spoonbill", + 130: "flamingo", + 131: "little blue heron, Egretta caerulea", + 132: "American egret, great white heron, Egretta albus", + 133: "bittern", + 134: "crane", + 135: "limpkin, Aramus pictus", + 136: "European gallinule, Porphyrio porphyrio", + 137: "American coot, marsh hen, mud hen, water hen, Fulica americana", + 138: "bustard", + 139: "ruddy turnstone, Arenaria interpres", + 140: "red-backed sandpiper, dunlin, Erolia alpina", + 141: "redshank, Tringa totanus", + 142: "dowitcher", + 143: "oystercatcher, oyster catcher", + 144: "pelican", + 145: "king penguin, Aptenodytes patagonica", + 146: "albatross, mollymawk", + 147: "grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus", + 148: "killer whale, killer, orca, grampus, sea wolf, Orcinus orca", + 149: "dugong, Dugong dugon", + 150: "sea lion", + 151: "Chihuahua", + 152: "Japanese spaniel", + 153: "Maltese dog, Maltese terrier, Maltese", + 154: "Pekinese, Pekingese, Peke", + 155: "Shih-Tzu", + 156: "Blenheim spaniel", + 157: "papillon", + 158: "toy terrier", + 159: "Rhodesian ridgeback", + 160: "Afghan hound, Afghan", + 161: "basset, basset hound", + 162: "beagle", + 163: "bloodhound, sleuthhound", + 164: "bluetick", + 165: "black-and-tan coonhound", + 166: "Walker hound, Walker foxhound", + 167: "English foxhound", + 168: "redbone", + 169: "borzoi, Russian wolfhound", + 170: "Irish wolfhound", + 171: "Italian greyhound", + 172: "whippet", + 173: "Ibizan hound, Ibizan Podenco", + 174: "Norwegian elkhound, elkhound", + 175: "otterhound, otter hound", + 176: "Saluki, gazelle hound", + 177: "Scottish deerhound, deerhound", + 178: "Weimaraner", + 179: "Staffordshire bullterrier, Staffordshire bull terrier", + 180: "American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier", + 181: "Bedlington terrier", + 182: "Border terrier", + 183: "Kerry blue terrier", + 184: "Irish terrier", + 185: "Norfolk terrier", + 186: "Norwich terrier", + 187: "Yorkshire terrier", + 188: "wire-haired fox terrier", + 189: "Lakeland terrier", + 190: "Sealyham terrier, Sealyham", + 191: "Airedale, Airedale terrier", + 192: "cairn, cairn terrier", + 193: "Australian terrier", + 194: "Dandie Dinmont, Dandie Dinmont terrier", + 195: "Boston bull, Boston terrier", + 196: "miniature schnauzer", + 197: "giant schnauzer", + 198: "standard schnauzer", + 199: "Scotch terrier, Scottish terrier, Scottie", + 200: "Tibetan terrier, chrysanthemum dog", + 201: "silky terrier, Sydney silky", + 202: "soft-coated wheaten terrier", + 203: "West Highland white terrier", + 204: "Lhasa, Lhasa apso", + 205: "flat-coated retriever", + 206: "curly-coated retriever", + 207: "golden retriever", + 208: "Labrador retriever", + 209: "Chesapeake Bay retriever", + 210: "German short-haired pointer", + 211: "vizsla, Hungarian pointer", + 212: "English setter", + 213: "Irish setter, red setter", + 214: "Gordon setter", + 215: "Brittany spaniel", + 216: "clumber, clumber spaniel", + 217: "English springer, English springer spaniel", + 218: "Welsh springer spaniel", + 219: "cocker spaniel, English cocker spaniel, cocker", + 220: "Sussex spaniel", + 221: "Irish water spaniel", + 222: "kuvasz", + 223: "schipperke", + 224: "groenendael", + 225: "malinois", + 226: "briard", + 227: "kelpie", + 228: "komondor", + 229: "Old English sheepdog, bobtail", + 230: "Shetland sheepdog, Shetland sheep dog, Shetland", + 231: "collie", + 232: "Border collie", + 233: "Bouvier des Flandres, Bouviers des Flandres", + 234: "Rottweiler", + 235: "German shepherd, German shepherd dog, German police dog, alsatian", + 236: "Doberman, Doberman pinscher", + 237: "miniature pinscher", + 238: "Greater Swiss Mountain dog", + 239: "Bernese mountain dog", + 240: "Appenzeller", + 241: "EntleBucher", + 242: "boxer", + 243: "bull mastiff", + 244: "Tibetan mastiff", + 245: "French bulldog", + 246: "Great Dane", + 247: "Saint Bernard, St Bernard", + 248: "Eskimo dog, husky", + 249: "malamute, malemute, Alaskan malamute", + 250: "Siberian husky", + 251: "dalmatian, coach dog, carriage dog", + 252: "affenpinscher, monkey pinscher, monkey dog", + 253: "basenji", + 254: "pug, pug-dog", + 255: "Leonberg", + 256: "Newfoundland, Newfoundland dog", + 257: "Great Pyrenees", + 258: "Samoyed, Samoyede", + 259: "Pomeranian", + 260: "chow, chow chow", + 261: "keeshond", + 262: "Brabancon griffon", + 263: "Pembroke, Pembroke Welsh corgi", + 264: "Cardigan, Cardigan Welsh corgi", + 265: "toy poodle", + 266: "miniature poodle", + 267: "standard poodle", + 268: "Mexican hairless", + 269: "timber wolf, grey wolf, gray wolf, Canis lupus", + 270: "white wolf, Arctic wolf, Canis lupus tundrarum", + 271: "red wolf, maned wolf, Canis rufus, Canis niger", + 272: "coyote, prairie wolf, brush wolf, Canis latrans", + 273: "dingo, warrigal, warragal, Canis dingo", + 274: "dhole, Cuon alpinus", + 275: "African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus", + 276: "hyena, hyaena", + 277: "red fox, Vulpes vulpes", + 278: "kit fox, Vulpes macrotis", + 279: "Arctic fox, white fox, Alopex lagopus", + 280: "grey fox, gray fox, Urocyon cinereoargenteus", + 281: "tabby, tabby cat", + 282: "tiger cat", + 283: "Persian cat", + 284: "Siamese cat, Siamese", + 285: "Egyptian cat", + 286: "cougar, puma, catamount, mountain lion, painter, panther, Felis concolor", + 287: "lynx, catamount", + 288: "leopard, Panthera pardus", + 289: "snow leopard, ounce, Panthera uncia", + 290: "jaguar, panther, Panthera onca, Felis onca", + 291: "lion, king of beasts, Panthera leo", + 292: "tiger, Panthera tigris", + 293: "cheetah, chetah, Acinonyx jubatus", + 294: "brown bear, bruin, Ursus arctos", + 295: "American black bear, black bear, Ursus americanus, Euarctos americanus", + 296: "ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus", + 297: "sloth bear, Melursus ursinus, Ursus ursinus", + 298: "mongoose", + 299: "meerkat, mierkat", + 300: "tiger beetle", + 301: "ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle", + 302: "ground beetle, carabid beetle", + 303: "long-horned beetle, longicorn, longicorn beetle", + 304: "leaf beetle, chrysomelid", + 305: "dung beetle", + 306: "rhinoceros beetle", + 307: "weevil", + 308: "fly", + 309: "bee", + 310: "ant, emmet, pismire", + 311: "grasshopper, hopper", + 312: "cricket", + 313: "walking stick, walkingstick, stick insect", + 314: "cockroach, roach", + 315: "mantis, mantid", + 316: "cicada, cicala", + 317: "leafhopper", + 318: "lacewing, lacewing fly", + 319: "dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk", + 320: "damselfly", + 321: "admiral", + 322: "ringlet, ringlet butterfly", + 323: "monarch, monarch butterfly, milkweed butterfly, Danaus plexippus", + 324: "cabbage butterfly", + 325: "sulphur butterfly, sulfur butterfly", + 326: "lycaenid, lycaenid butterfly", + 327: "starfish, sea star", + 328: "sea urchin", + 329: "sea cucumber, holothurian", + 330: "wood rabbit, cottontail, cottontail rabbit", + 331: "hare", + 332: "Angora, Angora rabbit", + 333: "hamster", + 334: "porcupine, hedgehog", + 335: "fox squirrel, eastern fox squirrel, Sciurus niger", + 336: "marmot", + 337: "beaver", + 338: "guinea pig, Cavia cobaya", + 339: "sorrel", + 340: "zebra", + 341: "hog, pig, grunter, squealer, Sus scrofa", + 342: "wild boar, boar, Sus scrofa", + 343: "warthog", + 344: "hippopotamus, hippo, river horse, Hippopotamus amphibius", + 345: "ox", + 346: "water buffalo, water ox, Asiatic buffalo, Bubalus bubalis", + 347: "bison", + 348: "ram, tup", + 349: "bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis", + 350: "ibex, Capra ibex", + 351: "hartebeest", + 352: "impala, Aepyceros melampus", + 353: "gazelle", + 354: "Arabian camel, dromedary, Camelus dromedarius", + 355: "llama", + 356: "weasel", + 357: "mink", + 358: "polecat, fitch, foulmart, foumart, Mustela putorius", + 359: "black-footed ferret, ferret, Mustela nigripes", + 360: "otter", + 361: "skunk, polecat, wood pussy", + 362: "badger", + 363: "armadillo", + 364: "three-toed sloth, ai, Bradypus tridactylus", + 365: "orangutan, orang, orangutang, Pongo pygmaeus", + 366: "gorilla, Gorilla gorilla", + 367: "chimpanzee, chimp, Pan troglodytes", + 368: "gibbon, Hylobates lar", + 369: "siamang, Hylobates syndactylus, Symphalangus syndactylus", + 370: "guenon, guenon monkey", + 371: "patas, hussar monkey, Erythrocebus patas", + 372: "baboon", + 373: "macaque", + 374: "langur", + 375: "colobus, colobus monkey", + 376: "proboscis monkey, Nasalis larvatus", + 377: "marmoset", + 378: "capuchin, ringtail, Cebus capucinus", + 379: "howler monkey, howler", + 380: "titi, titi monkey", + 381: "spider monkey, Ateles geoffroyi", + 382: "squirrel monkey, Saimiri sciureus", + 383: "Madagascar cat, ring-tailed lemur, Lemur catta", + 384: "indri, indris, Indri indri, Indri brevicaudatus", + 385: "Indian elephant, Elephas maximus", + 386: "African elephant, Loxodonta africana", + 387: "lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens", + 388: "giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca", + 389: "barracouta, snoek", + 390: "eel", + 391: "coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch", + 392: "rock beauty, Holocanthus tricolor", + 393: "anemone fish", + 394: "sturgeon", + 395: "gar, garfish, garpike, billfish, Lepisosteus osseus", + 396: "lionfish", + 397: "puffer, pufferfish, blowfish, globefish", + 398: "abacus", + 399: "abaya", + 400: "academic gown, academic robe, judge's robe", + 401: "accordion, piano accordion, squeeze box", + 402: "acoustic guitar", + 403: "aircraft carrier, carrier, flattop, attack aircraft carrier", + 404: "airliner", + 405: "airship, dirigible", + 406: "altar", + 407: "ambulance", + 408: "amphibian, amphibious vehicle", + 409: "analog clock", + 410: "apiary, bee house", + 411: "apron", + 412: "ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin", + 413: "assault rifle, assault gun", + 414: "backpack, back pack, knapsack, packsack, rucksack, haversack", + 415: "bakery, bakeshop, bakehouse", + 416: "balance beam, beam", + 417: "balloon", + 418: "ballpoint, ballpoint pen, ballpen, Biro", + 419: "Band Aid", + 420: "banjo", + 421: "bannister, banister, balustrade, balusters, handrail", + 422: "barbell", + 423: "barber chair", + 424: "barbershop", + 425: "barn", + 426: "barometer", + 427: "barrel, cask", + 428: "barrow, garden cart, lawn cart, wheelbarrow", + 429: "baseball", + 430: "basketball", + 431: "bassinet", + 432: "bassoon", + 433: "bathing cap, swimming cap", + 434: "bath towel", + 435: "bathtub, bathing tub, bath, tub", + 436: "beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon", + 437: "beacon, lighthouse, beacon light, pharos", + 438: "beaker", + 439: "bearskin, busby, shako", + 440: "beer bottle", + 441: "beer glass", + 442: "bell cote, bell cot", + 443: "bib", + 444: "bicycle-built-for-two, tandem bicycle, tandem", + 445: "bikini, two-piece", + 446: "binder, ring-binder", + 447: "binoculars, field glasses, opera glasses", + 448: "birdhouse", + 449: "boathouse", + 450: "bobsled, bobsleigh, bob", + 451: "bolo tie, bolo, bola tie, bola", + 452: "bonnet, poke bonnet", + 453: "bookcase", + 454: "bookshop, bookstore, bookstall", + 455: "bottlecap", + 456: "bow", + 457: "bow tie, bow-tie, bowtie", + 458: "brass, memorial tablet, plaque", + 459: "brassiere, bra, bandeau", + 460: "breakwater, groin, groyne, mole, bulwark, seawall, jetty", + 461: "breastplate, aegis, egis", + 462: "broom", + 463: "bucket, pail", + 464: "buckle", + 465: "bulletproof vest", + 466: "bullet train, bullet", + 467: "butcher shop, meat market", + 468: "cab, hack, taxi, taxicab", + 469: "caldron, cauldron", + 470: "candle, taper, wax light", + 471: "cannon", + 472: "canoe", + 473: "can opener, tin opener", + 474: "cardigan", + 475: "car mirror", + 476: "carousel, carrousel, merry-go-round, roundabout, whirligig", + 477: "carpenter's kit, tool kit", + 478: "carton", + 479: "car wheel", + 480: "cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM", + 481: "cassette", + 482: "cassette player", + 483: "castle", + 484: "catamaran", + 485: "CD player", + 486: "cello, violoncello", + 487: "cellular telephone, cellular phone, cellphone, cell, mobile phone", + 488: "chain", + 489: "chainlink fence", + 490: "chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour", + 491: "chain saw, chainsaw", + 492: "chest", + 493: "chiffonier, commode", + 494: "chime, bell, gong", + 495: "china cabinet, china closet", + 496: "Christmas stocking", + 497: "church, church building", + 498: "cinema, movie theater, movie theatre, movie house, picture palace", + 499: "cleaver, meat cleaver, chopper", + 500: "cliff dwelling", + 501: "cloak", + 502: "clog, geta, patten, sabot", + 503: "cocktail shaker", + 504: "coffee mug", + 505: "coffeepot", + 506: "coil, spiral, volute, whorl, helix", + 507: "combination lock", + 508: "computer keyboard, keypad", + 509: "confectionery, confectionary, candy store", + 510: "container ship, containership, container vessel", + 511: "convertible", + 512: "corkscrew, bottle screw", + 513: "cornet, horn, trumpet, trump", + 514: "cowboy boot", + 515: "cowboy hat, ten-gallon hat", + 516: "cradle", + 517: "crane", + 518: "crash helmet", + 519: "crate", + 520: "crib, cot", + 521: "Crock Pot", + 522: "croquet ball", + 523: "crutch", + 524: "cuirass", + 525: "dam, dike, dyke", + 526: "desk", + 527: "desktop computer", + 528: "dial telephone, dial phone", + 529: "diaper, nappy, napkin", + 530: "digital clock", + 531: "digital watch", + 532: "dining table, board", + 533: "dishrag, dishcloth", + 534: "dishwasher, dish washer, dishwashing machine", + 535: "disk brake, disc brake", + 536: "dock, dockage, docking facility", + 537: "dogsled, dog sled, dog sleigh", + 538: "dome", + 539: "doormat, welcome mat", + 540: "drilling platform, offshore rig", + 541: "drum, membranophone, tympan", + 542: "drumstick", + 543: "dumbbell", + 544: "Dutch oven", + 545: "electric fan, blower", + 546: "electric guitar", + 547: "electric locomotive", + 548: "entertainment center", + 549: "envelope", + 550: "espresso maker", + 551: "face powder", + 552: "feather boa, boa", + 553: "file, file cabinet, filing cabinet", + 554: "fireboat", + 555: "fire engine, fire truck", + 556: "fire screen, fireguard", + 557: "flagpole, flagstaff", + 558: "flute, transverse flute", + 559: "folding chair", + 560: "football helmet", + 561: "forklift", + 562: "fountain", + 563: "fountain pen", + 564: "four-poster", + 565: "freight car", + 566: "French horn, horn", + 567: "frying pan, frypan, skillet", + 568: "fur coat", + 569: "garbage truck, dustcart", + 570: "gasmask, respirator, gas helmet", + 571: "gas pump, gasoline pump, petrol pump, island dispenser", + 572: "goblet", + 573: "go-kart", + 574: "golf ball", + 575: "golfcart, golf cart", + 576: "gondola", + 577: "gong, tam-tam", + 578: "gown", + 579: "grand piano, grand", + 580: "greenhouse, nursery, glasshouse", + 581: "grille, radiator grille", + 582: "grocery store, grocery, food market, market", + 583: "guillotine", + 584: "hair slide", + 585: "hair spray", + 586: "half track", + 587: "hammer", + 588: "hamper", + 589: "hand blower, blow dryer, blow drier, hair dryer, hair drier", + 590: "hand-held computer, hand-held microcomputer", + 591: "handkerchief, hankie, hanky, hankey", + 592: "hard disc, hard disk, fixed disk", + 593: "harmonica, mouth organ, harp, mouth harp", + 594: "harp", + 595: "harvester, reaper", + 596: "hatchet", + 597: "holster", + 598: "home theater, home theatre", + 599: "honeycomb", + 600: "hook, claw", + 601: "hoopskirt, crinoline", + 602: "horizontal bar, high bar", + 603: "horse cart, horse-cart", + 604: "hourglass", + 605: "iPod", + 606: "iron, smoothing iron", + 607: "jack-o'-lantern", + 608: "jean, blue jean, denim", + 609: "jeep, landrover", + 610: "jersey, T-shirt, tee shirt", + 611: "jigsaw puzzle", + 612: "jinrikisha, ricksha, rickshaw", + 613: "joystick", + 614: "kimono", + 615: "knee pad", + 616: "knot", + 617: "lab coat, laboratory coat", + 618: "ladle", + 619: "lampshade, lamp shade", + 620: "laptop, laptop computer", + 621: "lawn mower, mower", + 622: "lens cap, lens cover", + 623: "letter opener, paper knife, paperknife", + 624: "library", + 625: "lifeboat", + 626: "lighter, light, igniter, ignitor", + 627: "limousine, limo", + 628: "liner, ocean liner", + 629: "lipstick, lip rouge", + 630: "Loafer", + 631: "lotion", + 632: "loudspeaker, speaker, speaker unit, loudspeaker system, speaker system", + 633: "loupe, jeweler's loupe", + 634: "lumbermill, sawmill", + 635: "magnetic compass", + 636: "mailbag, postbag", + 637: "mailbox, letter box", + 638: "maillot", + 639: "maillot, tank suit", + 640: "manhole cover", + 641: "maraca", + 642: "marimba, xylophone", + 643: "mask", + 644: "matchstick", + 645: "maypole", + 646: "maze, labyrinth", + 647: "measuring cup", + 648: "medicine chest, medicine cabinet", + 649: "megalith, megalithic structure", + 650: "microphone, mike", + 651: "microwave, microwave oven", + 652: "military uniform", + 653: "milk can", + 654: "minibus", + 655: "miniskirt, mini", + 656: "minivan", + 657: "missile", + 658: "mitten", + 659: "mixing bowl", + 660: "mobile home, manufactured home", + 661: "Model T", + 662: "modem", + 663: "monastery", + 664: "monitor", + 665: "moped", + 666: "mortar", + 667: "mortarboard", + 668: "mosque", + 669: "mosquito net", + 670: "motor scooter, scooter", + 671: "mountain bike, all-terrain bike, off-roader", + 672: "mountain tent", + 673: "mouse, computer mouse", + 674: "mousetrap", + 675: "moving van", + 676: "muzzle", + 677: "nail", + 678: "neck brace", + 679: "necklace", + 680: "nipple", + 681: "notebook, notebook computer", + 682: "obelisk", + 683: "oboe, hautboy, hautbois", + 684: "ocarina, sweet potato", + 685: "odometer, hodometer, mileometer, milometer", + 686: "oil filter", + 687: "organ, pipe organ", + 688: "oscilloscope, scope, cathode-ray oscilloscope, CRO", + 689: "overskirt", + 690: "oxcart", + 691: "oxygen mask", + 692: "packet", + 693: "paddle, boat paddle", + 694: "paddlewheel, paddle wheel", + 695: "padlock", + 696: "paintbrush", + 697: "pajama, pyjama, pj's, jammies", + 698: "palace", + 699: "panpipe, pandean pipe, syrinx", + 700: "paper towel", + 701: "parachute, chute", + 702: "parallel bars, bars", + 703: "park bench", + 704: "parking meter", + 705: "passenger car, coach, carriage", + 706: "patio, terrace", + 707: "pay-phone, pay-station", + 708: "pedestal, plinth, footstall", + 709: "pencil box, pencil case", + 710: "pencil sharpener", + 711: "perfume, essence", + 712: "Petri dish", + 713: "photocopier", + 714: "pick, plectrum, plectron", + 715: "pickelhaube", + 716: "picket fence, paling", + 717: "pickup, pickup truck", + 718: "pier", + 719: "piggy bank, penny bank", + 720: "pill bottle", + 721: "pillow", + 722: "ping-pong ball", + 723: "pinwheel", + 724: "pirate, pirate ship", + 725: "pitcher, ewer", + 726: "plane, carpenter's plane, woodworking plane", + 727: "planetarium", + 728: "plastic bag", + 729: "plate rack", + 730: "plow, plough", + 731: "plunger, plumber's helper", + 732: "Polaroid camera, Polaroid Land camera", + 733: "pole", + 734: "police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria", + 735: "poncho", + 736: "pool table, billiard table, snooker table", + 737: "pop bottle, soda bottle", + 738: "pot, flowerpot", + 739: "potter's wheel", + 740: "power drill", + 741: "prayer rug, prayer mat", + 742: "printer", + 743: "prison, prison house", + 744: "projectile, missile", + 745: "projector", + 746: "puck, hockey puck", + 747: "punching bag, punch bag, punching ball, punchball", + 748: "purse", + 749: "quill, quill pen", + 750: "quilt, comforter, comfort, puff", + 751: "racer, race car, racing car", + 752: "racket, racquet", + 753: "radiator", + 754: "radio, wireless", + 755: "radio telescope, radio reflector", + 756: "rain barrel", + 757: "recreational vehicle, RV, R.V.", + 758: "reel", + 759: "reflex camera", + 760: "refrigerator, icebox", + 761: "remote control, remote", + 762: "restaurant, eating house, eating place, eatery", + 763: "revolver, six-gun, six-shooter", + 764: "rifle", + 765: "rocking chair, rocker", + 766: "rotisserie", + 767: "rubber eraser, rubber, pencil eraser", + 768: "rugby ball", + 769: "rule, ruler", + 770: "running shoe", + 771: "safe", + 772: "safety pin", + 773: "saltshaker, salt shaker", + 774: "sandal", + 775: "sarong", + 776: "sax, saxophone", + 777: "scabbard", + 778: "scale, weighing machine", + 779: "school bus", + 780: "schooner", + 781: "scoreboard", + 782: "screen, CRT screen", + 783: "screw", + 784: "screwdriver", + 785: "seat belt, seatbelt", + 786: "sewing machine", + 787: "shield, buckler", + 788: "shoe shop, shoe-shop, shoe store", + 789: "shoji", + 790: "shopping basket", + 791: "shopping cart", + 792: "shovel", + 793: "shower cap", + 794: "shower curtain", + 795: "ski", + 796: "ski mask", + 797: "sleeping bag", + 798: "slide rule, slipstick", + 799: "sliding door", + 800: "slot, one-armed bandit", + 801: "snorkel", + 802: "snowmobile", + 803: "snowplow, snowplough", + 804: "soap dispenser", + 805: "soccer ball", + 806: "sock", + 807: "solar dish, solar collector, solar furnace", + 808: "sombrero", + 809: "soup bowl", + 810: "space bar", + 811: "space heater", + 812: "space shuttle", + 813: "spatula", + 814: "speedboat", + 815: "spider web, spider's web", + 816: "spindle", + 817: "sports car, sport car", + 818: "spotlight, spot", + 819: "stage", + 820: "steam locomotive", + 821: "steel arch bridge", + 822: "steel drum", + 823: "stethoscope", + 824: "stole", + 825: "stone wall", + 826: "stopwatch, stop watch", + 827: "stove", + 828: "strainer", + 829: "streetcar, tram, tramcar, trolley, trolley car", + 830: "stretcher", + 831: "studio couch, day bed", + 832: "stupa, tope", + 833: "submarine, pigboat, sub, U-boat", + 834: "suit, suit of clothes", + 835: "sundial", + 836: "sunglass", + 837: "sunglasses, dark glasses, shades", + 838: "sunscreen, sunblock, sun blocker", + 839: "suspension bridge", + 840: "swab, swob, mop", + 841: "sweatshirt", + 842: "swimming trunks, bathing trunks", + 843: "swing", + 844: "switch, electric switch, electrical switch", + 845: "syringe", + 846: "table lamp", + 847: "tank, army tank, armored combat vehicle, armoured combat vehicle", + 848: "tape player", + 849: "teapot", + 850: "teddy, teddy bear", + 851: "television, television system", + 852: "tennis ball", + 853: "thatch, thatched roof", + 854: "theater curtain, theatre curtain", + 855: "thimble", + 856: "thresher, thrasher, threshing machine", + 857: "throne", + 858: "tile roof", + 859: "toaster", + 860: "tobacco shop, tobacconist shop, tobacconist", + 861: "toilet seat", + 862: "torch", + 863: "totem pole", + 864: "tow truck, tow car, wrecker", + 865: "toyshop", + 866: "tractor", + 867: "trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi", + 868: "tray", + 869: "trench coat", + 870: "tricycle, trike, velocipede", + 871: "trimaran", + 872: "tripod", + 873: "triumphal arch", + 874: "trolleybus, trolley coach, trackless trolley", + 875: "trombone", + 876: "tub, vat", + 877: "turnstile", + 878: "typewriter keyboard", + 879: "umbrella", + 880: "unicycle, monocycle", + 881: "upright, upright piano", + 882: "vacuum, vacuum cleaner", + 883: "vase", + 884: "vault", + 885: "velvet", + 886: "vending machine", + 887: "vestment", + 888: "viaduct", + 889: "violin, fiddle", + 890: "volleyball", + 891: "waffle iron", + 892: "wall clock", + 893: "wallet, billfold, notecase, pocketbook", + 894: "wardrobe, closet, press", + 895: "warplane, military plane", + 896: "washbasin, handbasin, washbowl, lavabo, wash-hand basin", + 897: "washer, automatic washer, washing machine", + 898: "water bottle", + 899: "water jug", + 900: "water tower", + 901: "whiskey jug", + 902: "whistle", + 903: "wig", + 904: "window screen", + 905: "window shade", + 906: "Windsor tie", + 907: "wine bottle", + 908: "wing", + 909: "wok", + 910: "wooden spoon", + 911: "wool, woolen, woollen", + 912: "worm fence, snake fence, snake-rail fence, Virginia fence", + 913: "wreck", + 914: "yawl", + 915: "yurt", + 916: "web site, website, internet site, site", + 917: "comic book", + 918: "crossword puzzle, crossword", + 919: "street sign", + 920: "traffic light, traffic signal, stoplight", + 921: "book jacket, dust cover, dust jacket, dust wrapper", + 922: "menu", + 923: "plate", + 924: "guacamole", + 925: "consomme", + 926: "hot pot, hotpot", + 927: "trifle", + 928: "ice cream, icecream", + 929: "ice lolly, lolly, lollipop, popsicle", + 930: "French loaf", + 931: "bagel, beigel", + 932: "pretzel", + 933: "cheeseburger", + 934: "hotdog, hot dog, red hot", + 935: "mashed potato", + 936: "head cabbage", + 937: "broccoli", + 938: "cauliflower", + 939: "zucchini, courgette", + 940: "spaghetti squash", + 941: "acorn squash", + 942: "butternut squash", + 943: "cucumber, cuke", + 944: "artichoke, globe artichoke", + 945: "bell pepper", + 946: "cardoon", + 947: "mushroom", + 948: "Granny Smith", + 949: "strawberry", + 950: "orange", + 951: "lemon", + 952: "fig", + 953: "pineapple, ananas", + 954: "banana", + 955: "jackfruit, jak, jack", + 956: "custard apple", + 957: "pomegranate", + 958: "hay", + 959: "carbonara", + 960: "chocolate sauce, chocolate syrup", + 961: "dough", + 962: "meat loaf, meatloaf", + 963: "pizza, pizza pie", + 964: "potpie", + 965: "burrito", + 966: "red wine", + 967: "espresso", + 968: "cup", + 969: "eggnog", + 970: "alp", + 971: "bubble", + 972: "cliff, drop, drop-off", + 973: "coral reef", + 974: "geyser", + 975: "lakeside, lakeshore", + 976: "promontory, headland, head, foreland", + 977: "sandbar, sand bar", + 978: "seashore, coast, seacoast, sea-coast", + 979: "valley, vale", + 980: "volcano", + 981: "ballplayer, baseball player", + 982: "groom, bridegroom", + 983: "scuba diver", + 984: "rapeseed", + 985: "daisy", + 986: "yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum", + 987: "corn", + 988: "acorn", + 989: "hip, rose hip, rosehip", + 990: "buckeye, horse chestnut, conker", + 991: "coral fungus", + 992: "agaric", + 993: "gyromitra", + 994: "stinkhorn, carrion fungus", + 995: "earthstar", + 996: "hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa", + 997: "bolete", + 998: "ear, spike, capitulum", + 999: "toilet tissue, toilet paper, bathroom tissue", +} diff --git a/Transformer-Explainability/samples/catdog.png b/Transformer-Explainability/samples/catdog.png new file mode 100644 index 0000000000000000000000000000000000000000..2e83c062ecf02fd432baa94d91c6bf3b75df4ed4 Binary files /dev/null and b/Transformer-Explainability/samples/catdog.png differ diff --git a/Transformer-Explainability/samples/dogbird.png b/Transformer-Explainability/samples/dogbird.png new file mode 100644 index 0000000000000000000000000000000000000000..07592949de0ab5a91477c5f77b2a3048b26deab6 Binary files /dev/null and b/Transformer-Explainability/samples/dogbird.png differ diff --git a/Transformer-Explainability/samples/dogcat2.png b/Transformer-Explainability/samples/dogcat2.png new file mode 100644 index 0000000000000000000000000000000000000000..d29a92a6ddf986499c0cec34889995f5d55b4c60 Binary files /dev/null and b/Transformer-Explainability/samples/dogcat2.png differ diff --git a/Transformer-Explainability/samples/el1.png b/Transformer-Explainability/samples/el1.png new file mode 100644 index 0000000000000000000000000000000000000000..c0241ddc7566ba4909d6c733c657b45c82bba168 Binary files /dev/null and b/Transformer-Explainability/samples/el1.png differ diff --git a/Transformer-Explainability/samples/el2.png b/Transformer-Explainability/samples/el2.png new file mode 100644 index 0000000000000000000000000000000000000000..01494f5efa8a12618ffa09d055efb76649345a62 Binary files /dev/null and b/Transformer-Explainability/samples/el2.png differ diff --git a/Transformer-Explainability/samples/el3.png b/Transformer-Explainability/samples/el3.png new file mode 100644 index 0000000000000000000000000000000000000000..4fca3c105ceb258afecfa28897249a48591c403a Binary files /dev/null and b/Transformer-Explainability/samples/el3.png differ diff --git a/Transformer-Explainability/samples/el4.png b/Transformer-Explainability/samples/el4.png new file mode 100644 index 0000000000000000000000000000000000000000..0c0c1a8f33c87b4cfdd2c56f976aa86e99fee35c Binary files /dev/null and b/Transformer-Explainability/samples/el4.png differ diff --git a/Transformer-Explainability/samples/el5.png b/Transformer-Explainability/samples/el5.png new file mode 100644 index 0000000000000000000000000000000000000000..da92521517ec247f90074633c30e1145d5b4f05a Binary files /dev/null and b/Transformer-Explainability/samples/el5.png differ diff --git a/Transformer-Explainability/utils/__init__.py b/Transformer-Explainability/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Transformer-Explainability/utils/confusionmatrix.py b/Transformer-Explainability/utils/confusionmatrix.py new file mode 100644 index 0000000000000000000000000000000000000000..6411436d287225002153b7166a4ce27bade38816 --- /dev/null +++ b/Transformer-Explainability/utils/confusionmatrix.py @@ -0,0 +1,93 @@ +import numpy as np +import torch + +from . import metric + + +class ConfusionMatrix(metric.Metric): + """Constructs a confusion matrix for a multi-class classification problems. + Does not support multi-label, multi-class problems. + Keyword arguments: + - num_classes (int): number of classes in the classification problem. + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + Modified from: https://github.com/pytorch/tnt/blob/master/torchnet/meter/confusionmeter.py + """ + + def __init__(self, num_classes, normalized=False): + super().__init__() + + self.conf = np.ndarray((num_classes, num_classes), dtype=np.int32) + self.normalized = normalized + self.num_classes = num_classes + self.reset() + + def reset(self): + self.conf.fill(0) + + def add(self, predicted, target): + """Computes the confusion matrix + The shape of the confusion matrix is K x K, where K is the number + of classes. + Keyword arguments: + - predicted (Tensor or numpy.ndarray): Can be an N x K tensor/array of + predicted scores obtained from the model for N examples and K classes, + or an N-tensor/array of integer values between 0 and K-1. + - target (Tensor or numpy.ndarray): Can be an N x K tensor/array of + ground-truth classes for N examples and K classes, or an N-tensor/array + of integer values between 0 and K-1. + """ + # If target and/or predicted are tensors, convert them to numpy arrays + if torch.is_tensor(predicted): + predicted = predicted.cpu().numpy() + if torch.is_tensor(target): + target = target.cpu().numpy() + + assert ( + predicted.shape[0] == target.shape[0] + ), "number of targets and predicted outputs do not match" + + if np.ndim(predicted) != 1: + assert ( + predicted.shape[1] == self.num_classes + ), "number of predictions does not match size of confusion matrix" + predicted = np.argmax(predicted, 1) + else: + assert (predicted.max() < self.num_classes) and ( + predicted.min() >= 0 + ), "predicted values are not between 0 and k-1" + + if np.ndim(target) != 1: + assert ( + target.shape[1] == self.num_classes + ), "Onehot target does not match size of confusion matrix" + assert (target >= 0).all() and ( + target <= 1 + ).all(), "in one-hot encoding, target values should be 0 or 1" + assert (target.sum(1) == 1).all(), "multi-label setting is not supported" + target = np.argmax(target, 1) + else: + assert (target.max() < self.num_classes) and ( + target.min() >= 0 + ), "target values are not between 0 and k-1" + + # hack for bincounting 2 arrays together + x = predicted + self.num_classes * target + bincount_2d = np.bincount(x.astype(np.int32), minlength=self.num_classes**2) + assert bincount_2d.size == self.num_classes**2 + conf = bincount_2d.reshape((self.num_classes, self.num_classes)) + + self.conf += conf + + def value(self): + """ + Returns: + Confustion matrix of K rows and K columns, where rows corresponds + to ground-truth targets and columns corresponds to predicted + targets. + """ + if self.normalized: + conf = self.conf.astype(np.float32) + return conf / conf.sum(1).clip(min=1e-12)[:, None] + else: + return self.conf diff --git a/Transformer-Explainability/utils/iou.py b/Transformer-Explainability/utils/iou.py new file mode 100644 index 0000000000000000000000000000000000000000..d4f5ce146eafce527f4589f8ae07ad5fbc90711d --- /dev/null +++ b/Transformer-Explainability/utils/iou.py @@ -0,0 +1,97 @@ +import numpy as np +import torch + +from . import metric +from .confusionmatrix import ConfusionMatrix + + +class IoU(metric.Metric): + """Computes the intersection over union (IoU) per class and corresponding + mean (mIoU). + + Intersection over union (IoU) is a common evaluation metric for semantic + segmentation. The predictions are first accumulated in a confusion matrix + and the IoU is computed from it as follows: + + IoU = true_positive / (true_positive + false_positive + false_negative). + + Keyword arguments: + - num_classes (int): number of classes in the classification problem + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + - ignore_index (int or iterable, optional): Index of the classes to ignore + when computing the IoU. Can be an int, or any iterable of ints. + """ + + def __init__(self, num_classes, normalized=False, ignore_index=None): + super().__init__() + self.conf_metric = ConfusionMatrix(num_classes, normalized) + + if ignore_index is None: + self.ignore_index = None + elif isinstance(ignore_index, int): + self.ignore_index = (ignore_index,) + else: + try: + self.ignore_index = tuple(ignore_index) + except TypeError: + raise ValueError("'ignore_index' must be an int or iterable") + + def reset(self): + self.conf_metric.reset() + + def add(self, predicted, target): + """Adds the predicted and target pair to the IoU metric. + + Keyword arguments: + - predicted (Tensor): Can be a (N, K, H, W) tensor of + predicted scores obtained from the model for N examples and K classes, + or (N, H, W) tensor of integer values between 0 and K-1. + - target (Tensor): Can be a (N, K, H, W) tensor of + target scores for N examples and K classes, or (N, H, W) tensor of + integer values between 0 and K-1. + + """ + # Dimensions check + assert predicted.size(0) == target.size( + 0 + ), "number of targets and predicted outputs do not match" + assert ( + predicted.dim() == 3 or predicted.dim() == 4 + ), "predictions must be of dimension (N, H, W) or (N, K, H, W)" + assert ( + target.dim() == 3 or target.dim() == 4 + ), "targets must be of dimension (N, H, W) or (N, K, H, W)" + + # If the tensor is in categorical format convert it to integer format + if predicted.dim() == 4: + _, predicted = predicted.max(1) + if target.dim() == 4: + _, target = target.max(1) + + self.conf_metric.add(predicted.view(-1), target.view(-1)) + + def value(self): + """Computes the IoU and mean IoU. + + The mean computation ignores NaN elements of the IoU array. + + Returns: + Tuple: (IoU, mIoU). The first output is the per class IoU, + for K classes it's numpy.ndarray with K elements. The second output, + is the mean IoU. + """ + conf_matrix = self.conf_metric.value() + if self.ignore_index is not None: + for index in self.ignore_index: + conf_matrix[:, self.ignore_index] = 0 + conf_matrix[self.ignore_index, :] = 0 + true_positive = np.diag(conf_matrix) + false_positive = np.sum(conf_matrix, 0) - true_positive + false_negative = np.sum(conf_matrix, 1) - true_positive + + # Just in case we get a division by 0, ignore/hide the error + with np.errstate(divide="ignore", invalid="ignore"): + iou = true_positive / (true_positive + false_positive + false_negative) + + return iou, np.nanmean(iou) diff --git a/Transformer-Explainability/utils/metric.py b/Transformer-Explainability/utils/metric.py new file mode 100644 index 0000000000000000000000000000000000000000..db49a26fca5e3f6d1555810a12bd62cbe6fe2c00 --- /dev/null +++ b/Transformer-Explainability/utils/metric.py @@ -0,0 +1,13 @@ +class Metric(object): + """Base class for all metrics. + From: https://github.com/pytorch/tnt/blob/master/torchnet/meter/meter.py + """ + + def reset(self): + pass + + def add(self): + pass + + def value(self): + pass diff --git a/Transformer-Explainability/utils/metrices.py b/Transformer-Explainability/utils/metrices.py new file mode 100644 index 0000000000000000000000000000000000000000..98da13de53cd7d4c666bf48a025b03d1308c939a --- /dev/null +++ b/Transformer-Explainability/utils/metrices.py @@ -0,0 +1,219 @@ +import numpy as np +import torch +from sklearn.metrics import (average_precision_score, f1_score, + precision_recall_curve, roc_curve) + +SMOOTH = 1e-6 +__all__ = [ + "get_f1_scores", + "get_ap_scores", + "batch_pix_accuracy", + "batch_intersection_union", + "get_iou", + "get_pr", + "get_roc", + "get_ap_multiclass", +] + + +def get_iou(outputs: torch.Tensor, labels: torch.Tensor): + # You can comment out this line if you are passing tensors of equal shape + # But if you are passing output from UNet or something it will most probably + # be with the BATCH x 1 x H x W shape + outputs = outputs.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + labels = labels.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + + intersection = ( + (outputs & labels).float().sum((1, 2)) + ) # Will be zero if Truth=0 or Prediction=0 + union = (outputs | labels).float().sum((1, 2)) # Will be zzero if both are 0 + + iou = (intersection + SMOOTH) / ( + union + SMOOTH + ) # We smooth our devision to avoid 0/0 + + return iou.cpu().numpy() + + +def get_f1_scores(predict, target, ignore_index=-1): + # Tensor process + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target.data.cpu().numpy().reshape(-1) + pb = predict[target != ignore_index].reshape(batch_size, -1) + tb = target[target != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(np.nan_to_num(f1_score(t, p))) + + return total + + +def get_roc(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(roc_curve(t, p)) + + return total + + +def get_pr(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(precision_recall_curve(t, p)) + + return total + + +def get_ap_scores(predict, target, ignore_index=-1): + total = [] + for pred, tgt in zip(predict, target): + target_expand = tgt.unsqueeze(0).expand_as(pred) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + + # Tensor process + x = torch.zeros_like(target_expand) + t = tgt.unsqueeze(0).clamp(min=0).long() + target_1hot = x.scatter_(0, t, 1) + predict_flat = pred.data.cpu().numpy().reshape(-1) + target_flat = target_1hot.data.cpu().numpy().reshape(-1) + + p = predict_flat[target_expand_numpy != ignore_index] + t = target_flat[target_expand_numpy != ignore_index] + + total.append(np.nan_to_num(average_precision_score(t, p))) + + return total + + +def get_ap_multiclass(predict, target): + total = [] + for pred, tgt in zip(predict, target): + predict_flat = pred.data.cpu().numpy().reshape(-1) + target_flat = tgt.data.cpu().numpy().reshape(-1) + + total.append(np.nan_to_num(average_precision_score(target_flat, predict_flat))) + + return total + + +def batch_precision_recall(predict, target, thr=0.5): + """Batch Precision Recall + Args: + predict: input 4D tensor + target: label 4D tensor + """ + # _, predict = torch.max(predict, 1) + + predict = predict > thr + predict = predict.data.cpu().numpy() + 1 + target = target.data.cpu().numpy() + 1 + + tp = np.sum(((predict == 2) * (target == 2)) * (target > 0)) + fp = np.sum(((predict == 2) * (target == 1)) * (target > 0)) + fn = np.sum(((predict == 1) * (target == 2)) * (target > 0)) + + precision = float(np.nan_to_num(tp / (tp + fp))) + recall = float(np.nan_to_num(tp / (tp + fn))) + + return precision, recall + + +def batch_pix_accuracy(predict, target): + """Batch Pixel Accuracy + Args: + predict: input 3D tensor + target: label 3D tensor + """ + + # for thr in np.linspace(0, 1, slices): + + _, predict = torch.max(predict, 0) + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + pixel_labeled = np.sum(target > 0) + pixel_correct = np.sum((predict == target) * (target > 0)) + assert pixel_correct <= pixel_labeled, "Correct area should be smaller than Labeled" + return pixel_correct, pixel_labeled + + +def batch_intersection_union(predict, target, nclass): + """Batch Intersection of Union + Args: + predict: input 3D tensor + target: label 3D tensor + nclass: number of categories (int) + """ + _, predict = torch.max(predict, 0) + mini = 1 + maxi = nclass + nbins = nclass + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + + predict = predict * (target > 0).astype(predict.dtype) + intersection = predict * (predict == target) + # areas of intersection and union + area_inter, _ = np.histogram(intersection, bins=nbins, range=(mini, maxi)) + area_pred, _ = np.histogram(predict, bins=nbins, range=(mini, maxi)) + area_lab, _ = np.histogram(target, bins=nbins, range=(mini, maxi)) + area_union = area_pred + area_lab - area_inter + assert ( + area_inter <= area_union + ).all(), "Intersection area should be smaller than Union area" + return area_inter, area_union + + +# ref https://github.com/CSAILVision/sceneparsing/blob/master/evaluationCode/utils_eval.py +def pixel_accuracy(im_pred, im_lab): + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + + # Remove classes from unlabeled pixels in gt image. + # We should not penalize detections in unlabeled portions of the image. + pixel_labeled = np.sum(im_lab > 0) + pixel_correct = np.sum((im_pred == im_lab) * (im_lab > 0)) + # pixel_accuracy = 1.0 * pixel_correct / pixel_labeled + return pixel_correct, pixel_labeled + + +def intersection_and_union(im_pred, im_lab, num_class): + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + # Remove classes from unlabeled pixels in gt image. + im_pred = im_pred * (im_lab > 0) + # Compute area intersection: + intersection = im_pred * (im_pred == im_lab) + area_inter, _ = np.histogram( + intersection, bins=num_class - 1, range=(1, num_class - 1) + ) + # Compute area union: + area_pred, _ = np.histogram(im_pred, bins=num_class - 1, range=(1, num_class - 1)) + area_lab, _ = np.histogram(im_lab, bins=num_class - 1, range=(1, num_class - 1)) + area_union = area_pred + area_lab - area_inter + return area_inter, area_union diff --git a/Transformer-Explainability/utils/parallel.py b/Transformer-Explainability/utils/parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..0c066cf11cb4b48c2a833a70eaa289e6eb6e3e81 --- /dev/null +++ b/Transformer-Explainability/utils/parallel.py @@ -0,0 +1,276 @@ +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +## Created by: Hang Zhang +## ECE Department, Rutgers University +## Email: zhang.hang@rutgers.edu +## Copyright (c) 2017 +## +## This source code is licensed under the MIT-style license found in the +## LICENSE file in the root directory of this source tree +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +"""Encoding Data Parallel""" +import functools +import threading + +import torch +import torch.cuda.comm as comm +from torch.autograd import Function, Variable +from torch.nn.parallel._functions import Broadcast, ReduceAddCoalesced +from torch.nn.parallel.data_parallel import DataParallel +from torch.nn.parallel.parallel_apply import get_a_var + +torch_ver = torch.__version__[:3] + +__all__ = [ + "allreduce", + "DataParallelModel", + "DataParallelCriterion", + "patch_replication_callback", +] + + +def allreduce(*inputs): + """Cross GPU all reduce autograd operation for calculate mean and + variance in SyncBN. + """ + return AllReduce.apply(*inputs) + + +class AllReduce(Function): + @staticmethod + def forward(ctx, num_inputs, *inputs): + ctx.num_inputs = num_inputs + ctx.target_gpus = [ + inputs[i].get_device() for i in range(0, len(inputs), num_inputs) + ] + inputs = [inputs[i : i + num_inputs] for i in range(0, len(inputs), num_inputs)] + # sort before reduce sum + inputs = sorted(inputs, key=lambda i: i[0].get_device()) + results = comm.reduce_add_coalesced(inputs, ctx.target_gpus[0]) + outputs = comm.broadcast_coalesced(results, ctx.target_gpus) + return tuple([t for tensors in outputs for t in tensors]) + + @staticmethod + def backward(ctx, *inputs): + inputs = [i.data for i in inputs] + inputs = [ + inputs[i : i + ctx.num_inputs] + for i in range(0, len(inputs), ctx.num_inputs) + ] + results = comm.reduce_add_coalesced(inputs, ctx.target_gpus[0]) + outputs = comm.broadcast_coalesced(results, ctx.target_gpus) + return (None,) + tuple([Variable(t) for tensors in outputs for t in tensors]) + + +class Reduce(Function): + @staticmethod + def forward(ctx, *inputs): + ctx.target_gpus = [inputs[i].get_device() for i in range(len(inputs))] + inputs = sorted(inputs, key=lambda i: i.get_device()) + return comm.reduce_add(inputs) + + @staticmethod + def backward(ctx, gradOutput): + return Broadcast.apply(ctx.target_gpus, gradOutput) + + +class DataParallelModel(DataParallel): + """Implements data parallelism at the module level. + + This container parallelizes the application of the given module by + splitting the input across the specified devices by chunking in the + batch dimension. + In the forward pass, the module is replicated on each device, + and each replica handles a portion of the input. During the backwards pass, gradients from each replica are summed into the original module. + Note that the outputs are not gathered, please use compatible + :class:`encoding.parallel.DataParallelCriterion`. + + The batch size should be larger than the number of GPUs used. It should + also be an integer multiple of the number of GPUs so that each chunk is + the same size (so that each GPU processes the same number of samples). + + Args: + module: module to be parallelized + device_ids: CUDA devices (default: all devices) + + Reference: + Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, + Amit Agrawal. “Context Encoding for Semantic Segmentation. + *The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2018* + + Example:: + + >>> net = encoding.nn.DataParallelModel(model, device_ids=[0, 1, 2]) + >>> y = net(x) + """ + + def gather(self, outputs, output_device): + return outputs + + def replicate(self, module, device_ids): + modules = super(DataParallelModel, self).replicate(module, device_ids) + execute_replication_callbacks(modules) + return modules + + +class DataParallelCriterion(DataParallel): + """ + Calculate loss in multiple-GPUs, which balance the memory usage for + Semantic Segmentation. + + The targets are splitted across the specified devices by chunking in + the batch dimension. Please use together with :class:`encoding.parallel.DataParallelModel`. + + Reference: + Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, + Amit Agrawal. “Context Encoding for Semantic Segmentation. + *The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2018* + + Example:: + + >>> net = encoding.nn.DataParallelModel(model, device_ids=[0, 1, 2]) + >>> criterion = encoding.nn.DataParallelCriterion(criterion, device_ids=[0, 1, 2]) + >>> y = net(x) + >>> loss = criterion(y, target) + """ + + def forward(self, inputs, *targets, **kwargs): + # input should be already scatterd + # scattering the targets instead + if not self.device_ids: + return self.module(inputs, *targets, **kwargs) + targets, kwargs = self.scatter(targets, kwargs, self.device_ids) + if len(self.device_ids) == 1: + return self.module(inputs, *targets[0], **kwargs[0]) + replicas = self.replicate(self.module, self.device_ids[: len(inputs)]) + outputs = _criterion_parallel_apply(replicas, inputs, targets, kwargs) + return Reduce.apply(*outputs) / len(outputs) + # return self.gather(outputs, self.output_device).mean() + + +def _criterion_parallel_apply(modules, inputs, targets, kwargs_tup=None, devices=None): + assert len(modules) == len(inputs) + assert len(targets) == len(inputs) + if kwargs_tup: + assert len(modules) == len(kwargs_tup) + else: + kwargs_tup = ({},) * len(modules) + if devices is not None: + assert len(modules) == len(devices) + else: + devices = [None] * len(modules) + + lock = threading.Lock() + results = {} + if torch_ver != "0.3": + grad_enabled = torch.is_grad_enabled() + + def _worker(i, module, input, target, kwargs, device=None): + if torch_ver != "0.3": + torch.set_grad_enabled(grad_enabled) + if device is None: + device = get_a_var(input).get_device() + try: + with torch.cuda.device(device): + # this also avoids accidental slicing of `input` if it is a Tensor + if not isinstance(input, (list, tuple)): + input = (input,) + if type(input) != type(target): + if isinstance(target, tuple): + input = tuple(input) + elif isinstance(target, list): + input = list(input) + else: + raise Exception("Types problem") + + output = module(*(input + target), **kwargs) + with lock: + results[i] = output + except Exception as e: + with lock: + results[i] = e + + if len(modules) > 1: + threads = [ + threading.Thread( + target=_worker, + args=(i, module, input, target, kwargs, device), + ) + for i, (module, input, target, kwargs, device) in enumerate( + zip(modules, inputs, targets, kwargs_tup, devices) + ) + ] + + for thread in threads: + thread.start() + for thread in threads: + thread.join() + else: + _worker(0, modules[0], inputs[0], kwargs_tup[0], devices[0]) + + outputs = [] + for i in range(len(inputs)): + output = results[i] + if isinstance(output, Exception): + raise output + outputs.append(output) + return outputs + + +########################################################################### +# Adapted from Synchronized-BatchNorm-PyTorch. +# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch +# +class CallbackContext(object): + pass + + +def execute_replication_callbacks(modules): + """ + Execute an replication callback `__data_parallel_replicate__` on each module created + by original replication. + + The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)` + + Note that, as all modules are isomorphism, we assign each sub-module with a context + (shared among multiple copies of this module on different devices). + Through this context, different copies can share some information. + + We guarantee that the callback on the master copy (the first copy) will be called ahead + of calling the callback of any slave copies. + """ + master_copy = modules[0] + nr_modules = len(list(master_copy.modules())) + ctxs = [CallbackContext() for _ in range(nr_modules)] + + for i, module in enumerate(modules): + for j, m in enumerate(module.modules()): + if hasattr(m, "__data_parallel_replicate__"): + m.__data_parallel_replicate__(ctxs[j], i) + + +def patch_replication_callback(data_parallel): + """ + Monkey-patch an existing `DataParallel` object. Add the replication callback. + Useful when you have customized `DataParallel` implementation. + + Examples: + > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False) + > sync_bn = DataParallel(sync_bn, device_ids=[0, 1]) + > patch_replication_callback(sync_bn) + # this is equivalent to + > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False) + > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1]) + """ + + assert isinstance(data_parallel, DataParallel) + + old_replicate = data_parallel.replicate + + @functools.wraps(old_replicate) + def new_replicate(module, device_ids): + modules = old_replicate(module, device_ids) + execute_replication_callbacks(modules) + return modules + + data_parallel.replicate = new_replicate diff --git a/Transformer-Explainability/utils/render.py b/Transformer-Explainability/utils/render.py new file mode 100644 index 0000000000000000000000000000000000000000..e81daa9f0da1fe627d76f504a300132eafea9305 --- /dev/null +++ b/Transformer-Explainability/utils/render.py @@ -0,0 +1,275 @@ +import matplotlib.cm +import numpy as np +import skimage.feature +import skimage.filters +import skimage.io + + +def vec2im(V, shape=()): + """ + Transform an array V into a specified shape - or if no shape is given assume a square output format. + + Parameters + ---------- + + V : numpy.ndarray + an array either representing a matrix or vector to be reshaped into an two-dimensional image + + shape : tuple or list + optional. containing the shape information for the output array if not given, the output is assumed to be square + + Returns + ------- + + W : numpy.ndarray + with W.shape = shape or W.shape = [np.sqrt(V.size)]*2 + + """ + + if len(shape) < 2: + shape = [np.sqrt(V.size)] * 2 + shape = map(int, shape) + return np.reshape(V, shape) + + +def enlarge_image(img, scaling=3): + """ + Enlarges a given input matrix by replicating each pixel value scaling times in horizontal and vertical direction. + + Parameters + ---------- + + img : numpy.ndarray + array of shape [H x W] OR [H x W x D] + + scaling : int + positive integer value > 0 + + Returns + ------- + + out : numpy.ndarray + two-dimensional array of shape [scaling*H x scaling*W] + OR + three-dimensional array of shape [scaling*H x scaling*W x D] + depending on the dimensionality of the input + """ + + if scaling < 1 or not isinstance(scaling, int): + print("scaling factor needs to be an int >= 1") + + if len(img.shape) == 2: + H, W = img.shape + + out = np.zeros((scaling * H, scaling * W)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh : fh + scaling, fw : fw + scaling] = img[h, w] + + elif len(img.shape) == 3: + H, W, D = img.shape + + out = np.zeros((scaling * H, scaling * W, D)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh : fh + scaling, fw : fw + scaling, :] = img[h, w, :] + + return out + + +def repaint_corner_pixels(rgbimg, scaling=3): + """ + DEPRECATED/OBSOLETE. + + Recolors the top left and bottom right pixel (groups) with the average rgb value of its three neighboring pixel (groups). + The recoloring visually masks the opposing pixel values which are a product of stabilizing the scaling. + Assumes those image ares will pretty much never show evidence. + + Parameters + ---------- + + rgbimg : numpy.ndarray + array of shape [H x W x 3] + + scaling : int + positive integer value > 0 + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] + """ + + # top left corner. + rgbimg[0:scaling, 0:scaling, :] = ( + rgbimg[0, scaling, :] + rgbimg[scaling, 0, :] + rgbimg[scaling, scaling, :] + ) / 3.0 + # bottom right corner + rgbimg[-scaling:, -scaling:, :] = ( + rgbimg[-1, -1 - scaling, :] + + rgbimg[-1 - scaling, -1, :] + + rgbimg[-1 - scaling, -1 - scaling, :] + ) / 3.0 + return rgbimg + + +def digit_to_rgb(X, scaling=3, shape=(), cmap="binary"): + """ + Takes as input an intensity array and produces a rgb image due to some color map + + Parameters + ---------- + + X : numpy.ndarray + intensity matrix as array of shape [M x N] + + scaling : int + optional. positive integer value > 0 + + shape: tuple or list of its , length = 2 + optional. if not given, X is reshaped to be square. + + cmap : str + name of color map of choice. default is 'binary' + + Returns + ------- + + image : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + """ + + # create color map object from name string + cmap = eval("matplotlib.cm.{}".format(cmap)) + + image = enlarge_image(vec2im(X, shape), scaling) # enlarge + image = cmap(image.flatten())[..., 0:3].reshape( + [image.shape[0], image.shape[1], 3] + ) # colorize, reshape + + return image + + +def hm_to_rgb(R, X=None, scaling=3, shape=(), sigma=2, cmap="bwr", normalize=True): + """ + Takes as input an intensity array and produces a rgb image for the represented heatmap. + optionally draws the outline of another input on top of it. + + Parameters + ---------- + + R : numpy.ndarray + the heatmap to be visualized, shaped [M x N] + + X : numpy.ndarray + optional. some input, usually the data point for which the heatmap R is for, which shall serve + as a template for a black outline to be drawn on top of the image + shaped [M x N] + + scaling: int + factor, on how to enlarge the heatmap (to control resolution and as a inverse way to control outline thickness) + after reshaping it using shape. + + shape: tuple or list, length = 2 + optional. if not given, X is reshaped to be square. + + sigma : double + optional. sigma-parameter for the canny algorithm used for edge detection. the found edges are drawn as outlines. + + cmap : str + optional. color map of choice + + normalize : bool + optional. whether to normalize the heatmap to [-1 1] prior to colorization or not. + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + """ + + # create color map object from name string + cmap = eval("matplotlib.cm.{}".format(cmap)) + + if normalize: + R = R / np.max(np.abs(R)) # normalize to [-1,1] wrt to max relevance magnitude + R = (R + 1.0) / 2.0 # shift/normalize to [0,1] for color mapping + + R = enlarge_image(R, scaling) + rgb = cmap(R.flatten())[..., 0:3].reshape([R.shape[0], R.shape[1], 3]) + # rgb = repaint_corner_pixels(rgb, scaling) #obsolete due to directly calling the color map with [0,1]-normalized inputs + + if not X is None: # compute the outline of the input + # X = enlarge_image(vec2im(X,shape), scaling) + xdims = X.shape + Rdims = R.shape + + # if not np.all(xdims == Rdims): + # print 'transformed heatmap and data dimension mismatch. data dimensions differ?' + # print 'R.shape = ',Rdims, 'X.shape = ', xdims + # print 'skipping drawing of outline\n' + # else: + # #edges = skimage.filters.canny(X, sigma=sigma) + # edges = skimage.feature.canny(X, sigma=sigma) + # edges = np.invert(np.dstack([edges]*3))*1.0 + # rgb *= edges # set outline pixels to black color + + return rgb + + +def save_image(rgb_images, path, gap=2): + """ + Takes as input a list of rgb images, places them next to each other with a gap and writes out the result. + + Parameters + ---------- + + rgb_images : list , tuple, collection. such stuff + each item in the collection is expected to be an rgb image of dimensions [H x _ x 3] + where the width is variable + + path : str + the output path of the assembled image + + gap : int + optional. sets the width of a black area of pixels realized as an image shaped [H x gap x 3] in between the input images + + Returns + ------- + + image : numpy.ndarray + the assembled image as written out to path + """ + + sz = [] + image = [] + for i in range(len(rgb_images)): + if not sz: + sz = rgb_images[i].shape + image = rgb_images[i] + gap = np.zeros((sz[0], gap, sz[2])) + continue + if not sz[0] == rgb_images[i].shape[0] and sz[1] == rgb_images[i].shape[2]: + print("image", i, "differs in size. unable to perform horizontal alignment") + print("expected: Hx_xD = {0}x_x{1}".format(sz[0], sz[1])) + print( + "got : Hx_xD = {0}x_x{1}".format( + rgb_images[i].shape[0], rgb_images[i].shape[1] + ) + ) + print("skipping image\n") + else: + image = np.hstack((image, gap, rgb_images[i])) + + image *= 255 + image = image.astype(np.uint8) + + print("saving image to ", path) + skimage.io.imsave(path, image) + return image diff --git a/Transformer-Explainability/utils/saver.py b/Transformer-Explainability/utils/saver.py new file mode 100644 index 0000000000000000000000000000000000000000..6bd055f44438648d81c209ee30909fbd0dea56ec --- /dev/null +++ b/Transformer-Explainability/utils/saver.py @@ -0,0 +1,36 @@ +import glob +import os +from collections import OrderedDict + +import torch + + +class Saver(object): + def __init__(self, args): + self.args = args + self.directory = os.path.join("run", args.train_dataset, args.checkname) + self.runs = sorted(glob.glob(os.path.join(self.directory, "experiment_*"))) + run_id = int(self.runs[-1].split("_")[-1]) + 1 if self.runs else 0 + + self.experiment_dir = os.path.join( + self.directory, "experiment_{}".format(str(run_id)) + ) + if not os.path.exists(self.experiment_dir): + os.makedirs(self.experiment_dir) + + def save_checkpoint(self, state, filename="checkpoint.pth.tar"): + """Saves checkpoint to disk""" + filename = os.path.join(self.experiment_dir, filename) + torch.save(state, filename) + + def save_experiment_config(self): + logfile = os.path.join(self.experiment_dir, "parameters.txt") + log_file = open(logfile, "w") + p = OrderedDict() + p["train_dataset"] = self.args.train_dataset + p["lr"] = self.args.lr + p["epoch"] = self.args.epochs + + for key, val in p.items(): + log_file.write(key + ":" + str(val) + "\n") + log_file.close() diff --git a/Transformer-Explainability/utils/summaries.py b/Transformer-Explainability/utils/summaries.py new file mode 100644 index 0000000000000000000000000000000000000000..5c4dca94c70d3c3679d33485778914e0fc6d0c1a --- /dev/null +++ b/Transformer-Explainability/utils/summaries.py @@ -0,0 +1,12 @@ +import os + +from torch.utils.tensorboard import SummaryWriter + + +class TensorboardSummary(object): + def __init__(self, directory): + self.directory = directory + self.writer = SummaryWriter(log_dir=os.path.join(self.directory)) + + def add_scalar(self, *args): + self.writer.add_scalar(*args) diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..898695c1805a9f6d98b4947ad55257de5a8721c9 --- /dev/null +++ b/app.py @@ -0,0 +1,62 @@ +import gradio as gr +from PIL import Image +from torchvision import transforms + +from gradcam import do_gradcam +from lrp import do_lrp, do_partial_lrp +from rollout import do_rollout +from tiba import do_tiba + +normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) +TRANSFORM = transforms.Compose( + [ + transforms.Resize(256), + transforms.CenterCrop(224), + transforms.ToTensor(), + normalize, + ] +) +METHOD_MAP = { + "tiba": do_tiba, + "gradcam": do_gradcam, + "lrp": do_lrp, + "partial_lrp": do_partial_lrp, + "rollout": do_rollout, +} + + +def generate_viz(image, method, class_index=None): + viz_method = METHOD_MAP[method] + viz = viz_method(TRANSFORM, image, class_index) + viz.savefig("visualization.png") + return Image.open("visualization.png").convert("RGB") + + +title = "Compare different methods of explaining ViTs 🤖" +article = "Different methods for explaining Vision Transformers as explored by Chefer et al. in [Transformer Interpretability Beyond Attention Visualization, a novel method to visualize classifications by Transformer based networks](https://arxiv.org/abs/2012.09838)." + +iface = gr.Interface( + generate_viz, + inputs=[ + gr.Image(type="pil", label="Input Image"), + gr.Dropdown( + list(METHOD_MAP.keys()), + label="Method", + info="Explainability method to investigate.", + ), + gr.Number(label="Class Index", info="Class index to inspect", precision=int), + ], + outputs=gr.Image(), + title=title, + article=article, + allow_flagging="never", + cache_examples=True, + examples=[ + ["Transformer-Explainability/samples/catdog.png", "tiba", None], + ["Transformer-Explainability/samples/catdog.png", "rollout", 243], + ["Transformer-Explainability/samples/el2.png", "tiba", None], + ["Transformer-Explainability/samples/el2.png", "gradcam", 340], + ["Transformer-Explainability/samples/dogbird.png", "lrp", 161], + ], +) +iface.launch(debug=True) diff --git a/generic_utils.py b/generic_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c72d9ad380b5e7aaec8bb3af8f56e3ef51b3ec9d --- /dev/null +++ b/generic_utils.py @@ -0,0 +1,93 @@ +import sys + +import cv2 +import numpy as np +import torch + +from imagenet_class_indices import CLS2IDX + +sys.path.append("Transformer-Explainability") + + +from baselines.ViT.ViT_explanation_generator import LRP, Baselines +from baselines.ViT.ViT_LRP import vit_base_patch16_224 as vit_LRP +from baselines.ViT.ViT_new import vit_base_patch16_224 as vit + + +# create heatmap from mask on image +def show_cam_on_image(img, mask): + heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET) + heatmap = np.float32(heatmap) / 255 + cam = heatmap + np.float32(img) + cam = cam / np.max(cam) + return cam + + +# initialize ViT pretrained +model = vit_LRP(pretrained=True).cuda() +model.eval() +attribution_generator = LRP(model) +model_baseline = vit(pretrained=True).cuda() +model_baseline.eval() +baselines_generator = Baselines(model_baseline) + + +def generate_visualization( + original_image, class_index=None, method="transformer_attribution", LRP=True +): + if LRP: + transformer_attribution = attribution_generator.generate_LRP( + original_image.unsqueeze(0).cuda(), method=method, index=class_index + ).detach() + else: + if method == "gradcam": + transformer_attribution = baselines_generator.generate_cam_attn( + original_image.unsqueeze(0).cuda(), index=class_index + ).detach() + else: + transformer_attribution = baselines_generator.generate_rollout( + original_image.unsqueeze(0).cuda() + ).detach() + if method != "full": + transformer_attribution = transformer_attribution.reshape(1, 1, 14, 14) + transformer_attribution = torch.nn.functional.interpolate( + transformer_attribution, scale_factor=16, mode="bilinear" + ) + else: + transformer_attribution = transformer_attribution.reshape(1, 1, 224, 224) + transformer_attribution = ( + transformer_attribution.reshape(224, 224).data.cpu().numpy() + ) + transformer_attribution = ( + transformer_attribution - transformer_attribution.min() + ) / (transformer_attribution.max() - transformer_attribution.min()) + + image_transformer_attribution = original_image.permute(1, 2, 0).data.cpu().numpy() + image_transformer_attribution = ( + image_transformer_attribution - image_transformer_attribution.min() + ) / (image_transformer_attribution.max() - image_transformer_attribution.min()) + vis = show_cam_on_image(image_transformer_attribution, transformer_attribution) + vis = np.uint8(255 * vis) + vis = cv2.cvtColor(np.array(vis), cv2.COLOR_RGB2BGR) + return vis + + +def print_top_classes(predictions, **kwargs): + # Print Top-5 predictions + prob = torch.softmax(predictions, dim=1) + class_indices = predictions.data.topk(5, dim=1)[1][0].tolist() + max_str_len = 0 + class_names = [] + for cls_idx in class_indices: + class_names.append(CLS2IDX[cls_idx]) + if len(CLS2IDX[cls_idx]) > max_str_len: + max_str_len = len(CLS2IDX[cls_idx]) + + print("Top 5 classes:") + for cls_idx in class_indices: + output_string = "\t{} : {}".format(cls_idx, CLS2IDX[cls_idx]) + output_string += " " * (max_str_len - len(CLS2IDX[cls_idx])) + "\t\t" + output_string += "value = {:.3f}\t prob = {:.1f}%".format( + predictions[0, cls_idx], 100 * prob[0, cls_idx] + ) + print(output_string) diff --git a/gradcam.py b/gradcam.py new file mode 100644 index 0000000000000000000000000000000000000000..f756e74f2bd1da014abc0b472627ce7e42b1ca16 --- /dev/null +++ b/gradcam.py @@ -0,0 +1,18 @@ +import matplotlib.pyplot as plt + +from generic_utils import generate_visualization + + +def do_gradcam(transform, image, class_index=None): + fig, axs = plt.subplots(1, 2) + axs[0].imshow(image) + axs[0].axis("off") + + transformed_image = transform(image) + viz = generate_visualization( + transformed_image, class_index=class_index, method="gradcam", LRP=False + ) + + axs[1].imshow(viz) + axs[1].axis("off") + return fig diff --git a/imagenet_class_indices.py b/imagenet_class_indices.py new file mode 100644 index 0000000000000000000000000000000000000000..af5399c9778be19ecc5e940fe9191d6f9b71f7d6 --- /dev/null +++ b/imagenet_class_indices.py @@ -0,0 +1,1002 @@ +CLS2IDX = { + 0: "tench, Tinca tinca", + 1: "goldfish, Carassius auratus", + 2: "great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias", + 3: "tiger shark, Galeocerdo cuvieri", + 4: "hammerhead, hammerhead shark", + 5: "electric ray, crampfish, numbfish, torpedo", + 6: "stingray", + 7: "cock", + 8: "hen", + 9: "ostrich, Struthio camelus", + 10: "brambling, Fringilla montifringilla", + 11: "goldfinch, Carduelis carduelis", + 12: "house finch, linnet, Carpodacus mexicanus", + 13: "junco, snowbird", + 14: "indigo bunting, indigo finch, indigo bird, Passerina cyanea", + 15: "robin, American robin, Turdus migratorius", + 16: "bulbul", + 17: "jay", + 18: "magpie", + 19: "chickadee", + 20: "water ouzel, dipper", + 21: "kite", + 22: "bald eagle, American eagle, Haliaeetus leucocephalus", + 23: "vulture", + 24: "great grey owl, great gray owl, Strix nebulosa", + 25: "European fire salamander, Salamandra salamandra", + 26: "common newt, Triturus vulgaris", + 27: "eft", + 28: "spotted salamander, Ambystoma maculatum", + 29: "axolotl, mud puppy, Ambystoma mexicanum", + 30: "bullfrog, Rana catesbeiana", + 31: "tree frog, tree-frog", + 32: "tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui", + 33: "loggerhead, loggerhead turtle, Caretta caretta", + 34: "leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea", + 35: "mud turtle", + 36: "terrapin", + 37: "box turtle, box tortoise", + 38: "banded gecko", + 39: "common iguana, iguana, Iguana iguana", + 40: "American chameleon, anole, Anolis carolinensis", + 41: "whiptail, whiptail lizard", + 42: "agama", + 43: "frilled lizard, Chlamydosaurus kingi", + 44: "alligator lizard", + 45: "Gila monster, Heloderma suspectum", + 46: "green lizard, Lacerta viridis", + 47: "African chameleon, Chamaeleo chamaeleon", + 48: "Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis", + 49: "African crocodile, Nile crocodile, Crocodylus niloticus", + 50: "American alligator, Alligator mississipiensis", + 51: "triceratops", + 52: "thunder snake, worm snake, Carphophis amoenus", + 53: "ringneck snake, ring-necked snake, ring snake", + 54: "hognose snake, puff adder, sand viper", + 55: "green snake, grass snake", + 56: "king snake, kingsnake", + 57: "garter snake, grass snake", + 58: "water snake", + 59: "vine snake", + 60: "night snake, Hypsiglena torquata", + 61: "boa constrictor, Constrictor constrictor", + 62: "rock python, rock snake, Python sebae", + 63: "Indian cobra, Naja naja", + 64: "green mamba", + 65: "sea snake", + 66: "horned viper, cerastes, sand viper, horned asp, Cerastes cornutus", + 67: "diamondback, diamondback rattlesnake, Crotalus adamanteus", + 68: "sidewinder, horned rattlesnake, Crotalus cerastes", + 69: "trilobite", + 70: "harvestman, daddy longlegs, Phalangium opilio", + 71: "scorpion", + 72: "black and gold garden spider, Argiope aurantia", + 73: "barn spider, Araneus cavaticus", + 74: "garden spider, Aranea diademata", + 75: "black widow, Latrodectus mactans", + 76: "tarantula", + 77: "wolf spider, hunting spider", + 78: "tick", + 79: "centipede", + 80: "black grouse", + 81: "ptarmigan", + 82: "ruffed grouse, partridge, Bonasa umbellus", + 83: "prairie chicken, prairie grouse, prairie fowl", + 84: "peacock", + 85: "quail", + 86: "partridge", + 87: "African grey, African gray, Psittacus erithacus", + 88: "macaw", + 89: "sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita", + 90: "lorikeet", + 91: "coucal", + 92: "bee eater", + 93: "hornbill", + 94: "hummingbird", + 95: "jacamar", + 96: "toucan", + 97: "drake", + 98: "red-breasted merganser, Mergus serrator", + 99: "goose", + 100: "black swan, Cygnus atratus", + 101: "tusker", + 102: "echidna, spiny anteater, anteater", + 103: "platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus", + 104: "wallaby, brush kangaroo", + 105: "koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus", + 106: "wombat", + 107: "jellyfish", + 108: "sea anemone, anemone", + 109: "brain coral", + 110: "flatworm, platyhelminth", + 111: "nematode, nematode worm, roundworm", + 112: "conch", + 113: "snail", + 114: "slug", + 115: "sea slug, nudibranch", + 116: "chiton, coat-of-mail shell, sea cradle, polyplacophore", + 117: "chambered nautilus, pearly nautilus, nautilus", + 118: "Dungeness crab, Cancer magister", + 119: "rock crab, Cancer irroratus", + 120: "fiddler crab", + 121: "king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica", + 122: "American lobster, Northern lobster, Maine lobster, Homarus americanus", + 123: "spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish", + 124: "crayfish, crawfish, crawdad, crawdaddy", + 125: "hermit crab", + 126: "isopod", + 127: "white stork, Ciconia ciconia", + 128: "black stork, Ciconia nigra", + 129: "spoonbill", + 130: "flamingo", + 131: "little blue heron, Egretta caerulea", + 132: "American egret, great white heron, Egretta albus", + 133: "bittern", + 134: "crane", + 135: "limpkin, Aramus pictus", + 136: "European gallinule, Porphyrio porphyrio", + 137: "American coot, marsh hen, mud hen, water hen, Fulica americana", + 138: "bustard", + 139: "ruddy turnstone, Arenaria interpres", + 140: "red-backed sandpiper, dunlin, Erolia alpina", + 141: "redshank, Tringa totanus", + 142: "dowitcher", + 143: "oystercatcher, oyster catcher", + 144: "pelican", + 145: "king penguin, Aptenodytes patagonica", + 146: "albatross, mollymawk", + 147: "grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus", + 148: "killer whale, killer, orca, grampus, sea wolf, Orcinus orca", + 149: "dugong, Dugong dugon", + 150: "sea lion", + 151: "Chihuahua", + 152: "Japanese spaniel", + 153: "Maltese dog, Maltese terrier, Maltese", + 154: "Pekinese, Pekingese, Peke", + 155: "Shih-Tzu", + 156: "Blenheim spaniel", + 157: "papillon", + 158: "toy terrier", + 159: "Rhodesian ridgeback", + 160: "Afghan hound, Afghan", + 161: "basset, basset hound", + 162: "beagle", + 163: "bloodhound, sleuthhound", + 164: "bluetick", + 165: "black-and-tan coonhound", + 166: "Walker hound, Walker foxhound", + 167: "English foxhound", + 168: "redbone", + 169: "borzoi, Russian wolfhound", + 170: "Irish wolfhound", + 171: "Italian greyhound", + 172: "whippet", + 173: "Ibizan hound, Ibizan Podenco", + 174: "Norwegian elkhound, elkhound", + 175: "otterhound, otter hound", + 176: "Saluki, gazelle hound", + 177: "Scottish deerhound, deerhound", + 178: "Weimaraner", + 179: "Staffordshire bullterrier, Staffordshire bull terrier", + 180: "American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier", + 181: "Bedlington terrier", + 182: "Border terrier", + 183: "Kerry blue terrier", + 184: "Irish terrier", + 185: "Norfolk terrier", + 186: "Norwich terrier", + 187: "Yorkshire terrier", + 188: "wire-haired fox terrier", + 189: "Lakeland terrier", + 190: "Sealyham terrier, Sealyham", + 191: "Airedale, Airedale terrier", + 192: "cairn, cairn terrier", + 193: "Australian terrier", + 194: "Dandie Dinmont, Dandie Dinmont terrier", + 195: "Boston bull, Boston terrier", + 196: "miniature schnauzer", + 197: "giant schnauzer", + 198: "standard schnauzer", + 199: "Scotch terrier, Scottish terrier, Scottie", + 200: "Tibetan terrier, chrysanthemum dog", + 201: "silky terrier, Sydney silky", + 202: "soft-coated wheaten terrier", + 203: "West Highland white terrier", + 204: "Lhasa, Lhasa apso", + 205: "flat-coated retriever", + 206: "curly-coated retriever", + 207: "golden retriever", + 208: "Labrador retriever", + 209: "Chesapeake Bay retriever", + 210: "German short-haired pointer", + 211: "vizsla, Hungarian pointer", + 212: "English setter", + 213: "Irish setter, red setter", + 214: "Gordon setter", + 215: "Brittany spaniel", + 216: "clumber, clumber spaniel", + 217: "English springer, English springer spaniel", + 218: "Welsh springer spaniel", + 219: "cocker spaniel, English cocker spaniel, cocker", + 220: "Sussex spaniel", + 221: "Irish water spaniel", + 222: "kuvasz", + 223: "schipperke", + 224: "groenendael", + 225: "malinois", + 226: "briard", + 227: "kelpie", + 228: "komondor", + 229: "Old English sheepdog, bobtail", + 230: "Shetland sheepdog, Shetland sheep dog, Shetland", + 231: "collie", + 232: "Border collie", + 233: "Bouvier des Flandres, Bouviers des Flandres", + 234: "Rottweiler", + 235: "German shepherd, German shepherd dog, German police dog, alsatian", + 236: "Doberman, Doberman pinscher", + 237: "miniature pinscher", + 238: "Greater Swiss Mountain dog", + 239: "Bernese mountain dog", + 240: "Appenzeller", + 241: "EntleBucher", + 242: "boxer", + 243: "bull mastiff", + 244: "Tibetan mastiff", + 245: "French bulldog", + 246: "Great Dane", + 247: "Saint Bernard, St Bernard", + 248: "Eskimo dog, husky", + 249: "malamute, malemute, Alaskan malamute", + 250: "Siberian husky", + 251: "dalmatian, coach dog, carriage dog", + 252: "affenpinscher, monkey pinscher, monkey dog", + 253: "basenji", + 254: "pug, pug-dog", + 255: "Leonberg", + 256: "Newfoundland, Newfoundland dog", + 257: "Great Pyrenees", + 258: "Samoyed, Samoyede", + 259: "Pomeranian", + 260: "chow, chow chow", + 261: "keeshond", + 262: "Brabancon griffon", + 263: "Pembroke, Pembroke Welsh corgi", + 264: "Cardigan, Cardigan Welsh corgi", + 265: "toy poodle", + 266: "miniature poodle", + 267: "standard poodle", + 268: "Mexican hairless", + 269: "timber wolf, grey wolf, gray wolf, Canis lupus", + 270: "white wolf, Arctic wolf, Canis lupus tundrarum", + 271: "red wolf, maned wolf, Canis rufus, Canis niger", + 272: "coyote, prairie wolf, brush wolf, Canis latrans", + 273: "dingo, warrigal, warragal, Canis dingo", + 274: "dhole, Cuon alpinus", + 275: "African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus", + 276: "hyena, hyaena", + 277: "red fox, Vulpes vulpes", + 278: "kit fox, Vulpes macrotis", + 279: "Arctic fox, white fox, Alopex lagopus", + 280: "grey fox, gray fox, Urocyon cinereoargenteus", + 281: "tabby, tabby cat", + 282: "tiger cat", + 283: "Persian cat", + 284: "Siamese cat, Siamese", + 285: "Egyptian cat", + 286: "cougar, puma, catamount, mountain lion, painter, panther, Felis concolor", + 287: "lynx, catamount", + 288: "leopard, Panthera pardus", + 289: "snow leopard, ounce, Panthera uncia", + 290: "jaguar, panther, Panthera onca, Felis onca", + 291: "lion, king of beasts, Panthera leo", + 292: "tiger, Panthera tigris", + 293: "cheetah, chetah, Acinonyx jubatus", + 294: "brown bear, bruin, Ursus arctos", + 295: "American black bear, black bear, Ursus americanus, Euarctos americanus", + 296: "ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus", + 297: "sloth bear, Melursus ursinus, Ursus ursinus", + 298: "mongoose", + 299: "meerkat, mierkat", + 300: "tiger beetle", + 301: "ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle", + 302: "ground beetle, carabid beetle", + 303: "long-horned beetle, longicorn, longicorn beetle", + 304: "leaf beetle, chrysomelid", + 305: "dung beetle", + 306: "rhinoceros beetle", + 307: "weevil", + 308: "fly", + 309: "bee", + 310: "ant, emmet, pismire", + 311: "grasshopper, hopper", + 312: "cricket", + 313: "walking stick, walkingstick, stick insect", + 314: "cockroach, roach", + 315: "mantis, mantid", + 316: "cicada, cicala", + 317: "leafhopper", + 318: "lacewing, lacewing fly", + 319: "dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk", + 320: "damselfly", + 321: "admiral", + 322: "ringlet, ringlet butterfly", + 323: "monarch, monarch butterfly, milkweed butterfly, Danaus plexippus", + 324: "cabbage butterfly", + 325: "sulphur butterfly, sulfur butterfly", + 326: "lycaenid, lycaenid butterfly", + 327: "starfish, sea star", + 328: "sea urchin", + 329: "sea cucumber, holothurian", + 330: "wood rabbit, cottontail, cottontail rabbit", + 331: "hare", + 332: "Angora, Angora rabbit", + 333: "hamster", + 334: "porcupine, hedgehog", + 335: "fox squirrel, eastern fox squirrel, Sciurus niger", + 336: "marmot", + 337: "beaver", + 338: "guinea pig, Cavia cobaya", + 339: "sorrel", + 340: "zebra", + 341: "hog, pig, grunter, squealer, Sus scrofa", + 342: "wild boar, boar, Sus scrofa", + 343: "warthog", + 344: "hippopotamus, hippo, river horse, Hippopotamus amphibius", + 345: "ox", + 346: "water buffalo, water ox, Asiatic buffalo, Bubalus bubalis", + 347: "bison", + 348: "ram, tup", + 349: "bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis", + 350: "ibex, Capra ibex", + 351: "hartebeest", + 352: "impala, Aepyceros melampus", + 353: "gazelle", + 354: "Arabian camel, dromedary, Camelus dromedarius", + 355: "llama", + 356: "weasel", + 357: "mink", + 358: "polecat, fitch, foulmart, foumart, Mustela putorius", + 359: "black-footed ferret, ferret, Mustela nigripes", + 360: "otter", + 361: "skunk, polecat, wood pussy", + 362: "badger", + 363: "armadillo", + 364: "three-toed sloth, ai, Bradypus tridactylus", + 365: "orangutan, orang, orangutang, Pongo pygmaeus", + 366: "gorilla, Gorilla gorilla", + 367: "chimpanzee, chimp, Pan troglodytes", + 368: "gibbon, Hylobates lar", + 369: "siamang, Hylobates syndactylus, Symphalangus syndactylus", + 370: "guenon, guenon monkey", + 371: "patas, hussar monkey, Erythrocebus patas", + 372: "baboon", + 373: "macaque", + 374: "langur", + 375: "colobus, colobus monkey", + 376: "proboscis monkey, Nasalis larvatus", + 377: "marmoset", + 378: "capuchin, ringtail, Cebus capucinus", + 379: "howler monkey, howler", + 380: "titi, titi monkey", + 381: "spider monkey, Ateles geoffroyi", + 382: "squirrel monkey, Saimiri sciureus", + 383: "Madagascar cat, ring-tailed lemur, Lemur catta", + 384: "indri, indris, Indri indri, Indri brevicaudatus", + 385: "Indian elephant, Elephas maximus", + 386: "African elephant, Loxodonta africana", + 387: "lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens", + 388: "giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca", + 389: "barracouta, snoek", + 390: "eel", + 391: "coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch", + 392: "rock beauty, Holocanthus tricolor", + 393: "anemone fish", + 394: "sturgeon", + 395: "gar, garfish, garpike, billfish, Lepisosteus osseus", + 396: "lionfish", + 397: "puffer, pufferfish, blowfish, globefish", + 398: "abacus", + 399: "abaya", + 400: "academic gown, academic robe, judge's robe", + 401: "accordion, piano accordion, squeeze box", + 402: "acoustic guitar", + 403: "aircraft carrier, carrier, flattop, attack aircraft carrier", + 404: "airliner", + 405: "airship, dirigible", + 406: "altar", + 407: "ambulance", + 408: "amphibian, amphibious vehicle", + 409: "analog clock", + 410: "apiary, bee house", + 411: "apron", + 412: "ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin", + 413: "assault rifle, assault gun", + 414: "backpack, back pack, knapsack, packsack, rucksack, haversack", + 415: "bakery, bakeshop, bakehouse", + 416: "balance beam, beam", + 417: "balloon", + 418: "ballpoint, ballpoint pen, ballpen, Biro", + 419: "Band Aid", + 420: "banjo", + 421: "bannister, banister, balustrade, balusters, handrail", + 422: "barbell", + 423: "barber chair", + 424: "barbershop", + 425: "barn", + 426: "barometer", + 427: "barrel, cask", + 428: "barrow, garden cart, lawn cart, wheelbarrow", + 429: "baseball", + 430: "basketball", + 431: "bassinet", + 432: "bassoon", + 433: "bathing cap, swimming cap", + 434: "bath towel", + 435: "bathtub, bathing tub, bath, tub", + 436: "beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon", + 437: "beacon, lighthouse, beacon light, pharos", + 438: "beaker", + 439: "bearskin, busby, shako", + 440: "beer bottle", + 441: "beer glass", + 442: "bell cote, bell cot", + 443: "bib", + 444: "bicycle-built-for-two, tandem bicycle, tandem", + 445: "bikini, two-piece", + 446: "binder, ring-binder", + 447: "binoculars, field glasses, opera glasses", + 448: "birdhouse", + 449: "boathouse", + 450: "bobsled, bobsleigh, bob", + 451: "bolo tie, bolo, bola tie, bola", + 452: "bonnet, poke bonnet", + 453: "bookcase", + 454: "bookshop, bookstore, bookstall", + 455: "bottlecap", + 456: "bow", + 457: "bow tie, bow-tie, bowtie", + 458: "brass, memorial tablet, plaque", + 459: "brassiere, bra, bandeau", + 460: "breakwater, groin, groyne, mole, bulwark, seawall, jetty", + 461: "breastplate, aegis, egis", + 462: "broom", + 463: "bucket, pail", + 464: "buckle", + 465: "bulletproof vest", + 466: "bullet train, bullet", + 467: "butcher shop, meat market", + 468: "cab, hack, taxi, taxicab", + 469: "caldron, cauldron", + 470: "candle, taper, wax light", + 471: "cannon", + 472: "canoe", + 473: "can opener, tin opener", + 474: "cardigan", + 475: "car mirror", + 476: "carousel, carrousel, merry-go-round, roundabout, whirligig", + 477: "carpenter's kit, tool kit", + 478: "carton", + 479: "car wheel", + 480: "cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM", + 481: "cassette", + 482: "cassette player", + 483: "castle", + 484: "catamaran", + 485: "CD player", + 486: "cello, violoncello", + 487: "cellular telephone, cellular phone, cellphone, cell, mobile phone", + 488: "chain", + 489: "chainlink fence", + 490: "chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour", + 491: "chain saw, chainsaw", + 492: "chest", + 493: "chiffonier, commode", + 494: "chime, bell, gong", + 495: "china cabinet, china closet", + 496: "Christmas stocking", + 497: "church, church building", + 498: "cinema, movie theater, movie theatre, movie house, picture palace", + 499: "cleaver, meat cleaver, chopper", + 500: "cliff dwelling", + 501: "cloak", + 502: "clog, geta, patten, sabot", + 503: "cocktail shaker", + 504: "coffee mug", + 505: "coffeepot", + 506: "coil, spiral, volute, whorl, helix", + 507: "combination lock", + 508: "computer keyboard, keypad", + 509: "confectionery, confectionary, candy store", + 510: "container ship, containership, container vessel", + 511: "convertible", + 512: "corkscrew, bottle screw", + 513: "cornet, horn, trumpet, trump", + 514: "cowboy boot", + 515: "cowboy hat, ten-gallon hat", + 516: "cradle", + 517: "crane", + 518: "crash helmet", + 519: "crate", + 520: "crib, cot", + 521: "Crock Pot", + 522: "croquet ball", + 523: "crutch", + 524: "cuirass", + 525: "dam, dike, dyke", + 526: "desk", + 527: "desktop computer", + 528: "dial telephone, dial phone", + 529: "diaper, nappy, napkin", + 530: "digital clock", + 531: "digital watch", + 532: "dining table, board", + 533: "dishrag, dishcloth", + 534: "dishwasher, dish washer, dishwashing machine", + 535: "disk brake, disc brake", + 536: "dock, dockage, docking facility", + 537: "dogsled, dog sled, dog sleigh", + 538: "dome", + 539: "doormat, welcome mat", + 540: "drilling platform, offshore rig", + 541: "drum, membranophone, tympan", + 542: "drumstick", + 543: "dumbbell", + 544: "Dutch oven", + 545: "electric fan, blower", + 546: "electric guitar", + 547: "electric locomotive", + 548: "entertainment center", + 549: "envelope", + 550: "espresso maker", + 551: "face powder", + 552: "feather boa, boa", + 553: "file, file cabinet, filing cabinet", + 554: "fireboat", + 555: "fire engine, fire truck", + 556: "fire screen, fireguard", + 557: "flagpole, flagstaff", + 558: "flute, transverse flute", + 559: "folding chair", + 560: "football helmet", + 561: "forklift", + 562: "fountain", + 563: "fountain pen", + 564: "four-poster", + 565: "freight car", + 566: "French horn, horn", + 567: "frying pan, frypan, skillet", + 568: "fur coat", + 569: "garbage truck, dustcart", + 570: "gasmask, respirator, gas helmet", + 571: "gas pump, gasoline pump, petrol pump, island dispenser", + 572: "goblet", + 573: "go-kart", + 574: "golf ball", + 575: "golfcart, golf cart", + 576: "gondola", + 577: "gong, tam-tam", + 578: "gown", + 579: "grand piano, grand", + 580: "greenhouse, nursery, glasshouse", + 581: "grille, radiator grille", + 582: "grocery store, grocery, food market, market", + 583: "guillotine", + 584: "hair slide", + 585: "hair spray", + 586: "half track", + 587: "hammer", + 588: "hamper", + 589: "hand blower, blow dryer, blow drier, hair dryer, hair drier", + 590: "hand-held computer, hand-held microcomputer", + 591: "handkerchief, hankie, hanky, hankey", + 592: "hard disc, hard disk, fixed disk", + 593: "harmonica, mouth organ, harp, mouth harp", + 594: "harp", + 595: "harvester, reaper", + 596: "hatchet", + 597: "holster", + 598: "home theater, home theatre", + 599: "honeycomb", + 600: "hook, claw", + 601: "hoopskirt, crinoline", + 602: "horizontal bar, high bar", + 603: "horse cart, horse-cart", + 604: "hourglass", + 605: "iPod", + 606: "iron, smoothing iron", + 607: "jack-o'-lantern", + 608: "jean, blue jean, denim", + 609: "jeep, landrover", + 610: "jersey, T-shirt, tee shirt", + 611: "jigsaw puzzle", + 612: "jinrikisha, ricksha, rickshaw", + 613: "joystick", + 614: "kimono", + 615: "knee pad", + 616: "knot", + 617: "lab coat, laboratory coat", + 618: "ladle", + 619: "lampshade, lamp shade", + 620: "laptop, laptop computer", + 621: "lawn mower, mower", + 622: "lens cap, lens cover", + 623: "letter opener, paper knife, paperknife", + 624: "library", + 625: "lifeboat", + 626: "lighter, light, igniter, ignitor", + 627: "limousine, limo", + 628: "liner, ocean liner", + 629: "lipstick, lip rouge", + 630: "Loafer", + 631: "lotion", + 632: "loudspeaker, speaker, speaker unit, loudspeaker system, speaker system", + 633: "loupe, jeweler's loupe", + 634: "lumbermill, sawmill", + 635: "magnetic compass", + 636: "mailbag, postbag", + 637: "mailbox, letter box", + 638: "maillot", + 639: "maillot, tank suit", + 640: "manhole cover", + 641: "maraca", + 642: "marimba, xylophone", + 643: "mask", + 644: "matchstick", + 645: "maypole", + 646: "maze, labyrinth", + 647: "measuring cup", + 648: "medicine chest, medicine cabinet", + 649: "megalith, megalithic structure", + 650: "microphone, mike", + 651: "microwave, microwave oven", + 652: "military uniform", + 653: "milk can", + 654: "minibus", + 655: "miniskirt, mini", + 656: "minivan", + 657: "missile", + 658: "mitten", + 659: "mixing bowl", + 660: "mobile home, manufactured home", + 661: "Model T", + 662: "modem", + 663: "monastery", + 664: "monitor", + 665: "moped", + 666: "mortar", + 667: "mortarboard", + 668: "mosque", + 669: "mosquito net", + 670: "motor scooter, scooter", + 671: "mountain bike, all-terrain bike, off-roader", + 672: "mountain tent", + 673: "mouse, computer mouse", + 674: "mousetrap", + 675: "moving van", + 676: "muzzle", + 677: "nail", + 678: "neck brace", + 679: "necklace", + 680: "nipple", + 681: "notebook, notebook computer", + 682: "obelisk", + 683: "oboe, hautboy, hautbois", + 684: "ocarina, sweet potato", + 685: "odometer, hodometer, mileometer, milometer", + 686: "oil filter", + 687: "organ, pipe organ", + 688: "oscilloscope, scope, cathode-ray oscilloscope, CRO", + 689: "overskirt", + 690: "oxcart", + 691: "oxygen mask", + 692: "packet", + 693: "paddle, boat paddle", + 694: "paddlewheel, paddle wheel", + 695: "padlock", + 696: "paintbrush", + 697: "pajama, pyjama, pj's, jammies", + 698: "palace", + 699: "panpipe, pandean pipe, syrinx", + 700: "paper towel", + 701: "parachute, chute", + 702: "parallel bars, bars", + 703: "park bench", + 704: "parking meter", + 705: "passenger car, coach, carriage", + 706: "patio, terrace", + 707: "pay-phone, pay-station", + 708: "pedestal, plinth, footstall", + 709: "pencil box, pencil case", + 710: "pencil sharpener", + 711: "perfume, essence", + 712: "Petri dish", + 713: "photocopier", + 714: "pick, plectrum, plectron", + 715: "pickelhaube", + 716: "picket fence, paling", + 717: "pickup, pickup truck", + 718: "pier", + 719: "piggy bank, penny bank", + 720: "pill bottle", + 721: "pillow", + 722: "ping-pong ball", + 723: "pinwheel", + 724: "pirate, pirate ship", + 725: "pitcher, ewer", + 726: "plane, carpenter's plane, woodworking plane", + 727: "planetarium", + 728: "plastic bag", + 729: "plate rack", + 730: "plow, plough", + 731: "plunger, plumber's helper", + 732: "Polaroid camera, Polaroid Land camera", + 733: "pole", + 734: "police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria", + 735: "poncho", + 736: "pool table, billiard table, snooker table", + 737: "pop bottle, soda bottle", + 738: "pot, flowerpot", + 739: "potter's wheel", + 740: "power drill", + 741: "prayer rug, prayer mat", + 742: "printer", + 743: "prison, prison house", + 744: "projectile, missile", + 745: "projector", + 746: "puck, hockey puck", + 747: "punching bag, punch bag, punching ball, punchball", + 748: "purse", + 749: "quill, quill pen", + 750: "quilt, comforter, comfort, puff", + 751: "racer, race car, racing car", + 752: "racket, racquet", + 753: "radiator", + 754: "radio, wireless", + 755: "radio telescope, radio reflector", + 756: "rain barrel", + 757: "recreational vehicle, RV, R.V.", + 758: "reel", + 759: "reflex camera", + 760: "refrigerator, icebox", + 761: "remote control, remote", + 762: "restaurant, eating house, eating place, eatery", + 763: "revolver, six-gun, six-shooter", + 764: "rifle", + 765: "rocking chair, rocker", + 766: "rotisserie", + 767: "rubber eraser, rubber, pencil eraser", + 768: "rugby ball", + 769: "rule, ruler", + 770: "running shoe", + 771: "safe", + 772: "safety pin", + 773: "saltshaker, salt shaker", + 774: "sandal", + 775: "sarong", + 776: "sax, saxophone", + 777: "scabbard", + 778: "scale, weighing machine", + 779: "school bus", + 780: "schooner", + 781: "scoreboard", + 782: "screen, CRT screen", + 783: "screw", + 784: "screwdriver", + 785: "seat belt, seatbelt", + 786: "sewing machine", + 787: "shield, buckler", + 788: "shoe shop, shoe-shop, shoe store", + 789: "shoji", + 790: "shopping basket", + 791: "shopping cart", + 792: "shovel", + 793: "shower cap", + 794: "shower curtain", + 795: "ski", + 796: "ski mask", + 797: "sleeping bag", + 798: "slide rule, slipstick", + 799: "sliding door", + 800: "slot, one-armed bandit", + 801: "snorkel", + 802: "snowmobile", + 803: "snowplow, snowplough", + 804: "soap dispenser", + 805: "soccer ball", + 806: "sock", + 807: "solar dish, solar collector, solar furnace", + 808: "sombrero", + 809: "soup bowl", + 810: "space bar", + 811: "space heater", + 812: "space shuttle", + 813: "spatula", + 814: "speedboat", + 815: "spider web, spider's web", + 816: "spindle", + 817: "sports car, sport car", + 818: "spotlight, spot", + 819: "stage", + 820: "steam locomotive", + 821: "steel arch bridge", + 822: "steel drum", + 823: "stethoscope", + 824: "stole", + 825: "stone wall", + 826: "stopwatch, stop watch", + 827: "stove", + 828: "strainer", + 829: "streetcar, tram, tramcar, trolley, trolley car", + 830: "stretcher", + 831: "studio couch, day bed", + 832: "stupa, tope", + 833: "submarine, pigboat, sub, U-boat", + 834: "suit, suit of clothes", + 835: "sundial", + 836: "sunglass", + 837: "sunglasses, dark glasses, shades", + 838: "sunscreen, sunblock, sun blocker", + 839: "suspension bridge", + 840: "swab, swob, mop", + 841: "sweatshirt", + 842: "swimming trunks, bathing trunks", + 843: "swing", + 844: "switch, electric switch, electrical switch", + 845: "syringe", + 846: "table lamp", + 847: "tank, army tank, armored combat vehicle, armoured combat vehicle", + 848: "tape player", + 849: "teapot", + 850: "teddy, teddy bear", + 851: "television, television system", + 852: "tennis ball", + 853: "thatch, thatched roof", + 854: "theater curtain, theatre curtain", + 855: "thimble", + 856: "thresher, thrasher, threshing machine", + 857: "throne", + 858: "tile roof", + 859: "toaster", + 860: "tobacco shop, tobacconist shop, tobacconist", + 861: "toilet seat", + 862: "torch", + 863: "totem pole", + 864: "tow truck, tow car, wrecker", + 865: "toyshop", + 866: "tractor", + 867: "trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi", + 868: "tray", + 869: "trench coat", + 870: "tricycle, trike, velocipede", + 871: "trimaran", + 872: "tripod", + 873: "triumphal arch", + 874: "trolleybus, trolley coach, trackless trolley", + 875: "trombone", + 876: "tub, vat", + 877: "turnstile", + 878: "typewriter keyboard", + 879: "umbrella", + 880: "unicycle, monocycle", + 881: "upright, upright piano", + 882: "vacuum, vacuum cleaner", + 883: "vase", + 884: "vault", + 885: "velvet", + 886: "vending machine", + 887: "vestment", + 888: "viaduct", + 889: "violin, fiddle", + 890: "volleyball", + 891: "waffle iron", + 892: "wall clock", + 893: "wallet, billfold, notecase, pocketbook", + 894: "wardrobe, closet, press", + 895: "warplane, military plane", + 896: "washbasin, handbasin, washbowl, lavabo, wash-hand basin", + 897: "washer, automatic washer, washing machine", + 898: "water bottle", + 899: "water jug", + 900: "water tower", + 901: "whiskey jug", + 902: "whistle", + 903: "wig", + 904: "window screen", + 905: "window shade", + 906: "Windsor tie", + 907: "wine bottle", + 908: "wing", + 909: "wok", + 910: "wooden spoon", + 911: "wool, woolen, woollen", + 912: "worm fence, snake fence, snake-rail fence, Virginia fence", + 913: "wreck", + 914: "yawl", + 915: "yurt", + 916: "web site, website, internet site, site", + 917: "comic book", + 918: "crossword puzzle, crossword", + 919: "street sign", + 920: "traffic light, traffic signal, stoplight", + 921: "book jacket, dust cover, dust jacket, dust wrapper", + 922: "menu", + 923: "plate", + 924: "guacamole", + 925: "consomme", + 926: "hot pot, hotpot", + 927: "trifle", + 928: "ice cream, icecream", + 929: "ice lolly, lolly, lollipop, popsicle", + 930: "French loaf", + 931: "bagel, beigel", + 932: "pretzel", + 933: "cheeseburger", + 934: "hotdog, hot dog, red hot", + 935: "mashed potato", + 936: "head cabbage", + 937: "broccoli", + 938: "cauliflower", + 939: "zucchini, courgette", + 940: "spaghetti squash", + 941: "acorn squash", + 942: "butternut squash", + 943: "cucumber, cuke", + 944: "artichoke, globe artichoke", + 945: "bell pepper", + 946: "cardoon", + 947: "mushroom", + 948: "Granny Smith", + 949: "strawberry", + 950: "orange", + 951: "lemon", + 952: "fig", + 953: "pineapple, ananas", + 954: "banana", + 955: "jackfruit, jak, jack", + 956: "custard apple", + 957: "pomegranate", + 958: "hay", + 959: "carbonara", + 960: "chocolate sauce, chocolate syrup", + 961: "dough", + 962: "meat loaf, meatloaf", + 963: "pizza, pizza pie", + 964: "potpie", + 965: "burrito", + 966: "red wine", + 967: "espresso", + 968: "cup", + 969: "eggnog", + 970: "alp", + 971: "bubble", + 972: "cliff, drop, drop-off", + 973: "coral reef", + 974: "geyser", + 975: "lakeside, lakeshore", + 976: "promontory, headland, head, foreland", + 977: "sandbar, sand bar", + 978: "seashore, coast, seacoast, sea-coast", + 979: "valley, vale", + 980: "volcano", + 981: "ballplayer, baseball player", + 982: "groom, bridegroom", + 983: "scuba diver", + 984: "rapeseed", + 985: "daisy", + 986: "yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum", + 987: "corn", + 988: "acorn", + 989: "hip, rose hip, rosehip", + 990: "buckeye, horse chestnut, conker", + 991: "coral fungus", + 992: "agaric", + 993: "gyromitra", + 994: "stinkhorn, carrion fungus", + 995: "earthstar", + 996: "hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa", + 997: "bolete", + 998: "ear, spike, capitulum", + 999: "toilet tissue, toilet paper, bathroom tissue", +} diff --git a/lrp.py b/lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..c331e55af25e4eea56e14ddb961bfc8622349ee9 --- /dev/null +++ b/lrp.py @@ -0,0 +1,33 @@ +import matplotlib.pyplot as plt + +from generic_utils import generate_visualization + + +def do_lrp(transform, image, class_index=None): + fig, axs = plt.subplots(1, 2) + axs[0].imshow(image) + axs[0].axis("off") + + transformed_image = transform(image) + viz = generate_visualization( + transformed_image, class_index=class_index, method="full" + ) + + axs[1].imshow(viz) + axs[1].axis("off") + return fig + + +def do_partial_lrp(transform, image, class_index=None): + fig, axs = plt.subplots(1, 2) + axs[0].imshow(image) + axs[0].axis("off") + + transformed_image = transform(image) + viz = generate_visualization( + transformed_image, class_index=class_index, method="last_layer" + ) + + axs[1].imshow(viz) + axs[1].axis("off") + return fig diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..45742d8f265c02b46ed1aa3c18f5f9213c399d15 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +einops +numpy +matplotlib +opencv-python +h5py +torch +torchvision \ No newline at end of file diff --git a/rollout.py b/rollout.py new file mode 100644 index 0000000000000000000000000000000000000000..f8ee84ffa38ee822599bbf29181c8133d3f181de --- /dev/null +++ b/rollout.py @@ -0,0 +1,18 @@ +import matplotlib.pyplot as plt + +from generic_utils import generate_visualization + + +def do_rollout(transform, image, class_index=None): + fig, axs = plt.subplots(1, 2) + axs[0].imshow(image) + axs[0].axis("off") + + transformed_image = transform(image) + viz = generate_visualization( + transformed_image, class_index=class_index, method="rollout", LRP=False + ) + + axs[1].imshow(viz) + axs[1].axis("off") + return fig diff --git a/tiba.py b/tiba.py new file mode 100644 index 0000000000000000000000000000000000000000..e6ebe1e6686c3d0da261c9dbbb86a21ff0db7773 --- /dev/null +++ b/tiba.py @@ -0,0 +1,16 @@ +import matplotlib.pyplot as plt + +from generic_utils import generate_visualization + + +def do_tiba(transform, image, class_index=None): + fig, axs = plt.subplots(1, 2) + axs[0].imshow(image) + axs[0].axis("off") + + transformed_image = transform(image) + viz = generate_visualization(transformed_image, class_index=class_index) + + axs[1].imshow(viz) + axs[1].axis("off") + return fig