SST-2_Heatmap.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "d90a11d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import argparse\n",
    "import glob\n",
    "import math\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tqdm as tqdm\n",
    "from scipy.special import softmax\n",
    "import scipy.stats as stats\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, HTML\n",
    "from captum.attr import visualization\n",
    "\n",
    "from transformers import AutoTokenizer\n",
    "\n",
    "import datasets\n",
    "from datasets import load_dataset, load_metric \n",
    "from datasets import list_datasets, list_metrics\n",
    "\n",
    "from BERT_explainability.modules.BERT.BertForSequenceClassification import BertForSequenceClassification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "e0661e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load model   \n",
    "model = BertForSequenceClassification.from_pretrained(\"textattack/bert-base-uncased-SST-2\").to(\"cuda\")\n",
    "model.eval()\n",
    "\n",
    "# load tokenizer\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"textattack/bert-base-uncased-SST-2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ded2e972",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = \"glue\" # select a dataset\n",
    "task = \"sst2\" # select a task\n",
    "dataset = load_dataset(dataset, task) # load dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "636a3f07",
   "metadata": {},
   "outputs": [],
   "source": [
    "special_tokens = {\"[CLS]\", \"[SEP]\"}\n",
    "special_idxs = {101,102}    \n",
    "mask = \"[PAD]\"\n",
    "mask_id = 0   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "e85317ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_sample(text):\n",
    "    tokenized_input  = tokenizer(text, add_special_tokens=True, truncation=True)\n",
    "    input_ids = tokenized_input['input_ids']\n",
    "    text_ids = (torch.tensor([input_ids])).to(\"cuda\")\n",
    "    text_words = tokenizer.convert_ids_to_tokens(text_ids[0])\n",
    "    \n",
    "    # mask special tokens\n",
    "    att_mask = tokenized_input['attention_mask']\n",
    "    spe_idxs = [x for x, y in list(enumerate(input_ids)) if y in special_idxs]\n",
    "    att_mask = [0 if index in spe_idxs else 1 for index, item in enumerate(att_mask)]\n",
    "    att_mask = [0 if index in spe_idxs else 1 for index, item in enumerate(att_mask)]\n",
    "    att_mask = (torch.tensor([att_mask])).to(\"cuda\")\n",
    "    \n",
    "    return text_ids, att_mask, text_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "33db358e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(model, text_ids, target, att_mask=None, seg_ids=None):\n",
    "    out = model(text_ids, attention_mask=att_mask, token_type_ids=seg_ids)\n",
    "    prob = out[0]\n",
    "    pred_class = torch.argmax(prob, axis=1).cpu().detach().numpy()\n",
    "    pred_class_prob = softmax(prob.cpu().detach().numpy(), axis=1)\n",
    "    return pred_class[0], pred_class_prob[:, target][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "0d7f37ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def truncate_words(sorted_idx, text_words, text_ids, replaced_num, seg_ids=None):\n",
    "    to_be_replaced_idx = []\n",
    "    i= 0\n",
    "    while len(to_be_replaced_idx) < replaced_num and i!=len(text_words)-1:\n",
    "        current_idx = sorted_idx[i]\n",
    "        if text_words[current_idx] not in special_tokens:\n",
    "            to_be_replaced_idx.append(current_idx)\n",
    "        i += 1\n",
    "    remaining_idx = sorted(list(set(sorted_idx) - set(to_be_replaced_idx)))\n",
    "    truncated_text_ids = text_ids[0, np.array(remaining_idx)]\n",
    "    if seg_ids is not None:\n",
    "        seg_ids = seg_ids[0, np.array(remaining_idx)]\n",
    "    truncated_text_words = np.array(text_words)[remaining_idx]\n",
    "    return truncated_text_ids.unsqueeze(0), truncated_text_words, seg_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "0e875dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_words(sorted_idx, text_words, text_ids, replaced_num, mask, mask_id):\n",
    "    to_be_replaced_idx = []\n",
    "    i= 0\n",
    "    while len(to_be_replaced_idx) < replaced_num and i!=len(text_words)-1:\n",
    "        current_idx = sorted_idx[i]\n",
    "        if text_words[current_idx] not in special_tokens:\n",
    "            to_be_replaced_idx.append(current_idx)\n",
    "        i += 1\n",
    "    replaced_text_ids = text_ids.clone()\n",
    "    replaced_text_ids[0, to_be_replaced_idx] = mask_id\n",
    "    replaced_text_words = np.copy(text_words)\n",
    "    replaced_text_words[to_be_replaced_idx] = mask\n",
    "    return replaced_text_ids, replaced_text_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "2eb4c203",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute rollout between attention layers\n",
    "def compute_rollout_attention(all_layer_matrices, start_layer=0):\n",
    "    \n",
    "    # adding residual consideration- code adapted from https://github.com/samiraabnar/attention_flow\n",
    "    num_tokens = all_layer_matrices[0].shape[1]\n",
    "    batch_size = all_layer_matrices[0].shape[0]\n",
    "    eye = torch.eye(num_tokens).expand(batch_size, num_tokens, num_tokens).to(all_layer_matrices[0].device)\n",
    "    all_layer_matrices = [all_layer_matrices[i] + eye for i in range(len(all_layer_matrices))]\n",
    "    matrices_aug = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True)\n",
    "                          for i in range(len(all_layer_matrices))]\n",
    "    joint_attention = matrices_aug[start_layer]\n",
    "    for i in range(start_layer+1, len(matrices_aug)):\n",
    "        joint_attention = matrices_aug[i].bmm(joint_attention)\n",
    "        \n",
    "    return joint_attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "66061f0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator:\n",
    "    def __init__(self, model):\n",
    "        self.model = model\n",
    "        self.model.eval()\n",
    "\n",
    "    def forward(self, input_ids, attention_mask):\n",
    "        return self.model(input_ids, attention_mask)\n",
    "\n",
    "    \n",
    "    def generate_TransCAM(self, input_ids, attention_mask,\n",
    "                          index=None, start_layer=0):\n",
    "\n",
    "        result = self.model(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)\n",
    "        \n",
    "        output = result[0]\n",
    "        hs = result[1]\n",
    "\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "\n",
    "        for blk_id in range(len(blocks)):\n",
    "            hs[blk_id].retain_grad()\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cams = {}\n",
    "        \n",
    "        for blk_id in range(len(blocks)):\n",
    "            hs_grads = hs[blk_id].grad\n",
    "            \n",
    "            att = blocks[blk_id].attention.self.get_attn().squeeze(0)\n",
    "            att = att.mean(dim=0)\n",
    "            att = att.mean(dim=0)\n",
    "            \n",
    "            cat = (hs_grads * hs[blk_id]).sum(dim=-1).squeeze(0)\n",
    "            cat = cat * att\n",
    "            \n",
    "            cams[blk_id] = cat\n",
    "            \n",
    "        trans_expln = sum(cams.values())\n",
    "\n",
    "        return trans_expln\n",
    "\n",
    "    def generate_LRP(self, input_ids, attention_mask,\n",
    "                     index=None, start_layer=11):\n",
    "        \n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cams = []\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "        for blk in blocks:\n",
    "            grad = blk.attention.self.get_attn_gradients()\n",
    "            cam = blk.attention.self.get_attn_cam()\n",
    "            cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1])\n",
    "            grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1])\n",
    "            cam = grad * cam\n",
    "            cam = cam.clamp(min=0).mean(dim=0)\n",
    "            cams.append(cam.unsqueeze(0))\n",
    "        rollout = compute_rollout_attention(cams, start_layer=start_layer)\n",
    "        rollout[:, 0, 0] = 0\n",
    "        return rollout[:, 0]\n",
    "\n",
    "    def generate_LRP_last_layer(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn_cam()[0]\n",
    "        cam = cam.clamp(min=0).mean(dim=0).unsqueeze(0)\n",
    "        cam[:, 0, 0] = 0\n",
    "        return cam[:, 0]\n",
    "\n",
    "    def generate_full_lrp(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        cam = self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "        cam = cam.sum(dim=2)\n",
    "        cam[:, 0] = 0\n",
    "        return cam\n",
    "\n",
    "    def generate_attn_last_layer(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn()[0]\n",
    "        cam = cam.mean(dim=0).unsqueeze(0)\n",
    "        cam[:, 0, 0] = 0\n",
    "        return cam[:, 0]\n",
    "\n",
    "    def generate_rollout(self, input_ids, attention_mask, start_layer=0, index=None):\n",
    "        self.model.zero_grad()\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "        all_layer_attentions = []\n",
    "        for blk in blocks:\n",
    "            attn_heads = blk.attention.self.get_attn()\n",
    "            avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach()\n",
    "            all_layer_attentions.append(avg_heads)\n",
    "        rollout = compute_rollout_attention(all_layer_attentions, start_layer=start_layer)\n",
    "        rollout[:, 0, 0] = 0\n",
    "        return rollout[:, 0]\n",
    "\n",
    "    def generate_attn_gradcam(self, input_ids, attention_mask, index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn()\n",
    "        grad = self.model.bert.encoder.layer[-1].attention.self.get_attn_gradients()\n",
    "\n",
    "        cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1])\n",
    "        grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1])\n",
    "        grad = grad.mean(dim=[1, 2], keepdim=True)\n",
    "        cam = (cam * grad).mean(0).clamp(min=0).unsqueeze(0)\n",
    "        cam = (cam - cam.min()) / (cam.max() - cam.min())\n",
    "        cam[:, 0, 0] = 0\n",
    "        \n",
    "        return cam[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "584744a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_explns(explanations, input_ids, attention_mask, start_layer=0, true_class = 1, is_true = True):\n",
    "    \n",
    "    if is_true:\n",
    "        # TransCAM\n",
    "        TransCAM_expln = explanations.generate_TransCAM(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class, start_layer=start_layer)\n",
    "        # LRP\n",
    "        LRP_expln = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class, start_layer=start_layer)[0]\n",
    "        # PartialLRP\n",
    "        PartialLRP_expln = explanations.generate_LRP_last_layer(input_ids=input_ids, \n",
    "                                                     index=true_class, attention_mask=attention_mask)[0]\n",
    "        # FullLRP\n",
    "        # FullLRP_expln = explanations.generate_full_lrp(input_ids=input_ids, attention_mask=attention_mask, \n",
    "        #                                           index=true_class)[0]\n",
    "        # Att\n",
    "        Att_expln = explanations.generate_attn_last_layer(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class)[0]\n",
    "        # Rollout\n",
    "        Rollout_expln = explanations.generate_rollout(input_ids=input_ids, attention_mask=attention_mask,      \n",
    "                                                    index=true_class, start_layer=0)[0]\n",
    "        # Att_Gradcam\n",
    "        # Att_Gradcam_expln = explanations.generate_attn_gradcam(input_ids=input_ids, attention_mask=attention_mask, \n",
    "        #                                            index=true_class)[0]    \n",
    "        \n",
    "    else:\n",
    "        true_class = 1-true_class\n",
    "        # TransCAM\n",
    "        TransCAM_expln = explanations.generate_TransCAM(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class, start_layer=start_layer)\n",
    "        # LRP\n",
    "        LRP_expln = explanations.generate_LRP(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class, start_layer=start_layer)[0]\n",
    "        # PartialLRP\n",
    "        PartialLRP_expln = explanations.generate_LRP_last_layer(input_ids=input_ids, \n",
    "                                                    index=true_class, attention_mask=attention_mask)[0]\n",
    "        # FullLRP\n",
    "        # FullLRP_expln = explanations.generate_full_lrp(input_ids=input_ids, attention_mask=attention_mask, \n",
    "        #                                            index=true_class)[0]\n",
    "        # Att\n",
    "        Att_expln = explanations.generate_attn_last_layer(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class)[0]\n",
    "        # Rollout\n",
    "        Rollout_expln = explanations.generate_rollout(input_ids=input_ids, attention_mask=attention_mask, \n",
    "                                                    index=true_class, start_layer=0)[0]\n",
    "        # Att_Gradcam\n",
    "        # Att_Gradcam_expln = explanations.generate_attn_gradcam(input_ids=input_ids, attention_mask=attention_mask, \n",
    "        #                                            index=true_class)[0]\n",
    "    \n",
    "    # return TransCAM_expln, LRP_expln, PartialLRP_expln, FullLRP_expln, Att_expln, Rollout_expln, Att_Gradcam_expln\n",
    "    return TransCAM_expln, Att_expln, PartialLRP_expln, Rollout_expln, LRP_expln"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8e25ad8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_aopc(original_probs, degradation_probs):\n",
    "    original_probs = np.array(original_probs)\n",
    "    degradation_probs = np.array(degradation_probs)\n",
    "    \n",
    "    diffs = []\n",
    "    for i in range(len(original_probs)):\n",
    "        diffs_k = []\n",
    "        for j in range(9):\n",
    "            diff = original_probs[i] - degradation_probs[i][j]\n",
    "            diffs_k.append(np.abs(diff))\n",
    "        diffs.append(diffs_k)\n",
    "\n",
    "    result = np.mean(diffs, axis=0)\n",
    "    aopc = np.mean(result)\n",
    "    \n",
    "    return aopc\n",
    "\n",
    "def cal_logodds(original_probs, degradation_probs):\n",
    "    original_probs = np.array(original_probs)\n",
    "    degradation_probs = np.array(degradation_probs)\n",
    "    \n",
    "    ratios = []\n",
    "    for i in range(len(original_probs)):\n",
    "        ratios_k = []\n",
    "        for j in range(9):\n",
    "            ratio = math.log(degradation_probs[i][j] / original_probs[i])\n",
    "            ratios_k.append(ratio)\n",
    "        ratios.append(ratios_k)\n",
    "\n",
    "    result = np.mean(ratios, axis=0)\n",
    "    logodds = np.mean(result)\n",
    "    \n",
    "    return logodds\n",
    "\n",
    "def cal_kendaltau(attribution1, attribution2,):\n",
    "\n",
    "    sorted_idx1 = np.argsort(-attribution1)\n",
    "    sorted_idx2 = np.argsort(-attribution2)\n",
    "\n",
    "    tau, p_value = stats.kendalltau(sorted_idx1, sorted_idx2)\n",
    "    \n",
    "    return tau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "1d2d33cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, explanations, test_data, degrade_step = 10, seg_ids=None):\n",
    "    \n",
    "    original_probs = []\n",
    "    original_accs = [] \n",
    "    \n",
    "    degradation_probs_TransCAM = []\n",
    "    degradation_accs_TransCAM = []\n",
    "    del_probs_TransCAM = []\n",
    "    del_accs_TransCAM = []\n",
    "    \n",
    "    degradation_probs_Rawatt = []\n",
    "    degradation_accs_Rawatt = []\n",
    "    del_probs_Rawatt = []\n",
    "    del_accs_Rawatt = []\n",
    "    \n",
    "    degradation_probs_PartialLRP = []\n",
    "    degradation_accs_PartialLRP = []\n",
    "    del_probs_PartialLRP = []\n",
    "    del_accs_PartialLRP = []\n",
    "    \n",
    "    degradation_probs_Rollout = []\n",
    "    degradation_accs_Rollout = []\n",
    "    del_probs_Rollout = []\n",
    "    del_accs_Rollout = []\n",
    "    \n",
    "    degradation_probs_LRP = []\n",
    "    degradation_accs_LRP = []\n",
    "    del_probs_LRP = []\n",
    "    del_accs_LRP = []\n",
    "    \n",
    "    kendaltaus_TransCAM = []\n",
    "    kendaltaus_Rawatt = []\n",
    "    kendaltaus_PartialLRP = []\n",
    "    kendaltaus_Rollout = []\n",
    "    kendaltaus_LRP = []\n",
    "    \n",
    "    for i, test_instance in enumerate(test_data):\n",
    "        \n",
    "        text = test_instance['sentence']\n",
    "        target = test_instance['label'] \n",
    "\n",
    "        text_ids, att_mask, text_words = preprocess_sample(text)\n",
    "        \n",
    "        # get truc words number\n",
    "        total_len = len(text_words)\n",
    "        if total_len< 10: \n",
    "            continue\n",
    "        granularity = np.linspace(0, 1, degrade_step)\n",
    "        trunc_words_num = [int(g) for g in np.round(granularity*total_len)]\n",
    "        trunc_words_num = list(dict.fromkeys(trunc_words_num))\n",
    "        \n",
    "        original_class, original_prob = predict(model, text_ids, target)\n",
    "        \n",
    "        # get attributions\n",
    "        attribution_TransCAM, attribution_Rawatt, attribution_PartialLRP, attribution_Rollout, attribution_LRP = \\\n",
    "        generate_explns(explanations, text_ids, att_mask, start_layer=0, true_class = target, is_true = True) \n",
    "        \n",
    "        attribution_TransCAM_F, attribution_Rawatt_F, attribution_PartialLRP_F, attribution_Rollout_F, attribution_LRP_F = \\\n",
    "        generate_explns(explanations, text_ids, att_mask, start_layer=0, true_class = target, is_true = False) \n",
    "        \n",
    "        # conver to cpu numpy\n",
    "        attribution_TransCAM = attribution_TransCAM.cpu().detach().numpy()\n",
    "        attribution_Rawatt = attribution_Rawatt.cpu().detach().numpy()\n",
    "        attribution_PartialLRP = attribution_PartialLRP.cpu().detach().numpy()\n",
    "        attribution_Rollout = attribution_Rollout.cpu().detach().numpy()\n",
    "        attribution_LRP = attribution_LRP.cpu().detach().numpy()\n",
    "        \n",
    "        # conver to cpu numpy\n",
    "        attribution_TransCAM_F = attribution_TransCAM_F.cpu().detach().numpy()\n",
    "        attribution_Rawatt_F = attribution_Rawatt_F.cpu().detach().numpy()\n",
    "        attribution_PartialLRP_F = attribution_PartialLRP_F.cpu().detach().numpy()\n",
    "        attribution_Rollout_F = attribution_Rollout_F.cpu().detach().numpy()\n",
    "        attribution_LRP_F = attribution_LRP_F.cpu().detach().numpy()\n",
    "        \n",
    "        # get sorted_idx\n",
    "        sorted_idx_TransCAM = np.argsort(-attribution_TransCAM)\n",
    "        sorted_idx_Rawatt = np.argsort(-attribution_Rawatt)\n",
    "        sorted_idx_PartialLRP = np.argsort(-attribution_PartialLRP)\n",
    "        sorted_idx_Rollout = np.argsort(-attribution_Rollout)\n",
    "        sorted_idx_LRP = np.argsort(-attribution_LRP)\n",
    "        \n",
    "        instance_degradation_probs_TransCAM = []\n",
    "        instance_degradation_accs_TransCAM = []\n",
    "        instance_replace_probs_TransCAM = []\n",
    "        instance_replace_accs_TransCAM = []\n",
    "        \n",
    "        instance_degradation_probs_Rawatt = []\n",
    "        instance_degradation_accs_Rawatt = []\n",
    "        instance_replace_probs_Rawatt = []\n",
    "        instance_replace_accs_Rawatt = []\n",
    "        \n",
    "        instance_degradation_probs_PartialLRP = []\n",
    "        instance_degradation_accs_PartialLRP = []\n",
    "        instance_replace_probs_PartialLRP = []\n",
    "        instance_replace_accs_PartialLRP = []\n",
    "        \n",
    "        instance_degradation_probs_Rollout = []\n",
    "        instance_degradation_accs_Rollout = []\n",
    "        instance_replace_probs_Rollout = []\n",
    "        instance_replace_accs_Rollout = []\n",
    "        \n",
    "        instance_degradation_probs_LRP = []\n",
    "        instance_degradation_accs_LRP = []\n",
    "        instance_replace_probs_LRP = []\n",
    "        instance_replace_accs_LRP = []\n",
    "\n",
    "        for num in trunc_words_num[1:]: #exclude 0\n",
    "            \n",
    "            # TransCAM\n",
    "            truncated_text_ids_TransCAM, _, _ = truncate_words(sorted_idx_TransCAM, text_words, text_ids, \n",
    "                                                                                        num, seg_ids=seg_ids)\n",
    "            replaced_text_ids_TransCAM, _ = replace_words(sorted_idx_TransCAM, text_words, text_ids, num, mask, mask_id)\n",
    "           \n",
    "            trunc_class_TransCAM, trunc_prob_TransCAM = predict(model, truncated_text_ids_TransCAM, target, seg_ids=seg_ids)\n",
    "            rep_class_TransCAM, rep_prob_TransCAM = predict(model, replaced_text_ids_TransCAM, target, seg_ids=seg_ids)\n",
    "\n",
    "            instance_degradation_probs_TransCAM.append(trunc_prob_TransCAM)\n",
    "            instance_degradation_accs_TransCAM.append(trunc_class_TransCAM==target)\n",
    "            \n",
    "            instance_replace_probs_TransCAM.append(rep_prob_TransCAM)\n",
    "            instance_replace_accs_TransCAM.append(rep_class_TransCAM==target)\n",
    "            \n",
    "            # Rawatt\n",
    "            truncated_text_ids_Rawatt, _, _ = truncate_words(sorted_idx_Rawatt, text_words, text_ids, \n",
    "                                                                                       num, seg_ids=seg_ids)\n",
    "            replaced_text_ids_Rawatt, _ = replace_words(sorted_idx_Rawatt, text_words, text_ids, num, mask, mask_id)\n",
    "            \n",
    "            \n",
    "            trunc_class_Rawatt, trunc_prob_Rawatt = predict(model, truncated_text_ids_Rawatt, target, seg_ids=seg_ids)\n",
    "            rep_class_Rawatt, rep_prob_Rawatt = predict(model, replaced_text_ids_Rawatt, target, seg_ids=seg_ids)\n",
    "\n",
    "            instance_degradation_probs_Rawatt.append(trunc_prob_Rawatt)\n",
    "            instance_degradation_accs_Rawatt.append(trunc_class_Rawatt==target)\n",
    "            \n",
    "            instance_replace_probs_Rawatt.append(rep_prob_Rawatt)\n",
    "            instance_replace_accs_Rawatt.append(rep_class_Rawatt==target)\n",
    "            \n",
    "            # PartialLRP\n",
    "            truncated_text_ids_PartialLRP, _, _ = truncate_words(sorted_idx_PartialLRP, text_words, text_ids, \n",
    "                                                                                       num, seg_ids=seg_ids)\n",
    "            replaced_text_ids_PartialLRP, _ = replace_words(sorted_idx_PartialLRP, text_words, text_ids, num, mask, mask_id)\n",
    "            \n",
    "            trunc_class_PartialLRP, trunc_prob_PartialLRP = predict(model, truncated_text_ids_PartialLRP, target, seg_ids=seg_ids)\n",
    "            rep_class_PartialLRP, rep_prob_PartialLRP = predict(model, replaced_text_ids_PartialLRP, target, seg_ids=seg_ids)\n",
    "            \n",
    "            instance_degradation_probs_PartialLRP.append(trunc_prob_PartialLRP)\n",
    "            instance_degradation_accs_PartialLRP.append(trunc_class_PartialLRP==target)\n",
    "            \n",
    "            instance_replace_probs_PartialLRP.append(rep_prob_PartialLRP)\n",
    "            instance_replace_accs_PartialLRP.append(rep_class_PartialLRP==target)\n",
    "            \n",
    "            # Rollout\n",
    "            truncated_text_ids_Rollout, _, _ = truncate_words(sorted_idx_Rollout, text_words, text_ids, \n",
    "                                                                                       num, seg_ids=seg_ids)\n",
    "            replaced_text_ids_Rollout, _ = replace_words(sorted_idx_Rollout, text_words, text_ids, num, mask, mask_id)\n",
    "            \n",
    "            trunc_class_Rollout, trunc_prob_Rollout = predict(model, truncated_text_ids_Rollout, target, seg_ids=seg_ids)\n",
    "            rep_class_Rollout, rep_prob_Rollout = predict(model, replaced_text_ids_Rollout, target, seg_ids=seg_ids)\n",
    "            \n",
    "            instance_degradation_probs_Rollout.append(trunc_prob_Rollout)\n",
    "            instance_degradation_accs_Rollout.append(trunc_class_Rollout==target)\n",
    "            \n",
    "            instance_replace_probs_Rollout.append(rep_prob_Rollout)\n",
    "            instance_replace_accs_Rollout.append(rep_class_Rollout==target)\n",
    "            \n",
    "            # LRP\n",
    "            truncated_text_ids_LRP, _, _ = truncate_words(sorted_idx_LRP, text_words, text_ids, \n",
    "                                                                                       num, seg_ids=seg_ids)\n",
    "            replaced_text_ids_LRP, _ = replace_words(sorted_idx_LRP, text_words, text_ids, num, mask, mask_id)\n",
    "                \n",
    "            trunc_class_LRP, trunc_prob_LRP = predict(model, truncated_text_ids_LRP, target, seg_ids=seg_ids)\n",
    "            rep_class_LRP, rep_prob_LRP = predict(model, replaced_text_ids_LRP, target, seg_ids=seg_ids)\n",
    "\n",
    "            instance_degradation_probs_LRP.append(trunc_prob_LRP)\n",
    "            instance_degradation_accs_LRP.append(trunc_class_LRP==target)\n",
    "            \n",
    "            instance_replace_probs_LRP.append(rep_prob_LRP)\n",
    "            instance_replace_accs_LRP.append(rep_class_LRP==target)\n",
    "\n",
    "        original_probs.append(original_prob)\n",
    "        original_accs.append(original_class==target)\n",
    "        \n",
    "        degradation_probs_TransCAM.append(instance_degradation_probs_TransCAM)\n",
    "        degradation_accs_TransCAM.append(instance_degradation_accs_TransCAM)\n",
    "        del_probs_TransCAM.append(instance_replace_probs_TransCAM)\n",
    "        del_accs_TransCAM.append(instance_replace_accs_TransCAM)\n",
    "        \n",
    "        \n",
    "        degradation_probs_Rawatt.append(instance_degradation_probs_Rawatt)\n",
    "        degradation_accs_Rawatt.append(instance_degradation_accs_Rawatt)\n",
    "        del_probs_Rawatt.append(instance_replace_probs_Rawatt)\n",
    "        del_accs_Rawatt.append(instance_replace_accs_Rawatt)\n",
    "        \n",
    "        degradation_probs_PartialLRP.append(instance_degradation_probs_PartialLRP)\n",
    "        degradation_accs_PartialLRP.append(instance_degradation_accs_PartialLRP)\n",
    "        del_probs_PartialLRP.append(instance_replace_probs_PartialLRP)\n",
    "        del_accs_PartialLRP.append(instance_replace_accs_PartialLRP)\n",
    "        \n",
    "        degradation_probs_Rollout.append(instance_degradation_probs_Rollout)\n",
    "        degradation_accs_Rollout.append(instance_degradation_accs_Rollout)\n",
    "        del_probs_Rollout.append(instance_replace_probs_Rollout)\n",
    "        del_accs_Rollout.append(instance_replace_accs_Rollout)\n",
    "        \n",
    "        degradation_probs_LRP.append(instance_degradation_probs_LRP)\n",
    "        degradation_accs_LRP.append(instance_degradation_accs_LRP)\n",
    "        del_probs_LRP.append(instance_replace_probs_LRP)\n",
    "        del_accs_LRP.append(instance_replace_accs_LRP)\n",
    "        \n",
    "        \n",
    "        kendaltau_TransCAM = cal_kendaltau(attribution_TransCAM,attribution_TransCAM_F)\n",
    "        kendaltaus_TransCAM.append(kendaltau_TransCAM)      \n",
    "        \n",
    "        kendaltau_Rawatt = cal_kendaltau(attribution_Rawatt,attribution_Rawatt_F)\n",
    "        kendaltaus_Rawatt.append(kendaltau_Rawatt)      \n",
    "        \n",
    "        kendaltau_PartialLRP = cal_kendaltau(attribution_PartialLRP,attribution_PartialLRP_F)\n",
    "        kendaltaus_PartialLRP.append(kendaltau_PartialLRP)      \n",
    "        \n",
    "        kendaltau_Rollout = cal_kendaltau(attribution_Rollout,attribution_Rollout_F)\n",
    "        kendaltaus_Rollout.append(kendaltau_Rollout)      \n",
    "        \n",
    "        kendaltau_LRP = cal_kendaltau(attribution_LRP,attribution_LRP_F)\n",
    "        kendaltaus_LRP.append(kendaltau_LRP)      \n",
    "        \n",
    "    # get aopc score\n",
    "    aopc_TransCAM = cal_aopc(original_probs,degradation_probs_TransCAM)\n",
    "    aopc_Rawatt = cal_aopc(original_probs,degradation_probs_Rawatt)\n",
    "    aopc_PartialLRP = cal_aopc(original_probs,degradation_probs_PartialLRP)\n",
    "    aopc_Rollout = cal_aopc(original_probs,degradation_probs_Rollout)\n",
    "    aopc_LRP = cal_aopc(original_probs,degradation_probs_LRP)\n",
    "    \n",
    "    aopc_TransCAM_del = cal_aopc(original_probs,del_probs_TransCAM)\n",
    "    aopc_Rawatt_del = cal_aopc(original_probs,del_probs_Rawatt)\n",
    "    aopc_PartialLRP_del = cal_aopc(original_probs,del_probs_PartialLRP)\n",
    "    aopc_Rollout_del = cal_aopc(original_probs,del_probs_Rollout)\n",
    "    aopc_LRP_del = cal_aopc(original_probs,del_probs_LRP)\n",
    "        \n",
    "        \n",
    "    logodds_TransCAM = cal_logodds(original_probs,degradation_probs_TransCAM)\n",
    "    logodds_Rawatt = cal_logodds(original_probs,degradation_probs_Rawatt)\n",
    "    logodds_PartialLRP = cal_logodds(original_probs,degradation_probs_PartialLRP)\n",
    "    logodds_Rollout = cal_logodds(original_probs,degradation_probs_Rollout)\n",
    "    logodds_LRP = cal_logodds(original_probs,degradation_probs_LRP)\n",
    "    \n",
    "    logodds_TransCAM_del = cal_logodds(original_probs,del_probs_TransCAM)\n",
    "    logodds_Rawatt_del = cal_logodds(original_probs,del_probs_Rawatt)\n",
    "    logodds_PartialLRP_del = cal_logodds(original_probs,del_probs_PartialLRP)\n",
    "    logodds_Rollout_del = cal_logodds(original_probs,del_probs_Rollout)\n",
    "    logodds_LRP_del = cal_logodds(original_probs,del_probs_LRP)\n",
    "        \n",
    "            \n",
    "    # get kendaltau score    \n",
    "    k_TransCAM = np.mean(kendaltaus_TransCAM)\n",
    "    k_Rawatt = np.mean(kendaltaus_Rawatt)\n",
    "    k_PartialLRP = np.mean(kendaltaus_PartialLRP)\n",
    "    k_Rollout = np.mean(kendaltaus_Rollout)\n",
    "    k_LRP = np.mean(kendaltaus_LRP)\n",
    "\n",
    "        \n",
    "    return (aopc_TransCAM, aopc_Rawatt, aopc_PartialLRP, aopc_Rollout, aopc_LRP,\n",
    "            aopc_TransCAM_del, aopc_Rawatt_del, aopc_PartialLRP_del, aopc_Rollout_del, aopc_LRP_del,\n",
    "            k_TransCAM, k_Rawatt, k_PartialLRP, k_Rollout, k_LRP,\n",
    "            logodds_TransCAM, logodds_Rawatt, logodds_PartialLRP, logodds_Rollout, logodds_LRP,\n",
    "            logodds_TransCAM_del, logodds_Rawatt_del, logodds_PartialLRP_del, logodds_Rollout_del, logodds_LRP_del)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "5ede31c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the explanations generator\n",
    "explanations = Generator(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "35fae478",
   "metadata": {},
   "outputs": [],
   "source": [
    "# test_num = 200\n",
    "to_test = np.array(dataset['validation'])\n",
    "# to_test_idx = np.random.choice(len(dataset['validation']), test_num, replace=False)\n",
    "# to_test = to_test[to_test_idx]\n",
    "# print(len(to_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e950483c",
   "metadata": {},
   "outputs": [],
   "source": [
    "(aopc_TransCAM, aopc_Rawatt, aopc_PartialLRP, aopc_Rollout, aopc_LRP,\n",
    " aopc_TransCAM_del, aopc_Rawatt_del, aopc_PartialLRP_del, aopc_Rollout_del, aopc_LRP_del,\n",
    " k_TransCAM, k_Rawatt, k_PartialLRP, k_Rollout, k_LRP,\n",
    " logodds_TransCAM, logodds_Rawatt, logodds_PartialLRP, logodds_Rollout, logodds_LRP,\n",
    " logodds_TransCAM_del, logodds_Rawatt_del, logodds_PartialLRP_del, logodds_Rollout_del, logodds_LRP_del) = test(model, explanations, to_test, degrade_step = 10, seg_ids=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e34b492d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aopc_TransCAM,aopc_Rawatt,aopc_PartialLRP,aopc_Rollout,aopc_LRP)\n",
    "print(aopc_TransCAM_del,aopc_Rawatt_del,aopc_PartialLRP_del,aopc_Rollout_del,aopc_LRP_del)\n",
    "print(k_TransCAM,k_Rawatt,k_PartialLRP,k_Rollout,k_LRP)\n",
    "print(logodds_TransCAM, logodds_Rawatt, logodds_PartialLRP, logodds_Rollout, logodds_LRP)\n",
    "print(logodds_TransCAM_del, logodds_Rawatt_del, logodds_PartialLRP_del, logodds_Rollout_del, logodds_LRP_del)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dcdf73f",
   "metadata": {},
   "source": [
    "# Single Example Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "d704f19b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def expln_norm(expln):\n",
    "    expln = (expln - expln.min()) / (expln.max()- expln.min())\n",
    "    return expln\n",
    "\n",
    "def show_text_attr(expln,str_list,is_relu = True):\n",
    "    if is_relu:\n",
    "        rgb = lambda x: '0,0,0' if x < 0 else '0,255,0'\n",
    "        alpha = lambda x: max(x, 0)# ** 0.5\n",
    "    else:\n",
    "        rgb = lambda x: '255,0,0' if x < 0 else '0,255,0'\n",
    "        alpha = lambda x: x * -5 if x < 0 else x * 5\n",
    "    attrs = list(expln)\n",
    "    subwords = str_list\n",
    "    \n",
    "    token_marks = [\n",
    "        f'<mark style=\"background-color:rgba({rgb(attr)},{alpha(attr)})\">{token}</mark>'\n",
    "        for token, attr in zip(subwords, attrs)\n",
    "    ]\n",
    "    \n",
    "    display(HTML('<p>' + ' '.join(token_marks) + '</p>'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "8693c740",
   "metadata": {},
   "outputs": [],
   "source": [
    "text_ids, att_mask, text_words = preprocess_sample(to_test[15]['sentence'])\n",
    "label = to_test[15]['label'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "4c37cf47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#TransCAM_expln, LRP_expln, PartialLRP_expln, FullLRP_expln, Att_expln, Rollout_expln, Att_Gradcam_expln = \\\n",
    "        #generate_explns(explanations, text_ids, att_mask, start_layer=0, true_class = label, is_true = True) \n",
    "    \n",
    "TransCAM_expln, LRP_expln, PartialLRP_expln, Att_expln, Rollout_expln = \\\n",
    "        generate_explns(explanations, text_ids, att_mask, start_layer=0, true_class = label, is_true = True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ab1f539a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TransCAM_expln = expln_norm(TransCAM_expln)\n",
    "# show_text_attr(TransCAM_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "38658983",
   "metadata": {},
   "outputs": [],
   "source": [
    "# LRP_expln = expln_norm(LRP_expln)\n",
    "# show_text_attr(LRP_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4bba46ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PartialLRP_expln = expln_norm(PartialLRP_expln)\n",
    "# show_text_attr(PartialLRP_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1bb8055e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Att_expln = expln_norm(Att_expln)\n",
    "# show_text_attr(Att_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9982ec23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rollout_expln = expln_norm(Rollout_expln)\n",
    "# show_text_attr(Rollout_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "ccb2ead9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FullLRP_expln = expln_norm(FullLRP_expln)\n",
    "# show_text_attr(FullLRP_expln,text_words,is_relu = False)\n",
    "# Att_Gradcam_expln = expln_norm(Att_Gradcam_expln)\n",
    "# show_text_attr(Att_Gradcam_expln,text_words,is_relu = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "aeac11b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator:\n",
    "    def __init__(self, model):\n",
    "        self.model = model\n",
    "        self.model.eval()\n",
    "\n",
    "    def forward(self, input_ids, attention_mask):\n",
    "        return self.model(input_ids, attention_mask)\n",
    "\n",
    "    \n",
    "    def generate_TransCAM(self, input_ids, attention_mask,\n",
    "                          index=None, start_layer=0):\n",
    "\n",
    "        result = self.model(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)\n",
    "        \n",
    "        output = result[0]\n",
    "        hs = result[1]\n",
    "\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "\n",
    "        for blk_id in range(len(blocks)):\n",
    "            hs[blk_id].retain_grad()\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cams = {}\n",
    "        \n",
    "        for blk_id in range(len(blocks)):\n",
    "            hs_grads = hs[blk_id].grad\n",
    "            \n",
    "            att = blocks[blk_id].attention.self.get_attn().squeeze(0)\n",
    "            att = att.mean(dim=0)\n",
    "            att = att.mean(dim=0)\n",
    "            \n",
    "            cat = (hs_grads * hs[blk_id]).sum(dim=-1).squeeze(0)\n",
    "            cat = cat * att\n",
    "            \n",
    "            cams[blk_id] = cat\n",
    "            \n",
    "        trans_expln = sum(cams.values())\n",
    "\n",
    "        return trans_expln\n",
    "\n",
    "    def generate_LRP(self, input_ids, attention_mask,\n",
    "                     index=None, start_layer=11):\n",
    "        \n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cams = []\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "        for blk in blocks:\n",
    "            grad = blk.attention.self.get_attn_gradients()\n",
    "            cam = blk.attention.self.get_attn_cam()\n",
    "            cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1])\n",
    "            grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1])\n",
    "            cam = grad * cam\n",
    "            cam = cam.clamp(min=0).mean(dim=0)\n",
    "            cams.append(cam.unsqueeze(0))\n",
    "        rollout = compute_rollout_attention(cams, start_layer=start_layer)\n",
    "        rollout[:, 0, 0] = 0\n",
    "        return rollout[:, 0]\n",
    "\n",
    "    def generate_LRP_last_layer(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn_cam()[0]\n",
    "        cam = cam.clamp(min=0).mean(dim=0).unsqueeze(0)\n",
    "        cam[:, 0, 0] = 0\n",
    "        return cam[:, 0]\n",
    "\n",
    "    def generate_full_lrp(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        cam = self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "        cam = cam.sum(dim=2)\n",
    "        cam[:, 0] = 0\n",
    "        return cam\n",
    "\n",
    "    def generate_attn_last_layer(self, input_ids, attention_mask,\n",
    "                     index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn()[0]\n",
    "        cam = cam.mean(dim=0).unsqueeze(0)\n",
    "        cam[:, 0, 0] = 0\n",
    "        return cam[:, 0]\n",
    "\n",
    "    def generate_rollout(self, input_ids, attention_mask, start_layer=0, index=None):\n",
    "        self.model.zero_grad()\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        blocks = self.model.bert.encoder.layer\n",
    "        all_layer_attentions = []\n",
    "        for blk in blocks:\n",
    "            attn_heads = blk.attention.self.get_attn()\n",
    "            avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach()\n",
    "            all_layer_attentions.append(avg_heads)\n",
    "        rollout = compute_rollout_attention(all_layer_attentions, start_layer=start_layer)\n",
    "        rollout[:, 0, 0] = 0\n",
    "        return rollout[:, 0]\n",
    "\n",
    "    def generate_attn_gradcam(self, input_ids, attention_mask, index=None):\n",
    "        output = self.model(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        kwargs = {\"alpha\": 1}\n",
    "\n",
    "        if index == None:\n",
    "            index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "        one_hot[0, index] = 1\n",
    "        one_hot_vector = one_hot\n",
    "        one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "        one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "        self.model.zero_grad()\n",
    "        one_hot.backward(retain_graph=True)\n",
    "\n",
    "        self.model.relprop(torch.tensor(one_hot_vector).to(input_ids.device), **kwargs)\n",
    "\n",
    "        cam = self.model.bert.encoder.layer[-1].attention.self.get_attn()\n",
    "        grad = self.model.bert.encoder.layer[-1].attention.self.get_attn_gradients()\n",
    "\n",
    "        cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1])\n",
    "        grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1])\n",
    "        grad = grad.mean(dim=[1, 2], keepdim=True)\n",
    "        cam = (cam * grad).mean(0).clamp(min=0).unsqueeze(0)\n",
    "        cam = (cam - cam.min()) / (cam.max() - cam.min())\n",
    "        cam[:, 0, 0] = 0\n",
    "        \n",
    "        return cam[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "c18e4430",
   "metadata": {},
   "outputs": [],
   "source": [
    "text_batch = [\"I do not like this movie\"]\n",
    "encoding = tokenizer(text_batch, return_tensors='pt')\n",
    "\n",
    "input_ids = encoding['input_ids'].to(\"cuda\")\n",
    "attention_mask = encoding['attention_mask'].to(\"cuda\")\n",
    "attention_mask[0][0] = 0\n",
    "attention_mask[0][-1] = 0\n",
    "\n",
    "label = 0\n",
    "tokens = tokenizer.convert_ids_to_tokens(input_ids.flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "4cb96d37",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = model(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "245c4d17",
   "metadata": {},
   "outputs": [],
   "source": [
    "output = result[0]\n",
    "hs = result[1]\n",
    "\n",
    "kwargs = {\"alpha\": 1}\n",
    "\n",
    "blocks = model.bert.encoder.layer\n",
    "\n",
    "for blk_id in range(len(blocks)):\n",
    "    hs[blk_id].retain_grad()\n",
    "\n",
    "index = np.argmax(output.cpu().data.numpy(), axis=-1)\n",
    "\n",
    "one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)\n",
    "one_hot[0, index] = 1\n",
    "one_hot_vector = one_hot\n",
    "one_hot = torch.from_numpy(one_hot).requires_grad_(True)\n",
    "one_hot = torch.sum(one_hot.cuda() * output)\n",
    "\n",
    "model.zero_grad()\n",
    "one_hot.backward(retain_graph=True)\n",
    "\n",
    "model.relprop(torch.tensor(one_hot_vector).to(text_ids.device), **kwargs)\n",
    "\n",
    "cams = []\n",
    "\n",
    "for blk_id in range(len(blocks)):\n",
    "    hs_grads = hs[blk_id].grad\n",
    "\n",
    "    att = blocks[blk_id].attention.self.get_attn().squeeze(0)\n",
    "    att = att.mean(dim=0)\n",
    "    att = att.mean(dim=0)\n",
    "\n",
    "    cat = (hs_grads * hs[blk_id]).sum(dim=-1).squeeze(0)\n",
    "    cat = cat * att\n",
    "    cat = cat.cpu().detach().numpy()\n",
    "    cams.append(cat)\n",
    "    \n",
    "cams = np.array(cams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "9e23612e",
   "metadata": {},
   "outputs": [],
   "source": [
    "joint_attention = cams[0]\n",
    "for i in range(0+1, len(cams)):\n",
    "    joint_attention = np.multiply(cams[i],joint_attention)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "407dcbee",
   "metadata": {},
   "outputs": [],
   "source": [
    "camssum = cams.sum(axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "b3bab88e",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_cams = np.vstack([cams, joint_attention])\n",
    "new_cams = np.vstack([new_cams, camssum])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "f67f413a",
   "metadata": {},
   "outputs": [],
   "source": [
    "norm1 = new_cams / np.linalg.norm(new_cams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "dc67e50d",
   "metadata": {},
   "outputs": [],
   "source": [
    "yticklabels=['L'+str(i) for i in range(12)]\n",
    "yticklabels.append('Rollout')\n",
    "yticklabels.append('Sum')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "16bf61a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(font_scale=2)\n",
    "sns.set(rc = {'figure.figsize':(10,8)})\n",
    "ax = sns.heatmap(norm1, xticklabels = tokens, yticklabels=yticklabels,cmap=\"YlGnBu\", \n",
    "                 linewidths=0.1, annot=True, annot_kws={\"fontsize\":18, 'fontweight':'heavy'}, cbar_kws={\"values\":None, \"location\":'right',\n",
    "                                                            \"pad\":0.01}, fmt='.2f', cbar = True)\n",
    "\n",
    "ax.set_xticklabels(ax.get_xmajorticklabels(), fontsize = 18, fontweight = 'heavy')\n",
    "ax.set_yticklabels(ax.get_ymajorticklabels(), fontsize = 18, fontweight = 'heavy')\n",
    "\n",
    "cbar = ax.collections[0].colorbar\n",
    "cbar.ax.tick_params(labelsize=18)\n",
    "\n",
    "fig = ax.get_figure()\n",
    "fig.savefig('heatmap.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6c16461",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}