active_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:49:59.075163Z",
     "iopub.status.busy": "2022-05-31T12:49:59.065490Z",
     "iopub.status.idle": "2022-05-31T12:50:02.051950Z",
     "shell.execute_reply": "2022-05-31T12:50:02.050680Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "import json\n",
    "from modAL.models import ActiveLearner\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from modAL.uncertainty import uncertainty_sampling\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import wilcoxon\n",
    "from transformers import AutoModel, AutoTokenizer, AutoModelForMaskedLM\n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:02.059338Z",
     "iopub.status.busy": "2022-05-31T12:50:02.058127Z",
     "iopub.status.idle": "2022-05-31T12:50:02.062182Z",
     "shell.execute_reply": "2022-05-31T12:50:02.060821Z"
    }
   },
   "outputs": [],
   "source": [
    "negative_example_ids = []\n",
    "negative_example_json = json.load(open(\"negative_examples_100_2.json\"))\n",
    "for example in negative_example_json:\n",
    "    negative_example_ids.append((example[\"ap\"], example[\"technique\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:02.074988Z",
     "iopub.status.busy": "2022-05-31T12:50:02.073418Z",
     "iopub.status.idle": "2022-05-31T12:50:02.123608Z",
     "shell.execute_reply": "2022-05-31T12:50:02.122183Z"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"w_dict.json\", \"r\") as f:\n",
    "    w_dict = json.load(f)\n",
    "with open(\"ap_dict.json\", \"r\") as f:\n",
    "    ap_dict = json.load(f)\n",
    "with open(\"technique_dict.json\", \"r\") as f:\n",
    "    technique_dict = json.load(f)\n",
    "with open(\"tactic_dict.json\", \"r\") as f:\n",
    "    tactic_dict = json.load(f)\n",
    "with open(\"cwe_names.json\", \"r\") as f:\n",
    "    cwe_names = json.load(f)\n",
    "with open(\"ap_names.json\", \"r\") as f:\n",
    "    ap_names = json.load(f)\n",
    "with open(\"technique_names.json\", \"r\") as f:\n",
    "    technique_names = json.load(f)\n",
    "with open(\"tactic_names.json\", \"r\") as f:\n",
    "    tactic_names = json.load(f)\n",
    "with open(\"ap_mitigation_descriptions.json\", \"r\") as f:\n",
    "    ap_mitigation_descriptions = json.load(f)\n",
    "with open(\"cwe_mitigation_descriptions.json\", \"r\") as f:\n",
    "    cwe_mitigation_descriptions = json.load(f)\n",
    "with open(\"tech_mitigation_names.json\", \"r\") as f:\n",
    "    tech_mitigation_names = json.load(f)\n",
    "with open(\"tech_detection_names.json\", \"r\") as f:\n",
    "    tech_detection_names = json.load(f)\n",
    "with open(\"ap_detection_descriptions.json\", \"r\") as f:\n",
    "    ap_detection_descriptions = json.load(f)\n",
    "with open(\"cwe_detection_descriptions.json\", \"r\") as f:\n",
    "    cwe_detection_descriptions = json.load(f)\n",
    "\n",
    "f = open(\"cwe_mitigation_ids_temp.json\")\n",
    "w_mitigation = json.load(f)\n",
    "\n",
    "f = open(\"capec_mitigation_temp.json\")\n",
    "ap_mitigation = json.load(f)\n",
    "\n",
    "f = open(\"technique_mitigation_temp.json\")\n",
    "technique_mitigation = json.load(f)\n",
    "\n",
    "f = open(\"technique_detection_temp.json\")\n",
    "technique_detection = json.load(f)\n",
    "\n",
    "f = open(\"capec_detection_temp.json\")\n",
    "ap_detection = json.load(f)\n",
    "\n",
    "f = open(\"cwe_detection_temp.json\")\n",
    "w_detection = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:02.131210Z",
     "iopub.status.busy": "2022-05-31T12:50:02.129636Z",
     "iopub.status.idle": "2022-05-31T12:50:02.132572Z",
     "shell.execute_reply": "2022-05-31T12:50:02.133607Z"
    }
   },
   "outputs": [],
   "source": [
    "positive_example_ids = []\n",
    "for ap in ap_dict:\n",
    "    for technique in ap_dict[ap][\"techniques\"]:\n",
    "        positive_example_ids.append((ap, technique))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:02.139449Z",
     "iopub.status.busy": "2022-05-31T12:50:02.138170Z",
     "iopub.status.idle": "2022-05-31T12:50:02.142284Z",
     "shell.execute_reply": "2022-05-31T12:50:02.141000Z"
    }
   },
   "outputs": [],
   "source": [
    "example_ids = positive_example_ids + negative_example_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:02.148486Z",
     "iopub.status.busy": "2022-05-31T12:50:02.147206Z",
     "iopub.status.idle": "2022-05-31T12:50:04.526424Z",
     "shell.execute_reply": "2022-05-31T12:50:04.525671Z"
    }
   },
   "outputs": [],
   "source": [
    "encode = spacy.load(\"en_core_web_lg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:04.538937Z",
     "iopub.status.busy": "2022-05-31T12:50:04.537439Z",
     "iopub.status.idle": "2022-05-31T12:50:04.701730Z",
     "shell.execute_reply": "2022-05-31T12:50:04.702925Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountVectorizer()"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ap_name_vectorizer = CountVectorizer()\n",
    "ap_name_vectorizer.fit(ap_names)\n",
    "\n",
    "technique_name_vectorizer = CountVectorizer()\n",
    "technique_name_vectorizer.fit(technique_names)\n",
    "\n",
    "cwe_name_vectorizer = CountVectorizer()\n",
    "cwe_name_vectorizer.fit(cwe_names)\n",
    "\n",
    "tactic_name_vectorizer = CountVectorizer()\n",
    "tactic_name_vectorizer.fit(tactic_names)\n",
    "\n",
    "ap_mitigation_vectorizer = CountVectorizer()\n",
    "cwe_mitigation_vectorizer = CountVectorizer()\n",
    "tech_mitigation_vectorizer = CountVectorizer()\n",
    "\n",
    "ap_mitigation_vectorizer.fit(ap_mitigation_descriptions)\n",
    "cwe_mitigation_vectorizer.fit(cwe_mitigation_descriptions)\n",
    "tech_mitigation_vectorizer.fit(tech_mitigation_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:04.710530Z",
     "iopub.status.busy": "2022-05-31T12:50:04.709381Z",
     "iopub.status.idle": "2022-05-31T12:50:09.685240Z",
     "shell.execute_reply": "2022-05-31T12:50:09.684250Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "device = \"cpu\"\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-uncased\")\n",
    "pretrained_model = AutoModel.from_pretrained(\"bert-base-uncased\").to(device)\n",
    "\n",
    "model_path = \"bert_base\"\n",
    "finetuned_model = AutoModelForMaskedLM.from_pretrained(model_path).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:09.728126Z",
     "iopub.status.busy": "2022-05-31T12:50:09.689345Z",
     "iopub.status.idle": "2022-05-31T12:50:09.751186Z",
     "shell.execute_reply": "2022-05-31T12:50:09.750490Z"
    }
   },
   "outputs": [],
   "source": [
    "def vector_encoding(\n",
    "    encoding_type, text, vectorizer=None, bert_output_type=None, bert_finetuned=False\n",
    "):\n",
    "    if encoding_type == \"None\":\n",
    "        return text\n",
    "    elif encoding_type == \"BoW\":\n",
    "        return vectorizer_transform(text, vectorizer)\n",
    "    elif encoding_type == \"spaCy\":\n",
    "        return spaCy_vector(text)\n",
    "    elif encoding_type == \"BERT\":\n",
    "        if bert_finetuned:\n",
    "            model = finetuned_model\n",
    "        else:\n",
    "            model = pretrained_model\n",
    "\n",
    "        if bert_output_type == \"pooler_output\":\n",
    "            return get_pooler_output(model, text)\n",
    "        elif bert_output_type == \"hidden_state\":\n",
    "            return get_hidden_state(model, text)\n",
    "\n",
    "\n",
    "def vectorizer_transform(input_to_BoW, vectorizer):\n",
    "    return vectorizer.transform([input_to_BoW])[0].toarray().flatten()\n",
    "\n",
    "\n",
    "def spaCy_vector(text):\n",
    "    return encode(text).vector\n",
    "\n",
    "\n",
    "def get_pooler_output(model, text):\n",
    "    inputs = tokenizer(text.lower(), truncation=True, return_tensors=\"pt\").to(device)\n",
    "    outputs = model(**inputs)\n",
    "    pooled_output = outputs.pooler_output\n",
    "    return pooled_output.detach().cpu().numpy().flatten()\n",
    "\n",
    "\n",
    "def get_hidden_state(model, text):\n",
    "    inputs = tokenizer(text.lower(), truncation=True, return_tensors=\"pt\").to(device)\n",
    "    outputs = model(**inputs, output_hidden_states=True)\n",
    "    hidden_states = outputs.hidden_states\n",
    "    return hidden_states[-1][:, 0, :].detach().cpu().numpy().flatten()\n",
    "\n",
    "\n",
    "def append_data(\n",
    "    encoding_type,\n",
    "    data_combo,\n",
    "    ap,\n",
    "    technique,\n",
    "    bert_output_type=None,\n",
    "    bert_finetuned=False,\n",
    "):\n",
    "    output = []\n",
    "    vectorizer = CountVectorizer()\n",
    "    if data_combo == \"A0\":\n",
    "        vectorizer.fit(ap_names + technique_names)\n",
    "\n",
    "    elif data_combo == \"A1\":\n",
    "        vectorizer.fit(ap_names + technique_names + cwe_names + tactic_names)\n",
    "\n",
    "    elif data_combo == \"A1 + MI\":\n",
    "        vectorizer.fit(\n",
    "            ap_names\n",
    "            + technique_names\n",
    "            + cwe_names\n",
    "            + tactic_names\n",
    "            + cwe_mitigation_descriptions\n",
    "            + ap_mitigation_descriptions\n",
    "            + tech_mitigation_names\n",
    "        )\n",
    "\n",
    "    elif data_combo == \"A1 + D\":\n",
    "        vectorizer.fit(\n",
    "            ap_names\n",
    "            + technique_names\n",
    "            + cwe_names\n",
    "            + tactic_names\n",
    "            + cwe_detection_descriptions\n",
    "            + ap_detection_descriptions\n",
    "            + tech_detection_names\n",
    "        )\n",
    "\n",
    "    elif data_combo == \"A1 + MI + D\":\n",
    "        vectorizer.fit(\n",
    "            ap_names\n",
    "            + technique_names\n",
    "            + cwe_names\n",
    "            + tactic_names\n",
    "            + cwe_mitigation_descriptions\n",
    "            + ap_mitigation_descriptions\n",
    "            + tech_mitigation_names\n",
    "            + cwe_detection_descriptions\n",
    "            + ap_detection_descriptions\n",
    "            + tech_detection_names\n",
    "        )\n",
    "\n",
    "    output.append(ap_dict[ap][\"name\"])\n",
    "    output.append(technique_dict[technique][\"name\"])\n",
    "\n",
    "    if \"A1\" in data_combo:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            output.append(w_dict[cwe][\"name\"])\n",
    "\n",
    "        for tac in technique_dict[technique][\"tactics\"]:\n",
    "            output.append(tactic_dict[tac][\"name\"])\n",
    "\n",
    "    if data_combo in [\"A1 + MI\", \"A1 + MI + D\"]:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for mitigation in w_dict[cwe][\"mitigations\"]:\n",
    "                for cwe_mit in w_mitigation:\n",
    "                    if mitigation == cwe_mit[\"_id\"]:\n",
    "                        output.append(cwe_mit[\"metadata\"][\"Description\"])\n",
    "\n",
    "        for mitigation in ap_dict[ap][\"mitigations\"]:\n",
    "            for ap_mit in ap_mitigation:\n",
    "                if mitigation == ap_mit[\"_id\"]:\n",
    "                    output.append(ap_mit[\"metadata\"])\n",
    "\n",
    "        for mitigation in technique_dict[technique][\"mitigations\"]:\n",
    "            for tech_mit in technique_mitigation:\n",
    "                if mitigation == tech_mit[\"_id\"]:\n",
    "                    output.append(tech_mit[\"name\"])\n",
    "\n",
    "    if data_combo in [\"A1 + D\", \"A1 + MI + D\"]:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for detection in w_dict[cwe][\"detections\"]:\n",
    "                for cwe_det in w_detection:\n",
    "                    if detection == cwe_det[\"_id\"]:\n",
    "                        output.append(cwe_det[\"metadata\"][\"Description\"])\n",
    "\n",
    "        for detection in ap_dict[ap][\"detections\"]:\n",
    "            for ap_det in ap_detection:\n",
    "                if detection == ap_det[\"_id\"]:\n",
    "                    output.append(ap_det[\"metadata\"])\n",
    "\n",
    "        for detection in technique_dict[technique][\"detections\"]:\n",
    "            for tech_det in technique_mitigation:\n",
    "                if detection == tech_det[\"_id\"]:\n",
    "                    output.append(tech_det[\"metadata\"])\n",
    "\n",
    "    output = \" \".join(output)\n",
    "    return vector_encoding(\n",
    "        encoding_type, output, vectorizer, bert_output_type, bert_finetuned\n",
    "    )\n",
    "\n",
    "\n",
    "def handle_data(\n",
    "    encoding_type,\n",
    "    data_combo,\n",
    "    ap,\n",
    "    technique,\n",
    "    bert_output_type=None,\n",
    "    bert_finetuned=False,\n",
    "):\n",
    "    example = []\n",
    "    example.append(\n",
    "        vector_encoding(\n",
    "            encoding_type,\n",
    "            ap_dict[ap][\"name\"],\n",
    "            ap_name_vectorizer,\n",
    "            bert_output_type,\n",
    "            bert_finetuned,\n",
    "        )\n",
    "    )\n",
    "    example.append(\n",
    "        vector_encoding(\n",
    "            encoding_type,\n",
    "            technique_dict[technique][\"name\"],\n",
    "            technique_name_vectorizer,\n",
    "            bert_output_type,\n",
    "            bert_finetuned,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    if \"A1\" in data_combo:\n",
    "        tactics = []\n",
    "        for tac in technique_dict[technique][\"tactics\"]:\n",
    "            tactics.append(tactic_dict[tac][\"name\"])\n",
    "        tactics = \" \".join(tactics)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                tactics,\n",
    "                tactic_name_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        cwes = []\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            cwes.append(w_dict[cwe][\"name\"])\n",
    "        cwes = \" \".join(cwes)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                cwes,\n",
    "                cwe_name_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "    if data_combo in [\"A1 + MI\", \"A1 + MI + D\"]:\n",
    "        cwe_mitigations = []\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for mitigation in w_dict[cwe][\"mitigations\"]:\n",
    "                for cwe_mit in w_mitigation:\n",
    "                    if mitigation == cwe_mit[\"_id\"]:\n",
    "                        cwe_mitigations.append(cwe_mit[\"metadata\"][\"Description\"])\n",
    "        cwe_mitigations = \" \".join(cwe_mitigations)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                cwe_mitigations,\n",
    "                cwe_mitigation_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        capec_mitigations = []\n",
    "        for mitigation in ap_dict[ap][\"mitigations\"]:\n",
    "            for ap_mit in ap_mitigation:\n",
    "                if mitigation == ap_mit[\"_id\"]:\n",
    "                    capec_mitigations.append(ap_mit[\"metadata\"])\n",
    "        capec_mitigations = \" \".join(capec_mitigations)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                capec_mitigations,\n",
    "                ap_mitigation_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        tech_mitigations = []\n",
    "        for mitigation in technique_dict[technique][\"mitigations\"]:\n",
    "            for tech_mit in technique_mitigation:\n",
    "                if mitigation == tech_mit[\"_id\"]:\n",
    "                    tech_mitigations.append(tech_mit[\"name\"])\n",
    "        tech_mitigations = \" \".join(tech_mitigations)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                tech_mitigations,\n",
    "                tech_mitigation_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "    if data_combo in [\"A1 + D\", \"A1 + MI + D\"]:\n",
    "        cwe_detections = []\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for detection in w_dict[cwe][\"detections\"]:\n",
    "                for cwe_det in w_detection:\n",
    "                    if detection == cwe_det[\"_id\"]:\n",
    "                        cwe_detections.append(cwe_det[\"metadata\"][\"Description\"])\n",
    "\n",
    "        cwe_detections = \" \".join(cwe_detections)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                cwe_detections,\n",
    "                cwe_detection_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        capec_detections = []\n",
    "        for detection in ap_dict[ap][\"detections\"]:\n",
    "            for ap_det in ap_detection:\n",
    "                if detection == ap_det[\"_id\"]:\n",
    "                    capec_detections.append(ap_det[\"metadata\"])\n",
    "        capec_detections = \" \".join(capec_detections)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                capec_detections,\n",
    "                ap_detection_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        tech_detections = []\n",
    "        for detection in technique_dict[technique][\"detections\"]:\n",
    "            for tech_det in technique_detection:\n",
    "                if detection == tech_det[\"_id\"]:\n",
    "                    tech_detections.append(tech_det[\"name\"])\n",
    "        tech_detections = \" \".join(tech_detections)\n",
    "        example.append(\n",
    "            vector_encoding(\n",
    "                encoding_type,\n",
    "                tech_detections,\n",
    "                tech_detection_vectorizer,\n",
    "                bert_output_type,\n",
    "                bert_finetuned,\n",
    "            )\n",
    "        )\n",
    "\n",
    "    return np.hstack(example)\n",
    "\n",
    "\n",
    "def encode_data(\n",
    "    encoding_type,\n",
    "    data_combo,\n",
    "    ap,\n",
    "    technique,\n",
    "    bert_output_type=None,\n",
    "    bert_finetuned=False,\n",
    "):\n",
    "    example = []\n",
    "    example.append(\n",
    "        vector_encoding(\n",
    "            encoding_type,\n",
    "            ap_dict[ap][\"name\"],\n",
    "            ap_name_vectorizer,\n",
    "            bert_output_type,\n",
    "            bert_finetuned,\n",
    "        )\n",
    "    )\n",
    "    example.append(\n",
    "        vector_encoding(\n",
    "            encoding_type,\n",
    "            technique_dict[technique][\"name\"],\n",
    "            technique_name_vectorizer,\n",
    "            bert_output_type,\n",
    "            bert_finetuned,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    if \"A1\" in data_combo:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            example.append(\n",
    "                vector_encoding(\n",
    "                    encoding_type,\n",
    "                    w_dict[cwe][\"name\"],\n",
    "                    cwe_name_vectorizer,\n",
    "                    bert_output_type,\n",
    "                    bert_finetuned,\n",
    "                )\n",
    "            )\n",
    "\n",
    "        for tac in technique_dict[technique][\"tactics\"]:\n",
    "            example.append(\n",
    "                vector_encoding(\n",
    "                    encoding_type,\n",
    "                    tactic_dict[tac][\"name\"],\n",
    "                    tactic_name_vectorizer,\n",
    "                    bert_output_type,\n",
    "                    bert_finetuned,\n",
    "                )\n",
    "            )\n",
    "\n",
    "    if data_combo in [\"A1 + MI\", \"A1 + MI + D\"]:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for mitigation in w_dict[cwe][\"mitigations\"]:\n",
    "                for cwe_mit in w_mitigation:\n",
    "                    if mitigation == cwe_mit[\"_id\"]:\n",
    "                        example.append(\n",
    "                            vector_encoding(\n",
    "                                encoding_type,\n",
    "                                cwe_mit[\"metadata\"][\"Description\"],\n",
    "                                cwe_mitigation_vectorizer,\n",
    "                                bert_output_type,\n",
    "                                bert_finetuned,\n",
    "                            )\n",
    "                        )\n",
    "\n",
    "        for mitigation in ap_dict[ap][\"mitigations\"]:\n",
    "            for ap_mit in ap_mitigation:\n",
    "                if mitigation == ap_mit[\"_id\"]:\n",
    "                    example.append(\n",
    "                        vector_encoding(\n",
    "                            encoding_type,\n",
    "                            ap_mit[\"metadata\"],\n",
    "                            ap_mitigation_vectorizer,\n",
    "                            bert_output_type,\n",
    "                            bert_finetuned,\n",
    "                        )\n",
    "                    )\n",
    "\n",
    "        for mitigation in technique_dict[technique][\"mitigations\"]:\n",
    "            for tech_mit in technique_mitigation:\n",
    "                if mitigation == tech_mit[\"_id\"]:\n",
    "                    example.append(\n",
    "                        vector_encoding(\n",
    "                            encoding_type,\n",
    "                            tech_mit[\"name\"],\n",
    "                            tech_mitigation_vectorizer,\n",
    "                            bert_output_type,\n",
    "                            bert_finetuned,\n",
    "                        )\n",
    "                    )\n",
    "\n",
    "    if data_combo in [\"A1 + D\", \"A1 + MI + D\"]:\n",
    "        for cwe in ap_dict[ap][\"cwes\"]:\n",
    "            for detection in w_dict[cwe][\"detections\"]:\n",
    "                for cwe_det in w_detection:\n",
    "                    if detection == cwe_det[\"_id\"]:\n",
    "                        example.append(\n",
    "                            vector_encoding(\n",
    "                                encoding_type,\n",
    "                                cwe_det[\"metadata\"][\"Description\"],\n",
    "                                cwe_detection_vectorizer,\n",
    "                                bert_output_type,\n",
    "                                bert_finetuned,\n",
    "                            )\n",
    "                        )\n",
    "\n",
    "        for detection in ap_dict[ap][\"detections\"]:\n",
    "            for ap_det in ap_detection:\n",
    "                if detection == ap_det[\"_id\"]:\n",
    "                    example.append(\n",
    "                        vector_encoding(\n",
    "                            encoding_type,\n",
    "                            ap_det[\"metadata\"],\n",
    "                            ap_detection_vectorizer,\n",
    "                            bert_output_type,\n",
    "                            bert_finetuned,\n",
    "                        )\n",
    "                    )\n",
    "\n",
    "        for detection in technique_dict[technique][\"detections\"]:\n",
    "            for tech_det in technique_detection:\n",
    "                if detection == tech_det[\"_id\"]:\n",
    "                    example.append(\n",
    "                        vector_encoding(\n",
    "                            encoding_type,\n",
    "                            tech_det[\"name\"],\n",
    "                            tech_detection_vectorizer,\n",
    "                            bert_output_type,\n",
    "                            bert_finetuned,\n",
    "                        )\n",
    "                    )\n",
    "\n",
    "    return np.hstack(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:09.760465Z",
     "iopub.status.busy": "2022-05-31T12:50:09.759665Z",
     "iopub.status.idle": "2022-05-31T12:50:45.465693Z",
     "shell.execute_reply": "2022-05-31T12:50:45.466591Z"
    }
   },
   "outputs": [],
   "source": [
    "labels = []\n",
    "examples = []\n",
    "for i, (ap, technique) in enumerate(example_ids):\n",
    "    example = []\n",
    "    # examples.append(handle_data(\"BoW\", \"A1\", ap, technique))\n",
    "    examples.append(handle_data(\"spaCy\", \"A1 + MI\", ap, technique))\n",
    "    # examples.append(handle_data(\"BERT\", \"A1\", ap, technique, bert_output_type=\"hidden_state\", bert_finetuned=True))\n",
    "\n",
    "    if i < len(example_ids) / 2:\n",
    "        labels.append(1)\n",
    "    else:\n",
    "        labels.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:45.476686Z",
     "iopub.status.busy": "2022-05-31T12:50:45.471521Z",
     "iopub.status.idle": "2022-05-31T12:50:45.488908Z",
     "shell.execute_reply": "2022-05-31T12:50:45.488108Z"
    }
   },
   "outputs": [],
   "source": [
    "# Pool-based sampling based on https://modal-python.readthedocs.io/en/latest/content/examples/pool-based_sampling.html\n",
    "def active_learning(learner, X_train, y_train, X_test, y_test, initial_idx, n_initial):\n",
    "    X_pool, y_pool = np.delete(X_train, initial_idx, axis=0), np.delete(\n",
    "        y_train, initial_idx, axis=0\n",
    "    )\n",
    "\n",
    "    initial_train_score = learner.score(X_train, y_train)\n",
    "    initial_test_score = learner.score(X_test, y_test)\n",
    "\n",
    "    num_queries = len(X_train) - n_initial\n",
    "    train_accs = [initial_train_score]\n",
    "    test_accs = [initial_test_score]\n",
    "\n",
    "    for i in range(num_queries):\n",
    "        query_index, query_instance = learner.query(X_pool)\n",
    "\n",
    "        X, y = X_pool[query_index].reshape(1, -1), y_pool[query_index].reshape(\n",
    "            1,\n",
    "        )\n",
    "\n",
    "        learner.teach(X=X, y=y)\n",
    "\n",
    "        X_pool, y_pool = np.delete(X_pool, query_index, axis=0), np.delete(\n",
    "            y_pool, query_index\n",
    "        )\n",
    "\n",
    "        train_accs.append(learner.score(X_train, y_train))\n",
    "        test_accs.append(learner.score(X_test, y_test))\n",
    "\n",
    "    return train_accs, test_accs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T12:50:45.510986Z",
     "iopub.status.busy": "2022-05-31T12:50:45.509961Z",
     "iopub.status.idle": "2022-05-31T16:43:01.782170Z",
     "shell.execute_reply": "2022-05-31T16:43:01.780020Z"
    }
   },
   "outputs": [],
   "source": [
    "# Initial training set setup based on https://modal-python.readthedocs.io/en/latest/content/examples/interactive_labeling.html\n",
    "# Random sampling based on \"Replacing parts with your own solutions\" in https://github.com/modAL-python/modAL\n",
    "ratios = [0.25, 0.5, 0.75]\n",
    "results = {}\n",
    "for ratio in ratios:\n",
    "    results[str(ratio)] = {\n",
    "        \"train\": {\"uncertainty\": [], \"random\": []},\n",
    "        \"test\": {\"uncertainty\": [], \"random\": []},\n",
    "    }\n",
    "    for seed in range(100):\n",
    "        X_train, X_test, y_train, y_test = train_test_split(\n",
    "            np.array(examples), np.array(labels), test_size=0.3, random_state=seed\n",
    "        )\n",
    "        n_initial = round(ratio * len(X_train))\n",
    "        np.random.seed(seed)\n",
    "        initial_idx = np.random.choice(\n",
    "            range(len(X_train)), size=n_initial, replace=False\n",
    "        )\n",
    "        X_initial, y_initial = X_train[initial_idx], y_train[initial_idx]\n",
    "\n",
    "        uncertainty_learner = ActiveLearner(\n",
    "            estimator=RandomForestClassifier(random_state=seed),\n",
    "            X_training=X_initial,\n",
    "            y_training=y_initial,\n",
    "            query_strategy=uncertainty_sampling,\n",
    "        )\n",
    "\n",
    "        train_accs, test_accs = active_learning(\n",
    "            uncertainty_learner,\n",
    "            X_train,\n",
    "            y_train,\n",
    "            X_test,\n",
    "            y_test,\n",
    "            initial_idx,\n",
    "            n_initial,\n",
    "        )\n",
    "        results[str(ratio)][\"train\"][\"uncertainty\"].append(sum(train_accs))\n",
    "        results[str(ratio)][\"test\"][\"uncertainty\"].append(sum(test_accs))\n",
    "\n",
    "        def random_sampling(classifier, X):\n",
    "            index = np.random.choice(range(len(X)))\n",
    "            return index, X[index]\n",
    "\n",
    "        random_learner = ActiveLearner(\n",
    "            estimator=RandomForestClassifier(random_state=seed),\n",
    "            X_training=X_initial,\n",
    "            y_training=y_initial,\n",
    "            query_strategy=random_sampling,\n",
    "        )\n",
    "\n",
    "        train_accs, test_accs = active_learning(\n",
    "            random_learner, X_train, y_train, X_test, y_test, initial_idx, n_initial\n",
    "        )\n",
    "        results[str(ratio)][\"train\"][\"random\"].append(sum(train_accs))\n",
    "        results[str(ratio)][\"test\"][\"random\"].append(sum(test_accs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T16:43:01.792476Z",
     "iopub.status.busy": "2022-05-31T16:43:01.789254Z",
     "iopub.status.idle": "2022-05-31T16:43:01.796789Z",
     "shell.execute_reply": "2022-05-31T16:43:01.795637Z"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"active_learning_100_trials_spaCy_A1+MI.json\", \"w\") as f:\n",
    "    json.dump(results, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T16:43:01.802563Z",
     "iopub.status.busy": "2022-05-31T16:43:01.801386Z",
     "iopub.status.idle": "2022-05-31T16:43:01.809146Z",
     "shell.execute_reply": "2022-05-31T16:43:01.807999Z"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"active_learning_100_trials_BoW.json\", \"r\") as f:\n",
    "    results = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T16:43:01.818894Z",
     "iopub.status.busy": "2022-05-31T16:43:01.817389Z",
     "iopub.status.idle": "2022-05-31T16:43:01.827763Z",
     "shell.execute_reply": "2022-05-31T16:43:01.828737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratio:  0.25\n",
      "Dataset:  train\n",
      "Uncertainty mean  109.93815950920239\n",
      "Random mean  106.61680981595089\n",
      "p value  9.318997235593406e-18\n",
      "Dataset:  test\n",
      "Uncertainty mean  84.46957746478873\n",
      "Random mean  81.83676056338027\n",
      "p value  1.490247569483896e-07\n",
      "Ratio:  0.5\n",
      "Dataset:  train\n",
      "Uncertainty mean  76.93417177914111\n",
      "Random mean  75.43325153374231\n",
      "p value  5.112258973385463e-18\n",
      "Dataset:  test\n",
      "Uncertainty mean  57.738873239436614\n",
      "Random mean  56.18985915492957\n",
      "p value  1.830039780176053e-12\n",
      "Ratio:  0.75\n",
      "Dataset:  train\n",
      "Uncertainty mean  40.7979754601227\n",
      "Random mean  40.40687116564417\n",
      "p value  1.3324605170425474e-17\n",
      "Dataset:  test\n",
      "Uncertainty mean  29.683802816901412\n",
      "Random mean  29.43619718309859\n",
      "p value  0.0016644939117470405\n"
     ]
    }
   ],
   "source": [
    "for ratio in results:\n",
    "    print(\"Ratio: \", ratio)\n",
    "    for dataset in results[ratio]:\n",
    "        print(\"Dataset: \", dataset)\n",
    "        w, p = wilcoxon(\n",
    "            results[ratio][dataset][\"uncertainty\"], results[ratio][dataset][\"random\"]\n",
    "        )\n",
    "        print(\"Uncertainty mean \", np.mean(results[ratio][dataset][\"uncertainty\"]))\n",
    "        print(\"Random mean \", np.mean(results[ratio][dataset][\"random\"]))\n",
    "        print(\"p value \", p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T16:43:01.850320Z",
     "iopub.status.busy": "2022-05-31T16:43:01.849453Z",
     "iopub.status.idle": "2022-05-31T16:43:54.043529Z",
     "shell.execute_reply": "2022-05-31T16:43:54.042135Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    np.array(examples), np.array(labels), random_state=0\n",
    ")\n",
    "n_initial = round(0.5 * len(X_train))\n",
    "np.random.seed(0)\n",
    "initial_idx = np.random.choice(range(len(X_train)), size=n_initial, replace=False)\n",
    "X_initial, y_initial = X_train[initial_idx], y_train[initial_idx]\n",
    "\n",
    "uncertainty_learner = ActiveLearner(\n",
    "    estimator=RandomForestClassifier(random_state=0),\n",
    "    X_training=X_initial,\n",
    "    y_training=y_initial,\n",
    "    query_strategy=uncertainty_sampling,\n",
    ")\n",
    "\n",
    "\n",
    "def random_sampling(classifier, X):\n",
    "    index = np.random.choice(range(len(X)))\n",
    "    return index, X[index]\n",
    "\n",
    "\n",
    "train_uncertainty_accs, test_uncertainty_accs = active_learning(\n",
    "    uncertainty_learner, X_train, y_train, X_test, y_test, initial_idx, n_initial\n",
    ")\n",
    "\n",
    "random_learner = ActiveLearner(\n",
    "    estimator=RandomForestClassifier(random_state=0),\n",
    "    X_training=X_initial,\n",
    "    y_training=y_initial,\n",
    "    query_strategy=random_sampling,\n",
    ")\n",
    "\n",
    "train_random_accs, test_random_accs = active_learning(\n",
    "    random_learner, X_train, y_train, X_test, y_test, initial_idx, n_initial\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-31T16:43:54.087209Z",
     "iopub.status.busy": "2022-05-31T16:43:54.073862Z",
     "iopub.status.idle": "2022-05-31T16:43:54.256207Z",
     "shell.execute_reply": "2022-05-31T16:43:54.257279Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f84d3dfb6d8>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_random_accs, label=\"random sampling\")\n",
    "plt.plot(train_uncertainty_accs, label=\"uncertainty sampling\")\n",
    "plt.xlabel(\"Number of queries\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "98b0a9b7b4eaaa670588a142fd0a9b87eaafe866f1db4228be72b4211d12040f"
  },
  "kernelspec": {
   "display_name": "Python 3.7.10 64-bit ('base': conda)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}