model_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\theor\\Documents\\Imperial\\NLP\\NLP_CW1\\venv\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from datasets import Dataset\n",
    "from transformers import DistilBertModel\n",
    "from torch.nn.functional import mse_loss\n",
    "from scipy.stats import spearmanr, pearsonr\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Trained Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "BATCH_SIZE = 4\n",
    "dev = Dataset.load_from_disk(\"data/dev\")\n",
    "dev_df = pd.DataFrame(dev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomBert(nn.Module):\n",
    "    def __init__(self, transformer_out=range(4, 7), dropout=0.1, class_weights=None):\n",
    "        super(CustomBert, self).__init__()\n",
    "        # Instead of just using the output of the final hidden layer,\n",
    "        # you can also pass in a range of hidden layers to concatenate their outputs\n",
    "        self.transformer_out = (\n",
    "            range(transformer_out, transformer_out + 1)\n",
    "            if isinstance(transformer_out, int)\n",
    "            else transformer_out\n",
    "        )\n",
    "        out_dim = len(self.transformer_out) * 768\n",
    "\n",
    "        # Use pretrained DistilBert. Force it to use our dropout\n",
    "        self.distilbert = DistilBertModel.from_pretrained(\n",
    "            \"distilbert-base-uncased\", output_hidden_states=True\n",
    "        )  # type: DistilBertModel\n",
    "        # for module in self.distilbert.modules():\n",
    "        #     if isinstance(module, torch.nn.Dropout):\n",
    "        #         module.p = dropout\n",
    "\n",
    "        # Then apply a dense hidden layer down to 768, and a final layer down to 1\n",
    "        self.feedforward = nn.Sequential(\n",
    "            nn.Linear(out_dim, 768),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(dropout),\n",
    "            nn.Linear(768, 1),\n",
    "        )\n",
    "\n",
    "        if class_weights is not None:\n",
    "            self.class_weights = class_weights\n",
    "            self.pos_weight = class_weights[1] / class_weights[0]\n",
    "\n",
    "    def forward(self, input_ids, attention_mask, labels=None):\n",
    "        outputs = self.distilbert(input_ids=input_ids, attention_mask=attention_mask)\n",
    "\n",
    "        # Recommended pooling approach for DistilBert is to average over the hidden state sequence\n",
    "        # instead of outputs.last_hidden_state[:, 0], which is used for Bert which uses [CLS] token\n",
    "        pooled_output = []\n",
    "        for i in self.transformer_out:\n",
    "            hs = outputs.hidden_states[i]\n",
    "            mask = attention_mask.unsqueeze(-1)\n",
    "            hs = hs * mask\n",
    "            mean_hs = hs.sum(dim=1) / mask.sum(dim=1)\n",
    "            pooled_output.append(mean_hs)\n",
    "\n",
    "        # We also concatenate the outputs of multiple layers if chosen by the user\n",
    "        cat_output = torch.cat(pooled_output, dim=1)\n",
    "\n",
    "        # Apply dense feedforward\n",
    "        y = self.feedforward(cat_output).squeeze(-1)\n",
    "\n",
    "        # Outside the Trainer, we return the predictions\n",
    "        if labels is None:\n",
    "            return y\n",
    "\n",
    "        # Inside the Trainer, we also need to return the loss\n",
    "        global binary_classifier\n",
    "        if binary_classifier:\n",
    "            loss = F.binary_cross_entropy_with_logits(\n",
    "                y, labels, pos_weight=self.pos_weight\n",
    "            )\n",
    "        else:\n",
    "            loss = mse_loss(y, labels, reduction=\"none\")\n",
    "            weights = self.class_weights[labels.long()]\n",
    "            loss = loss * weights\n",
    "            loss = loss.mean()\n",
    "        return loss, y\n",
    "\n",
    "    def freeze(self):\n",
    "        for param in self.distilbert.parameters():\n",
    "            param.requires_grad = False\n",
    "\n",
    "    def unfreeze(self, layer=None):\n",
    "        if layer is not None and layer < 0:\n",
    "            return\n",
    "\n",
    "        for name, param in self.distilbert.named_parameters():\n",
    "            if layer is None or name.startswith(f\"transformer.layer.{layer}\"):\n",
    "                param.requires_grad = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the same hyperparamters for defining the model\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "\n",
    "train = Dataset.load_from_disk(\"data/train\")\n",
    "labels = train[\"labels\"]\n",
    "dropout = 0.1\n",
    "class_weights = torch.tensor(compute_class_weight(\"balanced\", classes=np.unique(labels), y=labels)).to(DEVICE)\n",
    "transformer_out = range(4, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CustomBert(\n",
       "  (distilbert): DistilBertModel(\n",
       "    (embeddings): Embeddings(\n",
       "      (word_embeddings): Embedding(30522, 768, padding_idx=0)\n",
       "      (position_embeddings): Embedding(512, 768)\n",
       "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "      (dropout): Dropout(p=0.1, inplace=False)\n",
       "    )\n",
       "    (transformer): Transformer(\n",
       "      (layer): ModuleList(\n",
       "        (0-5): 6 x TransformerBlock(\n",
       "          (attention): MultiHeadSelfAttention(\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "            (q_lin): Linear(in_features=768, out_features=768, bias=True)\n",
       "            (k_lin): Linear(in_features=768, out_features=768, bias=True)\n",
       "            (v_lin): Linear(in_features=768, out_features=768, bias=True)\n",
       "            (out_lin): Linear(in_features=768, out_features=768, bias=True)\n",
       "          )\n",
       "          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "          (ffn): FFN(\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "            (lin1): Linear(in_features=768, out_features=3072, bias=True)\n",
       "            (lin2): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (activation): GELUActivation()\n",
       "          )\n",
       "          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (feedforward): Sequential(\n",
       "    (0): Linear(in_features=2304, out_features=768, bias=True)\n",
       "    (1): ReLU()\n",
       "    (2): Dropout(p=0.1, inplace=False)\n",
       "    (3): Linear(in_features=768, out_features=1, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = CustomBert(dropout=dropout,\n",
    "        class_weights = class_weights,\n",
    "        transformer_out=transformer_out,\n",
    "    ).to(DEVICE)\n",
    "\n",
    "# load in trained parameters\n",
    "checkpoint_fp = 'results/model.pth'\n",
    "checkpoint = torch.load(checkpoint_fp)\n",
    "model.load_state_dict(checkpoint)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Record basic test performance metrics of model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def torch_f1_score(pred_y, true_y):\n",
    "    tp = torch.sum((true_y == 1) & (pred_y == 1)).item()\n",
    "    fp = torch.sum((true_y == 0) & (pred_y == 1)).item()\n",
    "    fn = torch.sum((true_y == 1) & (pred_y == 0)).item()\n",
    "    return tp / (tp + 0.5 * (fp + fn))\n",
    "\n",
    "def torch_recall(pred_y, true_y):\n",
    "    tp = torch.sum((true_y == 1) & (pred_y == 1)).item()\n",
    "    fn = torch.sum((true_y == 1) & (pred_y == 0)).item()\n",
    "    return tp / (tp + fn)\n",
    "\n",
    "def torch_precision(pred_y, true_y):\n",
    "    tp = torch.sum((true_y == 1) & (pred_y == 1)).item()\n",
    "    fp = torch.sum((true_y == 0) & (pred_y == 1)).item()\n",
    "    return tp / (tp + fp)\n",
    "\n",
    "def torch_accuracy(pred_y, true_y):\n",
    "    return torch.sum(pred_y == true_y) / len(true_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Model is 0.9202483296394348\n",
      "Recall of Model is 0.5678391959798995\n",
      "Precision of Model is 0.5824742268041238\n",
      "F1 Score of Model is 0.5750636132315522\n"
     ]
    }
   ],
   "source": [
    "# generate classification evaluation metrics for model\n",
    "all_atten_masks = torch.LongTensor([ls for ls in dev_df.attention_mask.values])\n",
    "all_input_ids = torch.LongTensor([ls for ls in dev_df.input_ids.values])\n",
    "test_y = torch.LongTensor(dev_df.pcl)\n",
    "completed_n = 0\n",
    "all_pred = torch.empty(len(all_atten_masks))\n",
    "while completed_n < len(all_atten_masks):\n",
    "    batch_atten_masks = all_atten_masks[completed_n: completed_n+BATCH_SIZE].to(DEVICE)\n",
    "    batch_input_ids = all_input_ids[completed_n: completed_n+BATCH_SIZE].to(DEVICE)\n",
    "    all_pred[completed_n: completed_n+BATCH_SIZE] = (model(batch_input_ids, batch_atten_masks).cpu().detach().flatten() > 1.5) \n",
    "    torch.cuda.empty_cache()\n",
    "    completed_n += BATCH_SIZE\n",
    "\n",
    "print(f'Accuracy of Model is {torch_accuracy(all_pred, test_y)}')\n",
    "print(f'Recall of Model is {torch_recall(all_pred, test_y)}')\n",
    "print(f'Precision of Model is {torch_precision(all_pred, test_y)}')\n",
    "print(f'F1 Score of Model is {torch_f1_score(all_pred, test_y)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy_by_group(group_df):\n",
    "    n_correct_pred = 0\n",
    "    atten_masks = torch.LongTensor([ls for ls in group_df.attention_mask.values])\n",
    "    input_ids = torch.LongTensor([ls for ls in group_df.input_ids.values])\n",
    "    completed_batches = 0\n",
    "    while completed_batches < len(atten_masks):\n",
    "        batch_atten_masks = atten_masks[completed_batches:completed_batches+BATCH_SIZE].to(DEVICE)\n",
    "        batch_input_ids = input_ids[completed_batches:completed_batches+BATCH_SIZE].to(DEVICE)\n",
    "        predictions = model(batch_input_ids, batch_atten_masks).to('cpu').detach().numpy() > 1.5\n",
    "        n_correct_pred += np.sum(predictions == group_df['pcl'][completed_batches:completed_batches+BATCH_SIZE])\n",
    "        completed_batches += BATCH_SIZE\n",
    "    return n_correct_pred / len(group_df) if len(group_df) > 0 else -0.1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Performance by the Degree of PCL (Question 3a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate predictions and evaluate performance based on the degree of pcl\n",
    "pcl_levels = dev_df['labels'].unique()\n",
    "\n",
    "accuracy_by_pcl_level = []\n",
    "for pcl_level in pcl_levels:\n",
    "    dev_df_subset = dev_df[dev_df['labels'] == pcl_level]\n",
    "    accuracy = accuracy_by_group(dev_df_subset)\n",
    "    accuracy_by_pcl_level.append(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(pcl_levels, accuracy_by_pcl_level)\n",
    "\n",
    "plt.xlabel(\"PCL Score\", fontsize=16)\n",
    "plt.ylabel(\"Accuracy\", fontsize=16)\n",
    "\n",
    "plt.xticks(fontsize=14)\n",
    "plt.yticks(fontsize=14)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Performance by Length of Sequence (Question 3b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_accuracy_by_len(df):\n",
    "    all_text_len = sorted(df.text.apply(len).unique())\n",
    "\n",
    "    accuracy_by_len = []\n",
    "    for text_len in all_text_len:\n",
    "        dev_df_subset = df[df['text'].apply(len) == text_len]\n",
    "        accuracy = accuracy_by_group(dev_df_subset)\n",
    "        accuracy_by_len.append(accuracy)\n",
    "    return all_text_len, accuracy_by_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate predictions and evaluate performance based on the length of sequence\n",
    "all_text_len, accuracy_by_len = generate_accuracy_by_len(dev_df)\n",
    "pos_text_len, pos_accuracy_by_len = generate_accuracy_by_len(dev_df[dev_df['pcl'] == 1])\n",
    "neg_text_len, neg_accuracy_by_len = generate_accuracy_by_len(dev_df[dev_df['pcl'] == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearmans Correlation Coefficient (Monotonic Relationship):\n",
      "All Samples: SignificanceResult(statistic=0.08654821472882536, pvalue=0.04479567072851378)\n",
      "Positive Samples: SignificanceResult(statistic=-0.09648039133232716, pvalue=0.22195836562673707)\n",
      "Negative Samples: SignificanceResult(statistic=0.11148463934412298, pvalue=0.010728450694950698)\n"
     ]
    }
   ],
   "source": [
    "print('Spearmans Correlation Coefficient (Monotonic Relationship):')\n",
    "print(f\"All Samples: {spearmanr(all_text_len, accuracy_by_len)}\")\n",
    "print(f\"Positive Samples: {spearmanr(pos_text_len, pos_accuracy_by_len)}\")\n",
    "print(f\"Negative Samples: {spearmanr(neg_text_len, neg_accuracy_by_len)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearsons Correlation Coefficient (Linear Relationship):\n",
      "All Samples: PearsonRResult(statistic=-0.017133386947443582, pvalue=0.6917282990245093)\n",
      "Positive Samples: PearsonRResult(statistic=-0.06111132026856193, pvalue=0.4398068554735259)\n",
      "Negative Samples: PearsonRResult(statistic=0.030181934288886044, pvalue=0.4909857130957517)\n"
     ]
    }
   ],
   "source": [
    "print('Pearsons Correlation Coefficient (Linear Relationship):')\n",
    "print(f\"All Samples: {pearsonr(all_text_len, accuracy_by_len)}\")\n",
    "print(f\"Positive Samples: {pearsonr(pos_text_len, pos_accuracy_by_len)}\")\n",
    "print(f\"Negative Samples: {pearsonr(neg_text_len, neg_accuracy_by_len)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(all_text_len, accuracy_by_len, label='All Samples')\n",
    "plt.scatter(pos_text_len, pos_accuracy_by_len, label='Positive Samples')\n",
    "plt.scatter(neg_text_len, neg_accuracy_by_len, label='Negative Samples')\n",
    "\n",
    "plt.xlabel(\"Text Length\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate predictions and evaluate performance based on the length of sequence condition on degree of PCL\n",
    "text_len_dict = {}\n",
    "accuracy_by_len_dict = {}\n",
    "for pcl_lvl in range(5):\n",
    "    text_len_dict[pcl_lvl], accuracy_by_len_dict[pcl_lvl] = generate_accuracy_by_len(dev_df[dev_df['labels'] == pcl_lvl])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearsons Correlation Coefficient (Linear Relationship):\n",
      "PCL Level 0 Samples: SignificanceResult(statistic=0.06640165664271293, pvalue=0.13618773122148947)\n",
      "PCL Level 1 Samples: SignificanceResult(statistic=0.08270293172675057, pvalue=0.31598876457029074)\n",
      "PCL Level 2 Samples: SignificanceResult(statistic=-0.07312724241271305, pvalue=0.7878211152427433)\n",
      "PCL Level 3 Samples: SignificanceResult(statistic=-0.11498467957753924, pvalue=0.29468909010030103)\n",
      "PCL Level 4 Samples: SignificanceResult(statistic=-0.14793671173774092, pvalue=0.1847174059407381)\n"
     ]
    }
   ],
   "source": [
    "print('Pearsons Correlation Coefficient (Linear Relationship):')\n",
    "for pcl_lvl in range(5):\n",
    "    print(f\"PCL Level {pcl_lvl} Samples: {spearmanr(text_len_dict[pcl_lvl], accuracy_by_len_dict[pcl_lvl])}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearmans Correlation Coefficient (Monotonic Relationship):\n",
      "PCL Level 0 Samples: PearsonRResult(statistic=0.020383356675261092, pvalue=0.6476916402767066)\n",
      "PCL Level 1 Samples: PearsonRResult(statistic=0.09356844832976066, pvalue=0.2563662955589738)\n",
      "PCL Level 2 Samples: PearsonRResult(statistic=0.0018480492136785376, pvalue=0.9945804161315404)\n",
      "PCL Level 3 Samples: PearsonRResult(statistic=-0.10482285421806453, pvalue=0.3397075028942189)\n",
      "PCL Level 4 Samples: PearsonRResult(statistic=-0.09715618537685095, pvalue=0.38520987103992765)\n"
     ]
    }
   ],
   "source": [
    "print('Spearmans Correlation Coefficient (Monotonic Relationship):')\n",
    "for pcl_lvl in range(5):\n",
    "    print(f\"PCL Level {pcl_lvl} Samples: {pearsonr(text_len_dict[pcl_lvl], accuracy_by_len_dict[pcl_lvl])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Investigate Correlation between prediction and length of text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pos_prediction_rate_by_group(group_df):\n",
    "    n_pos_prediction = 0\n",
    "    atten_masks = torch.LongTensor([ls for ls in group_df.attention_mask.values]).to(DEVICE)\n",
    "    input_ids = torch.LongTensor([ls for ls in group_df.input_ids.values]).to(DEVICE)\n",
    "    completed_batches = 0\n",
    "    while completed_batches < len(atten_masks):\n",
    "        batch_atten_masks = atten_masks[completed_batches:completed_batches+BATCH_SIZE]\n",
    "        batch_input_ids = input_ids[completed_batches:completed_batches+BATCH_SIZE]\n",
    "        predictions = model(batch_input_ids, batch_atten_masks).to('cpu').detach().numpy() > 1.5\n",
    "        n_pos_prediction += np.sum(predictions)\n",
    "        completed_batches += BATCH_SIZE\n",
    "    return n_pos_prediction / len(group_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_pos_prediction_rate_by_len(df):\n",
    "    all_text_len = sorted(df.text.apply(len).unique())\n",
    "\n",
    "    pos_prediction_rate_by_len = []\n",
    "    for text_len in all_text_len:\n",
    "        dev_df_subset = df[df['text'].apply(len) == text_len]\n",
    "        pos_prediction_rate = pos_prediction_rate_by_group(dev_df_subset)\n",
    "        pos_prediction_rate_by_len.append(pos_prediction_rate)\n",
    "    return all_text_len, pos_prediction_rate_by_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_text_len, pos_prediction_rate_by_len = generate_pos_prediction_rate_by_len(dev_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PearsonRResult(statistic=0.023846599772299214, pvalue=0.5810101928237636)\n",
      "SignificanceResult(statistic=-0.10427866620318899, pvalue=0.015533321307298854)\n"
     ]
    }
   ],
   "source": [
    "print(pearsonr(all_text_len, pos_prediction_rate_by_len))\n",
    "print(spearmanr(all_text_len, pos_prediction_rate_by_len))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Performance by Keyword Category (Question 3c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_accuracy_by_keyword(df, all_keywords):\n",
    "    accuracy_by_keyword = {key: 0 for key in all_keywords}\n",
    "    for keyword in all_keywords:\n",
    "        dev_df_subset = df[df['keyword'] == keyword]\n",
    "        accuracy_by_keyword[keyword] = accuracy_by_group(dev_df_subset)\n",
    "    return accuracy_by_keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate predictions and evaluate performance based on the keyword\n",
    "all_keywords = sorted(dev_df['keyword'].unique())\n",
    "accuracy_by_keyword = generate_accuracy_by_keyword(dev_df, all_keywords)\n",
    "pos_accuracy_by_keyword = generate_accuracy_by_keyword(dev_df[dev_df['pcl'] == 1], all_keywords)\n",
    "neg_accuracy_by_keyword = generate_accuracy_by_keyword(dev_df[dev_df['pcl'] == 0], all_keywords)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 0.25\n",
    "x_axis = np.arange(len(all_keywords))\n",
    "\n",
    "plt.figure(figsize=(7, 5))\n",
    "plt.bar(x_axis, accuracy_by_keyword.values(), width=width, label='All Samples')\n",
    "plt.bar(x_axis + width, pos_accuracy_by_keyword.values(), width=width, label='Positive Samples')\n",
    "plt.bar(x_axis + width*2, neg_accuracy_by_keyword.values(), width=width, label='Negative Samples')\n",
    "\n",
    "plt.xticks(x_axis+width, all_keywords, rotation=90) \n",
    "plt.legend(loc='best',\n",
    "            bbox_to_anchor=(1.05, 1.12),\n",
    "             ncol=3, \n",
    "            fontsize=12)\n",
    "\n",
    "plt.xlabel(\"Category\", fontsize=15)\n",
    "plt.ylabel(\"Accuracy\", fontsize=15)\n",
    "\n",
    "plt.xticks(fontsize=12.5)\n",
    "plt.yticks(fontsize=13)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard deviation in accuracy across keywords (all samples) = 0.05008427616898172\n",
      "Standard deviation in accuracy across keywords (positive samples) = 0.165834121748858\n",
      "Standard deviation in accuracy across keywords (negative samples) = 0.03825371489049535\n"
     ]
    }
   ],
   "source": [
    "# Examine the variability of the test accuracy across different keywords\n",
    "print(f'Standard deviation in accuracy across keywords (all samples) = {np.std(list(accuracy_by_keyword.values()))}')\n",
    "print(f'Standard deviation in accuracy across keywords (positive samples) = {np.std(list(pos_accuracy_by_keyword.values()))}')\n",
    "print(f'Standard deviation in accuracy across keywords (negative samples) = {np.std(list(neg_accuracy_by_keyword.values()))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate predictions and evaluate performance based on the keyword condition on degree of PCL\n",
    "accuracy_by_keyword_dict = {}\n",
    "for pcl_lvl in range(5):\n",
    "    accuracy_by_keyword_dict[pcl_lvl] = generate_accuracy_by_keyword(dev_df[dev_df['labels'] == pcl_lvl], all_keywords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 1/6\n",
    "x_axis = np.arange(len(all_keywords))\n",
    "\n",
    "plt.figure(figsize=(12, 6))\n",
    "for pcl_lvl in range(5):\n",
    "    plt.bar(x_axis+width*pcl_lvl, accuracy_by_keyword_dict[pcl_lvl].values(), width=width, label=f'Lvl. {pcl_lvl}')\n",
    "\n",
    "\n",
    "plt.xlabel(\"Keyword\") \n",
    "plt.ylabel(\"Accuracy\") \n",
    "\n",
    "plt.xticks(x_axis+2*width, all_keywords) \n",
    "plt.legend(bbox_to_anchor=(1, 0.5))\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}