CVSSV3prediction/predictionForCVSSVersion3UseLR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Software is free software released under the \"GNU General Public License v3.0\"\n",
    "\n",
    "Copyright (c) 2021 Yuning-Jiang - yuning.jiang17@gmail.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import re\n",
    "import json\n",
    "import zipfile\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import csv\n",
    "import unicodedata\n",
    "import itertools\n",
    "import logging\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "from typing import KeysView\n",
    "from pandas.core.frame import DataFrame\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.utils.multiclass import unique_labels\n",
    "from sklearn.metrics import precision_recall_fscore_support as score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer\n",
    "from sklearn.metrics import balanced_accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nvdcve-1.1-2021.json.zip\n",
      "nvdcve-1.1-2020.json.zip\n",
      "nvdcve-1.1-2019.json.zip\n",
      "nvdcve-1.1-2018.json.zip\n",
      "nvdcve-1.1-2017.json.zip\n",
      "nvdcve-1.1-2016.json.zip\n",
      "nvdcve-1.1-2015.json.zip\n",
      "nvdcve-1.1-2014.json.zip\n",
      "nvdcve-1.1-2013.json.zip\n",
      "nvdcve-1.1-2012.json.zip\n",
      "nvdcve-1.1-2011.json.zip\n",
      "nvdcve-1.1-2010.json.zip\n",
      "nvdcve-1.1-2009.json.zip\n",
      "nvdcve-1.1-2008.json.zip\n",
      "nvdcve-1.1-2007.json.zip\n",
      "nvdcve-1.1-2006.json.zip\n",
      "nvdcve-1.1-2005.json.zip\n",
      "nvdcve-1.1-2004.json.zip\n",
      "nvdcve-1.1-2003.json.zip\n",
      "nvdcve-1.1-2002.json.zip\n"
     ]
    }
   ],
   "source": [
    "#Download NVD data feeds in JSON format. Ensure you have a folder called \"zip\" in the same directory.\n",
    "def get_nvd_data():\n",
    "    r = requests.get('https://nvd.nist.gov/vuln/data-feeds#JSON_FEED')\n",
    "    for filename in re.findall(\"nvdcve-1.1-[0-9]*\\.json\\.zip\",r.text):\n",
    "        print(filename)\n",
    "        r_file = requests.get(\"https://nvd.nist.gov/feeds/json/cve/1.1/\" + filename, stream=True)\n",
    "        filePath = \"zipFile\"\n",
    "        if not os.path.exists(filePath):\n",
    "            os.makedirs(filePath)\n",
    "        with open(\"zipFile/\" + filename, 'wb') as f:\n",
    "            for chunk in r_file:\n",
    "                f.write(chunk)\n",
    "get_nvd_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: nvdcve-1.1-2002.json.zip\n",
      "Opening: nvdcve-1.1-2003.json.zip\n",
      "Opening: nvdcve-1.1-2004.json.zip\n",
      "Opening: nvdcve-1.1-2005.json.zip\n",
      "Opening: nvdcve-1.1-2006.json.zip\n",
      "Opening: nvdcve-1.1-2007.json.zip\n",
      "Opening: nvdcve-1.1-2008.json.zip\n",
      "Opening: nvdcve-1.1-2009.json.zip\n",
      "Opening: nvdcve-1.1-2010.json.zip\n",
      "Opening: nvdcve-1.1-2011.json.zip\n",
      "Opening: nvdcve-1.1-2012.json.zip\n",
      "Opening: nvdcve-1.1-2013.json.zip\n",
      "Opening: nvdcve-1.1-2014.json.zip\n",
      "Opening: nvdcve-1.1-2015.json.zip\n",
      "Opening: nvdcve-1.1-2016.json.zip\n",
      "Opening: nvdcve-1.1-2017.json.zip\n",
      "Opening: nvdcve-1.1-2018.json.zip\n",
      "Opening: nvdcve-1.1-2019.json.zip\n",
      "Opening: nvdcve-1.1-2020.json.zip\n",
      "Opening: nvdcve-1.1-2021.json.zip\n"
     ]
    }
   ],
   "source": [
    "#Extract the JSON files from .zip files.\n",
    "def unzip_data():\n",
    "    files = [f for f in listdir(\"zipFile/\") if isfile(join(\"zipFile/\", f))]\n",
    "    files.sort()\n",
    "    for file in files:\n",
    "        print(\"Opening: \" + file)\n",
    "        archive = zipfile.ZipFile(join(\"zipFile/\", file), 'r')\n",
    "        filePath = \"jsonFile\"\n",
    "        if not os.path.exists(filePath):\n",
    "            os.makedirs(filePath)\n",
    "        with archive as f:\n",
    "            f.extractall('jsonFile')\n",
    "unzip_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_nvd_dict(year):\n",
    "    filename = join(\"jsonFile/nvdcve-1.1-\" + str(year) + \".json\")\n",
    "    #print(\"Opening: \" + filename)\n",
    "    with open(filename, encoding=\"utf8\") as json_file:\n",
    "    \tcve_dict = json.load(json_file)\n",
    "    return(cve_dict)\n",
    "\n",
    "def generate_CVSSV3csv_for_training():\n",
    "    list = listdir(\"jsonFile/\")\n",
    "    number_files = len(list)\n",
    "    for year in range(2002,2002 + number_files):\n",
    "        year_in_string = str(year)\n",
    "        cve_dict = create_nvd_dict(year)\n",
    "        fileName = 'NVD_'+ year_in_string + '_CVSSV3_train.csv'\n",
    "        with open('trainCVSSV3/' + fileName, 'w', newline='') as f_output:\n",
    "            csv_output = csv.writer(f_output)\n",
    "            csv_output.writerow(['CVE_ID', 'PublishTime','ModifyTime','Report','CVSSV3','AttackVector','AttackComplexity','PrivilegesRequired',\n",
    "                             'UserInteraction','Scope','ConfidentialityImpact','IntegrityImpact','AvailabilityImpact'])\n",
    "            for item in cve_dict['CVE_Items']:\n",
    "                cve_id = item['cve']['CVE_data_meta']['ID']\n",
    "                report = item['cve']['description']['description_data'][0]['value']\n",
    "                publish = item['publishedDate']\n",
    "                modify = item['lastModifiedDate']\n",
    "                if not report.find(\"**REJECT**\"):\n",
    "                    continue\n",
    "                if 'baseMetricV3' not in item['impact']:\n",
    "                    continue\n",
    "                elif 'baseMetricV3' in item['impact']:\n",
    "                    cvssv3_base_score = item['impact']['baseMetricV3']['cvssV3']['baseScore']\n",
    "                    attackVector = item['impact']['baseMetricV3']['cvssV3']['attackVector']\n",
    "                    attackComplexity = item['impact']['baseMetricV3']['cvssV3']['attackComplexity']\n",
    "                    privilegesRequired = item['impact']['baseMetricV3']['cvssV3']['privilegesRequired']\n",
    "                    userInteraction = item['impact']['baseMetricV3']['cvssV3']['userInteraction']\n",
    "                    scope = item['impact']['baseMetricV3']['cvssV3']['scope']\n",
    "                    confidentialityImpact = item['impact']['baseMetricV3']['cvssV3']['confidentialityImpact']\n",
    "                    integrityImpact = item['impact']['baseMetricV3']['cvssV3']['integrityImpact']\n",
    "                    availabilityImpact = item['impact']['baseMetricV3']['cvssV3']['availabilityImpact']\n",
    "\n",
    "                    csv_output.writerow([cve_id, publish, modify,report, cvssv3_base_score,\n",
    "                                 attackVector, attackComplexity, privilegesRequired, userInteraction,\n",
    "                                 scope, confidentialityImpact, integrityImpact, availabilityImpact])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "generate_CVSSV3csv_for_training()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate training dataset using NVD reports from 2002 to 2020.\n",
    "def generate_CombinedFile():\n",
    "    list = listdir(\"trainCVSSV3/\")\n",
    "    number_files = len(list)-1\n",
    "    dict = []\n",
    "    dict_of_reports = {}\n",
    "    for year in range(2002,2002 + number_files):\n",
    "        year_in_string = str(year)\n",
    "        file_name = 'NVD_'+ year_in_string + '_CVSSV3_train.csv'\n",
    "        dict_of_reports[year_in_string] = []\n",
    "        dict_of_reports[year_in_string] = pd.read_csv(\"trainCVSSV3/\" + file_name)\n",
    "        dict.append(dict_of_reports[year_in_string])\n",
    "    df = pd.concat(dict, ignore_index=True)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = generate_CombinedFile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Schema:\n",
      "\n",
      " CVE_ID                    object\n",
      "PublishTime               object\n",
      "ModifyTime                object\n",
      "Report                    object\n",
      "CVSSV3                   float64\n",
      "AttackVector              object\n",
      "AttackComplexity          object\n",
      "PrivilegesRequired        object\n",
      "UserInteraction           object\n",
      "Scope                     object\n",
      "ConfidentialityImpact     object\n",
      "IntegrityImpact           object\n",
      "AvailabilityImpact        object\n",
      "dtype: object\n",
      "Number of vulnerability reports,columns= (59401, 13)\n"
     ]
    }
   ],
   "source": [
    "print(\"Schema:\\n\\n\",df.dtypes)\n",
    "print(\"Number of vulnerability reports,columns=\",df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Schema:\n",
      "\n",
      " CVE_ID                    object\n",
      "PublishTime               object\n",
      "ModifyTime                object\n",
      "Report                    object\n",
      "CVSSV3                   float64\n",
      "AttackVector              object\n",
      "AttackComplexity          object\n",
      "PrivilegesRequired        object\n",
      "UserInteraction           object\n",
      "Scope                     object\n",
      "ConfidentialityImpact     object\n",
      "IntegrityImpact           object\n",
      "AvailabilityImpact        object\n",
      "dtype: object\n",
      "Number of vulnerability reports,columns= (77183, 13)\n"
     ]
    }
   ],
   "source": [
    "df = df[~df['Report'].str.contains('REJECT')]\n",
    "# print schema\n",
    "print(\"Schema:\\n\\n\",df.dtypes)\n",
    "print(\"Number of vulnerability reports,columns=\",df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CVE_ID</th>\n",
       "      <th>PublishTime</th>\n",
       "      <th>ModifyTime</th>\n",
       "      <th>Report</th>\n",
       "      <th>CVSSV3</th>\n",
       "      <th>AttackVector</th>\n",
       "      <th>AttackComplexity</th>\n",
       "      <th>PrivilegesRequired</th>\n",
       "      <th>UserInteraction</th>\n",
       "      <th>Scope</th>\n",
       "      <th>ConfidentialityImpact</th>\n",
       "      <th>IntegrityImpact</th>\n",
       "      <th>AvailabilityImpact</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>69013</th>\n",
       "      <td>CVE-2020-26130</td>\n",
       "      <td>2020-10-28T18:15Z</td>\n",
       "      <td>2021-07-21T11:39Z</td>\n",
       "      <td>Issues were discovered in Open TFTP Server mul...</td>\n",
       "      <td>7.8</td>\n",
       "      <td>LOCAL</td>\n",
       "      <td>LOW</td>\n",
       "      <td>LOW</td>\n",
       "      <td>NONE</td>\n",
       "      <td>UNCHANGED</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>HIGH</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14040</th>\n",
       "      <td>CVE-2017-0011</td>\n",
       "      <td>2017-03-17T00:59Z</td>\n",
       "      <td>2017-07-12T01:29Z</td>\n",
       "      <td>Microsoft Edge allows remote attackers to obta...</td>\n",
       "      <td>4.3</td>\n",
       "      <td>NETWORK</td>\n",
       "      <td>LOW</td>\n",
       "      <td>NONE</td>\n",
       "      <td>REQUIRED</td>\n",
       "      <td>UNCHANGED</td>\n",
       "      <td>LOW</td>\n",
       "      <td>NONE</td>\n",
       "      <td>NONE</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               CVE_ID        PublishTime         ModifyTime  \\\n",
       "69013  CVE-2020-26130  2020-10-28T18:15Z  2021-07-21T11:39Z   \n",
       "14040   CVE-2017-0011  2017-03-17T00:59Z  2017-07-12T01:29Z   \n",
       "\n",
       "                                                  Report  CVSSV3 AttackVector  \\\n",
       "69013  Issues were discovered in Open TFTP Server mul...     7.8        LOCAL   \n",
       "14040  Microsoft Edge allows remote attackers to obta...     4.3      NETWORK   \n",
       "\n",
       "      AttackComplexity PrivilegesRequired UserInteraction      Scope  \\\n",
       "69013              LOW                LOW            NONE  UNCHANGED   \n",
       "14040              LOW               NONE        REQUIRED  UNCHANGED   \n",
       "\n",
       "      ConfidentialityImpact IntegrityImpact AvailabilityImpact  \n",
       "69013                  HIGH            HIGH               HIGH  \n",
       "14040                   LOW            NONE               NONE  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sample(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process(text):    \n",
    "    # lowercase\n",
    "    text=text.lower()    \n",
    "    #remove tags\n",
    "    text=re.sub(\"<!--?.*?-->\",\"\",text)    \n",
    "    # remove special characters and digits \n",
    "    text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8', 'ignore')\n",
    "    text= re.sub(\"(\\\\d|\\\\W)+\",\" \",text)\n",
    "    text = re.sub('[^a-zA-z0-9\\s]', '', text)\n",
    "    return text\n",
    "\n",
    "def _reciprocal_rank(true_labels: list, machine_preds: list):\n",
    "    \"\"\"Compute the reciprocal rank at cutoff k\"\"\"\n",
    "    # add index to list only if machine predicted label exists in true labels\n",
    "    tp_pos_list = [(idx + 1) for idx, r in enumerate(machine_preds) if r in true_labels]\n",
    "    rr = 0\n",
    "    if len(tp_pos_list) > 0:\n",
    "        # for RR we need position of first correct item\n",
    "        first_pos_list = tp_pos_list[0] \n",
    "        # rr = 1/rank\n",
    "        rr = 1 / float(first_pos_list)\n",
    "    return rr\n",
    "\n",
    "def compute_mrr_at_k(items:list):\n",
    "    \"\"\"Compute the MRR (average RR) at cutoff k\"\"\"\n",
    "    rr_total = 0\n",
    "    for item in items:   \n",
    "        rr_at_k = _reciprocal_rank(item[0],item[1])\n",
    "        rr_total = rr_total + rr_at_k\n",
    "        mrr = rr_total / 1/float(len(items))\n",
    "    return mrr\n",
    "\n",
    "def collect_preds(Y_test,Y_preds):\n",
    "    \"\"\"Collect all predictions and ground truth\"\"\"    \n",
    "    pred_gold_list=[[[Y_test[idx]],pred] for idx,pred in enumerate(Y_preds)]\n",
    "    return pred_gold_list\n",
    "             \n",
    "def compute_accuracy(eval_items:list):\n",
    "    correct=0\n",
    "    total=0\n",
    "    for item in eval_items:\n",
    "        true_pred=item[0]\n",
    "        machine_pred=set(item[1])        \n",
    "        for cat in true_pred:\n",
    "            if cat in machine_pred:\n",
    "                correct+=1\n",
    "                break\n",
    "    accuracy=correct/float(len(eval_items))\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes,\n",
    "                          normalize=False,\n",
    "                          title=None,\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if not title:\n",
    "        if normalize:\n",
    "            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "            title = 'Normalized confusion matrix'\n",
    "        else:\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    # Only use the labels that appear in the data\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "    print(cm)\n",
    "    fig, ax = plt.subplots()\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    # We want to show all ticks...\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "           title=title,\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "             rotation_mode=\"anchor\")\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    fig.tight_layout()\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stop_words(stop_file_path):\n",
    "    \"\"\"load stop words \"\"\"\n",
    "    with open(stop_file_path, 'r', encoding=\"utf-8\") as f:\n",
    "        stopwords = f.readlines()\n",
    "        stop_set = set(m.strip() for m in stopwords)\n",
    "        return frozenset(stop_set)\n",
    "#load a set of stop words\n",
    "stopwords=get_stop_words(\"src/stopwords.txt\")\n",
    "logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)\n",
    "\n",
    "def extract_features(df,field,training_data,testing_data,type=\"binary\"):\n",
    "    \"\"\"Extract features using different methods\"\"\"\n",
    "    logging.info(\"Extracting features and creating vocabulary...\")\n",
    "    if \"binary\" in type:\n",
    "        # BINARY FEATURE REPRESENTATION\n",
    "        cv= CountVectorizer(binary=True, max_df=0.95)\n",
    "        cv.fit_transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        train_feature_set=cv.transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        test_feature_set=cv.transform(testing_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        return train_feature_set,test_feature_set,cv\n",
    "    elif \"counts\" in type:\n",
    "        # COUNT BASED FEATURE REPRESENTATION\n",
    "        cv= CountVectorizer(binary=False, max_df=0.95)\n",
    "        cv.fit_transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        train_feature_set=cv.transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        test_feature_set=cv.transform(testing_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        return train_feature_set,test_feature_set,cv\n",
    "    else:    \n",
    "        # TF-IDF BASED FEATURE REPRESENTATION\n",
    "        tfidf_vectorizer=TfidfVectorizer(smooth_idf=True,use_idf=True, max_df=0.95)\n",
    "        tfidf_vectorizer.fit_transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        train_feature_set=tfidf_vectorizer.transform(training_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        test_feature_set=tfidf_vectorizer.transform(testing_data[field].apply(lambda x:pre_process(x)).tolist())\n",
    "        return train_feature_set,test_feature_set,tfidf_vectorizer\n",
    "    \n",
    "def get_top_k_predictions(model,X_test,k):\n",
    "    # get probabilities instead of predicted labels, since we want to collect top 3\n",
    "    probs = model.predict_proba(X_test)\n",
    "    # GET TOP K PREDICTIONS BY PROB - note these are just index\n",
    "    best_n = np.argsort(probs, axis=1)[:,-k:]\n",
    "    # GET CATEGORY OF PREDICTIONS\n",
    "    preds=[[model.classes_[predicted_cat] for predicted_cat in prediction] for prediction in best_n]\n",
    "    preds=[ item[::-1] for item in preds]\n",
    "    return preds\n",
    "\n",
    "def train_model(df,field,feature_rep,top_k,label):\n",
    "    logging.info(\"Starting model training...\")\n",
    "    # GET A TRAIN TEST SPLIT (set seed for consistent results)\n",
    "    training_data, testing_data = train_test_split(df,random_state = 2000,test_size=0.25)\n",
    "    # GET LABELS\n",
    "    if 'AttackVector' in label:\n",
    "        Y_train=training_data['AttackVector'].values\n",
    "        Y_test=testing_data['AttackVector'].values\n",
    "        classes = ['NETWORK','ADJACENT_NETWORK','LOCAL','PHYSICAL']\n",
    "    elif 'AttackComplexity' in label:\n",
    "        Y_train=training_data['AttackComplexity'].values\n",
    "        Y_test=testing_data['AttackComplexity'].values\n",
    "        classes = ['HIGH','LOW']\n",
    "    elif 'UserInteraction' in label:\n",
    "        Y_train=training_data['UserInteraction'].values\n",
    "        Y_test=testing_data['UserInteraction'].values\n",
    "        classes = ['REQUIRED','NONE']\n",
    "    elif 'PrivilegesRequired' in label:\n",
    "        Y_train=training_data['PrivilegesRequired'].values\n",
    "        Y_test=testing_data['PrivilegesRequired'].values\n",
    "        classes = ['HIGH','LOW','NONE']\n",
    "    elif 'Scope' in label:\n",
    "        Y_train=training_data['Scope'].values\n",
    "        Y_test=testing_data['Scope'].values\n",
    "        classes = ['CHANGED','UNCHANGED']\n",
    "    elif 'ConfidentialityImpact' in label:\n",
    "        Y_train=training_data['ConfidentialityImpact'].values\n",
    "        Y_test=testing_data['ConfidentialityImpact'].values\n",
    "        classes = ['HIGH','LOW','NONE']\n",
    "    elif 'IntegrityImpact' in label:\n",
    "        Y_train=training_data['IntegrityImpact'].values\n",
    "        Y_test=testing_data['IntegrityImpact'].values\n",
    "        classes = ['HIGH','LOW','NONE']\n",
    "    elif 'AvailabilityImpact' in label:\n",
    "        Y_train=training_data['AvailabilityImpact'].values\n",
    "        Y_test=testing_data['AvailabilityImpact'].values\n",
    "        classes = ['HIGH','LOW','NONE']\n",
    "    # GET FEATURES\n",
    "    X_train,X_test,feature_transformer=extract_features(df,field,training_data,testing_data,type=feature_rep)\n",
    "    # INIT LOGISTIC REGRESSION CLASSIFIER\n",
    "    logging.info(\"Training a Logistic Regression Model...\")\n",
    "    scikit_log_reg = LogisticRegression(verbose=1, solver='liblinear',random_state=0, C=5, penalty='l2',max_iter=1000)\n",
    "    model=scikit_log_reg.fit(X_train,Y_train)\n",
    "    \n",
    "    # GET TOP K PREDICTIONS\n",
    "    preds=get_top_k_predictions(model,X_test,top_k)\n",
    "    \n",
    "    # GET PREDICTED VALUES AND GROUND TRUTH INTO A LIST OF LISTS - for ease of evaluation\n",
    "    eval_items=collect_preds(Y_test,preds)\n",
    "    \n",
    "    # GET EVALUATION NUMBERS ON TEST SET -- HOW DID WE DO?\n",
    "    logging.info(\"Starting evaluation...\")\n",
    "    accuracy=compute_accuracy(eval_items)\n",
    "    mrr_at_k=compute_mrr_at_k(eval_items)\n",
    "\n",
    "    fig = plt.figure()\n",
    "    fig.set_size_inches(14, 12, forward=True)\n",
    "    \n",
    "    plot_confusion_matrix(Y_test,preds, classes,normalize=True,\n",
    "                      title='Normalized Confusion matrix')\n",
    "    plt.grid(False)\n",
    "    precision, recall, fscore, support = score(Y_test,preds)\n",
    "\n",
    "    print('precision: {}'.format(precision), 'macro-average: '+ str(np.mean(precision)))\n",
    "    print('recall: {}'.format(recall), 'macro-average: '+ str(np.mean(recall)))\n",
    "    print('fscore: {}'.format(fscore), 'macro-average: '+ str(np.mean(fscore)))\n",
    "    print('support: {}'.format(support), 'macro-average: '+ str(np.mean(support)))\n",
    "    F1score = 2 * (np.mean(recall) * np.mean(precision)) / (np.mean(precision) + np.mean(recall)) \n",
    "    print('micro f_score:'+str(F1score))\n",
    "    logging.info(\"Done training and evaluation.\")\n",
    "    ACC = balanced_accuracy_score(Y_test,preds)\n",
    "    print('balanced_accuracy_score:'+str(ACC))\n",
    "    \n",
    "    return model,feature_transformer,accuracy,mrr_at_k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:01,151 : INFO : Starting model training...\n",
      "2021-11-18 10:46:01,260 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:46:16,791 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:25,744 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[4.70225873e-01 5.33880903e-02 4.74332649e-01 2.05338809e-03]\n",
      " [2.80846283e-03 8.16700992e-01 1.77494851e-01 2.99569369e-03]\n",
      " [1.56278175e-03 3.75668690e-02 9.60088958e-01 7.81390876e-04]\n",
      " [7.81250000e-03 1.64062500e-01 2.69531250e-01 5.58593750e-01]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:26,250 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.84191176 0.86290801 0.92753034 0.8265896 ] macro-average: 0.8647349282034853\n",
      "recall: [0.47022587 0.81670099 0.96008896 0.55859375] macro-average: 0.7014023933398322\n",
      "fscore: [0.60342556 0.83916891 0.94352886 0.66666667] macro-average: 0.7631974983857962\n",
      "support: [  487  5341 16637   256] macro-average: 5680.25\n",
      "micro f_score:0.774551681903325\n",
      "balanced_accuracy_score:0.7014023933398322\n",
      "\n",
      "Accuracy=0.911359535231724; MRR=0.911359535231724\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='AttackVector'\n",
    "modelAttackVectorTFIDF,transformerAttackVectorTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:26,627 : INFO : Starting model training...\n",
      "2021-11-18 10:46:26,736 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:46:42,860 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:44,876 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.46918605 0.53081395]\n",
      " [0.00804724 0.99195276]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:45,339 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.82684426 0.95801334] macro-average: 0.8924287993471272\n",
      "recall: [0.46918605 0.99195276] macro-average: 0.730569405332858\n",
      "fscore: [0.59866469 0.97468769] macro-average: 0.786676189251782\n",
      "support: [ 1720 21001] macro-average: 11360.5\n",
      "micro f_score:0.8034280942035934\n",
      "balanced_accuracy_score:0.730569405332858\n",
      "\n",
      "Accuracy=0.9523788565644118; MRR=0.9523788565644118\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='AttackComplexity'\n",
    "modelAttackComplexityTFIDF,transformerAttackComplexityTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:46:45,578 : INFO : Starting model training...\n",
      "2021-11-18 10:46:45,618 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:47:01,413 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:03,502 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.95590152 0.04409848]\n",
      " [0.12776413 0.87223587]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:03,998 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.93056483 0.91695725] macro-average: 0.9237610400631158\n",
      "recall: [0.95590152 0.87223587] macro-average: 0.9140686939534756\n",
      "fscore: [0.94306303 0.89403765] macro-average: 0.918550338403672\n",
      "support: [14581  8140] macro-average: 11360.5\n",
      "micro f_score:0.9188893092617401\n",
      "balanced_accuracy_score:0.9140686939534756\n",
      "\n",
      "Accuracy=0.9259275560054575; MRR=0.9259275560054575\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='UserInteraction'\n",
    "modelUserInteractionTFIDF,transformerUserInteractionTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:04,318 : INFO : Starting model training...\n",
      "2021-11-18 10:47:04,379 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:47:18,810 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:25,027 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.5178117  0.2480916  0.23409669]\n",
      " [0.02056886 0.71701752 0.26241363]\n",
      " [0.00643173 0.05286078 0.94070749]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:25,435 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.78420039 0.7909945  0.87526493] macro-average: 0.8168199398122783\n",
      "recall: [0.5178117  0.71701752 0.94070749] macro-average: 0.7251789035958994\n",
      "fscore: [0.62375479 0.7521915  0.90680703] macro-average: 0.7609177731962803\n",
      "support: [ 1572  6223 14926] macro-average: 7573.666666666667\n",
      "micro f_score:0.7682763069771511\n",
      "balanced_accuracy_score:0.7251789035958994\n",
      "\n",
      "Accuracy=0.8501826504115135; MRR=0.8501826504115135\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='PrivilegesRequired'\n",
    "modelPrivilegesRequiredTFIDF,transformerPrivilegesRequiredTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:25,712 : INFO : Starting model training...\n",
      "2021-11-18 10:47:25,762 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:47:40,188 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:41,807 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.82674298 0.17325702]\n",
      " [0.01064788 0.98935212]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:42,315 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.94051495 0.96556716] macro-average: 0.9530410523996208\n",
      "recall: [0.82674298 0.98935212] macro-average: 0.9080475488480468\n",
      "fscore: [0.87996677 0.97731495] macro-average: 0.9286408604357821\n",
      "support: [ 3844 18877] macro-average: 11360.5\n",
      "micro f_score:0.930000421261914\n",
      "balanced_accuracy_score:0.9080475488480468\n",
      "\n",
      "Accuracy=0.9618414682452356; MRR=0.9618414682452356\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='Scope'\n",
    "modelScopeTFIDF,transformerScopeTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:47:42,595 : INFO : Starting model training...\n",
      "2021-11-18 10:47:42,650 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:47:57,020 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:03,047 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.93572181 0.02536505 0.03891314]\n",
      " [0.20539933 0.76197975 0.03262092]\n",
      " [0.2006012  0.02224449 0.77715431]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:03,418 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.86658302 0.88318123 0.85418502] macro-average: 0.8679830890791953\n",
      "recall: [0.93572181 0.76197975 0.77715431] macro-average: 0.8249519578607698\n",
      "fscore: [0.89982629 0.81811594 0.813851  ] macro-average: 0.8439310757474506\n",
      "support: [13286  4445  4990] macro-average: 7573.666666666667\n",
      "micro f_score:0.84592063944827\n",
      "balanced_accuracy_score:0.8249519578607698\n",
      "\n",
      "Accuracy=0.866907266405528; MRR=0.866907266405528\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='ConfidentialityImpact'\n",
    "modelConfidentialityTFIDF,transformerConfidentialityTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:03,679 : INFO : Starting model training...\n",
      "2021-11-18 10:48:03,743 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:48:17,289 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:23,418 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.91014065 0.02075013 0.06910922]\n",
      " [0.14024239 0.81152609 0.04823151]\n",
      " [0.13128492 0.00907821 0.85963687]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:23,797 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.87431193 0.91520223 0.86132102] macro-average: 0.8836117256258257\n",
      "recall: [0.91014065 0.81152609 0.85963687] macro-average: 0.860434538470325\n",
      "fscore: [0.8918666  0.8602517  0.86047812] macro-average: 0.8708654746401076\n",
      "support: [11518  4043  7160] macro-average: 7573.666666666667\n",
      "micro f_score:0.8718691275312516\n",
      "balanced_accuracy_score:0.860434538470325\n",
      "\n",
      "Accuracy=0.8766779631178205; MRR=0.8766779631178205\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='IntegrityImpact'\n",
    "modelIntegrityTFIDF,transformerIntegrityTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:24,113 : INFO : Starting model training...\n",
      "2021-11-18 10:48:24,185 : INFO : Extracting features and creating vocabulary...\n",
      "2021-11-18 10:48:39,352 : INFO : Training a Logistic Regression Model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibLinear]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:45,049 : INFO : Starting evaluation...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[9.27719934e-01 1.35808058e-03 7.09219858e-02]\n",
      " [5.04638219e-01 2.80148423e-01 2.15213358e-01]\n",
      " [1.23991935e-01 8.96057348e-04 8.75112007e-01]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:48:45,447 : INFO : Done training and evaluation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: [0.89915905 0.85310734 0.88093359] macro-average: 0.8777333276326966\n",
      "recall: [0.92771993 0.28014842 0.87511201] macro-average: 0.6943267879263247\n",
      "fscore: [0.91321624 0.42178771 0.87801315] macro-average: 0.7376723643553351\n",
      "support: [13254   539  8928] macro-average: 7573.666666666667\n",
      "micro f_score:0.7753313706001392\n",
      "balanced_accuracy_score:0.6943267879263247\n",
      "\n",
      "Accuracy=0.8916861053650808; MRR=0.8916861053650808\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1008x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "field='Report'\n",
    "feature_rep='tfidf'\n",
    "top_k=1\n",
    "label='AvailabilityImpact'\n",
    "modelAvailabilityTFIDF,transformerAvailabilityTFIDF,accuracy,mrr_at_k=train_model(df,field=field,feature_rep=feature_rep,top_k=top_k,label=label)\n",
    "print(\"\\nAccuracy={0}; MRR={1}\".format(accuracy,mrr_at_k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate the CVSS V3 score according to the CVSS documentation\n",
    "def calculate_ISC(document):\n",
    "    test_features_Confidentiality=transformerConfidentialityTFIDF.transform(document)\n",
    "    confidentiality_label=get_top_k_predictions(modelConfidentialityTFIDF,test_features_Confidentiality,1)\n",
    "    confidentiality_label=eval(str(confidentiality_label).strip('[]'))\n",
    "    if confidentiality_label=='HIGH':\n",
    "        confidentiality_value=0.56\n",
    "    elif confidentiality_label=='LOW': \n",
    "        confidentiality_value=0.22\n",
    "    else:\n",
    "        confidentiality_value=0\n",
    "\n",
    "    test_features_Integrity=transformerIntegrityTFIDF.transform(document)\n",
    "    integrity_label=get_top_k_predictions(modelIntegrityTFIDF,test_features_Integrity,1)\n",
    "    integrity_label=eval(str(integrity_label).strip('[]'))\n",
    "    if integrity_label=='HIGH':\n",
    "        integrity_value=0.56\n",
    "    elif integrity_label=='LOW': \n",
    "        integrity_value=0.22\n",
    "    else:\n",
    "        integrity_value=0\n",
    "        \n",
    "    test_features_Availability=transformerAvailabilityTFIDF.transform(document)\n",
    "    availability_label=get_top_k_predictions(modelAvailabilityTFIDF,test_features_Availability,1)\n",
    "    availability_label=eval(str(availability_label).strip('[]'))\n",
    "    if availability_label=='HIGH':\n",
    "        availability_value=0.56\n",
    "    elif availability_label=='LOW': \n",
    "        availability_value=0.22\n",
    "    else:\n",
    "        availability_value=0\n",
    "    \n",
    "    ISC=(1-(1-confidentiality_value)*(1-integrity_value)*(1-availability_value))\n",
    "    return ISC\n",
    "\n",
    "def get_scopeValue(document):\n",
    "    test_features_Scope=transformerScopeTFIDF.transform(document)\n",
    "    scope_label=get_top_k_predictions(modelScopeTFIDF,test_features_Scope,1)\n",
    "    scope_label=eval(str(scope_label).strip('[]'))\n",
    "    return scope_label\n",
    "\n",
    "def calculate_exploitabilityScore(document):\n",
    "    test_features_AttackVector=transformerAttackVectorTFIDF.transform(document)\n",
    "    attackVector_label=get_top_k_predictions(modelAttackVectorTFIDF,test_features_AttackVector,1)\n",
    "    attackVector_label=eval(str(attackVector_label).strip('[]'))\n",
    "    if attackVector_label=='NETWORK':\n",
    "        attackVector_value=0.85\n",
    "    elif attackVector_label=='ADJACENT_NETWORK':\n",
    "        attackVector_value=0.62\n",
    "    elif attackVector_label=='LOCAL':\n",
    "        attackVector_value=0.55\n",
    "    elif attackVector_label=='PHYSICAL':\n",
    "        attackVector_value=0.2\n",
    "    else:\n",
    "        attackVector_value=0\n",
    "        \n",
    "    test_features_AttackComplexity=transformerAttackComplexityTFIDF.transform(document)\n",
    "    attackComplexity_label=get_top_k_predictions(modelAttackComplexityTFIDF,test_features_AttackComplexity,1)\n",
    "    attackComplexity_label=eval(str(attackComplexity_label).strip('[]'))\n",
    "    if attackComplexity_label=='LOW':\n",
    "        attackComplexity_value=0.77\n",
    "    elif attackComplexity_label=='HIGH':\n",
    "        attackComplexity_value=0.44\n",
    "    else:\n",
    "        attackComplexity_value=0\n",
    "        \n",
    "    test_features_UserInteraction=transformerUserInteractionTFIDF.transform(document)\n",
    "    userInteraction_label=get_top_k_predictions(modelUserInteractionTFIDF,test_features_UserInteraction,1)\n",
    "    userInteraction_label=eval(str(userInteraction_label).strip('[]'))\n",
    "    if userInteraction_label=='NONE':\n",
    "        userInteraction_value=0.85\n",
    "    elif userInteraction_label=='REQUIRED':\n",
    "        userInteraction_value=0.62\n",
    "    else:\n",
    "        userInteraction_value=0\n",
    "        \n",
    "    test_features_Privileges=transformerPrivilegesRequiredTFIDF.transform(document)\n",
    "    privileges_label=get_top_k_predictions(modelPrivilegesRequiredTFIDF,test_features_Privileges,1)\n",
    "    privileges_label=eval(str(privileges_label).strip('[]'))\n",
    "    scope_label=get_scopeValue(document)\n",
    "    if scope_label=='UNCHANGED' and privileges_label=='LOW':\n",
    "        privileges_value=0.62\n",
    "    elif scope_label=='CHANGED' and privileges_label=='LOW':\n",
    "        privileges_value=0.68\n",
    "    elif scope_label=='UNCHANGED' and privileges_label=='HIGH':\n",
    "        privileges_value=0.27\n",
    "    elif scope_label=='CHANGED' and privileges_label=='HIGH':\n",
    "        privileges_value=0.5\n",
    "    else :\n",
    "        privileges_value=0.85\n",
    "    \n",
    "    exploitabilityScore=8.22*attackVector_value*attackComplexity_value*userInteraction_value*privileges_value\n",
    "    return exploitabilityScore\n",
    "\n",
    "def calculate_impactScore(document):\n",
    "    scope_label=get_scopeValue(document)\n",
    "    ISC=calculate_ISC(document)\n",
    "    if scope_label=='UNCHANGED':\n",
    "        impactScore=6.42*ISC\n",
    "    elif scope_label=='CHANGED':\n",
    "        impactScore=7.52*(ISC-0.029)-3.25*((ISC-0.02)**15)\n",
    "    else:\n",
    "        impactScore=0\n",
    "    return impactScore\n",
    "\n",
    "import math\n",
    "def round_up(n, decimals=1):\n",
    "    multiplier = 10 ** decimals\n",
    "    return math.ceil(n * multiplier) / multiplier\n",
    "def calculate_baseScore(document):\n",
    "    scope_label=get_scopeValue(document)\n",
    "    exploitabilityScore=calculate_exploitabilityScore(document)\n",
    "    impactScore=calculate_impactScore(document)\n",
    "    if impactScore>0 and scope_label=='UNCHANGED':\n",
    "        baseScore=round_up(min((impactScore+exploitabilityScore),10))\n",
    "    elif impactScore>0 and scope_label=='CHANGED':\n",
    "        baseScore=round_up(min((impactScore+exploitabilityScore)*1.08,10))\n",
    "    else:\n",
    "        baseScore=0\n",
    "    return baseScore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(13700, 13)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#NVD reports in 2021 are used as validation.\n",
    "df2021 = pd.read_csv('validateCVSSV3/NVD_2021_CVSSV3_train.csv')\n",
    "df2021.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "def train_cvss_model(df):\n",
    "    docs=df2021['Report'].tolist()\n",
    "    preds=[]\n",
    "    for i in range(0,len(df2021)):\n",
    "        pred_score=calculate_baseScore([docs[i]])\n",
    "        preds.append(str(pred_score))\n",
    "    logging.info(\"Starting evaluation...\")\n",
    "    logging.info(\"Done training and evaluation.\")\n",
    "    return preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-18 10:57:41,623 : INFO : Starting evaluation...\n",
      "2021-11-18 10:57:41,623 : INFO : Done training and evaluation.\n"
     ]
    }
   ],
   "source": [
    "preds = train_cvss_model(df2021)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_labels=[]\n",
    "y_test = df2021['CVSSV3'].values\n",
    "for item in y_test:\n",
    "    item = str(item)\n",
    "    y_test_labels.append(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9568458114661529"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct=0\n",
    "total=0\n",
    "for i in range(0,len(df2021)):\n",
    "    true_pred=y_test_labels[i]\n",
    "    machine_pred=preds[i]\n",
    "    true_pred=float(true_pred)\n",
    "    machine_pred=float(machine_pred)\n",
    "    try:\n",
    "        if true_pred == 0 and machine_pred != 0:\n",
    "            distance = machine_pred\n",
    "        elif true_pred != 0 and machine_pred == 0:\n",
    "            distance = true_pred\n",
    "        elif true_pred == machine_pred:\n",
    "            distance = 0\n",
    "        elif true_pred < machine_pred:\n",
    "            distance = (machine_pred - true_pred)/true_pred\n",
    "        else:\n",
    "            distance = (true_pred - machine_pred)/true_pred\n",
    "    except ZeroDivisionError:\n",
    "        print(\"true_pred = 0\")\n",
    "    if float(distance) <= 0.5:\n",
    "        correct+=1\n",
    "accuracy=correct/float(len(preds))\n",
    "accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CVE_ID</th>\n",
       "      <th>Report</th>\n",
       "      <th>CVSSV3</th>\n",
       "      <th>AttackVector</th>\n",
       "      <th>AttackComplexity</th>\n",
       "      <th>PrivilegesRequired</th>\n",
       "      <th>UserInteraction</th>\n",
       "      <th>Scope</th>\n",
       "      <th>ConfidentialityImpact</th>\n",
       "      <th>IntegrityImpact</th>\n",
       "      <th>AvailabilityImpact</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>CVE-2016-8374</td>\n",
       "      <td>An issue was discovered in Schneider Electric ...</td>\n",
       "      <td>0.00</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "      <td>l</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           CVE_ID                                             Report  CVSSV3  \\\n",
       "55  CVE-2016-8374  An issue was discovered in Schneider Electric ...    0.00   \n",
       "\n",
       "   AttackVector AttackComplexity PrivilegesRequired UserInteraction Scope  \\\n",
       "55            l                l                  l               l     l   \n",
       "\n",
       "   ConfidentialityImpact IntegrityImpact AvailabilityImpact  \n",
       "55                     l               l                  l  "
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Some NVD reports related to HMI are used as an example .\n",
    "dfTest=pd.read_csv(\"testData/testHMI.csv\")\n",
    "dfTest['CVSSV3'] = pd.to_numeric(dfTest['CVSSV3'], downcast=\"float\")\n",
    "pd.options.display.precision = 2\n",
    "dfTest.iloc[[55]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown in the dfTest, these CVEs have just pre-defined values, i.e. CVSSV3 equals to 0 while the other vectors are set to \"l\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "docs=dfTest['Report'].tolist()\n",
    "for i in range(0,len(dfTest)):\n",
    "\n",
    "    test_features_Scope=transformerScopeTFIDF.transform([docs[i]])\n",
    "    scope_label=get_top_k_predictions(modelScopeTFIDF,test_features_Scope,1)\n",
    "    scope_label=eval(str(scope_label).strip('[]'))\n",
    "    dfTest.at[i, 'Scope'] =  str(scope_label)\n",
    "\n",
    "    test_features_AttackVector=transformerAttackVectorTFIDF.transform([docs[i]])\n",
    "    attackVector_label=get_top_k_predictions(modelAttackVectorTFIDF,test_features_AttackVector,1)\n",
    "    attackVector_label=eval(str(attackVector_label).strip('[]'))\n",
    "    dfTest.at[i, 'AttackVector'] =  str(attackVector_label)\n",
    "\n",
    "    test_features_AttackComplexity=transformerAttackComplexityTFIDF.transform([docs[i]])\n",
    "    attackComplexity_label=get_top_k_predictions(modelAttackComplexityTFIDF,test_features_AttackComplexity,1)\n",
    "    attackComplexity_label=eval(str(attackComplexity_label).strip('[]'))\n",
    "    dfTest.at[i, 'AttackComplexity'] = str(attackComplexity_label)\n",
    "\n",
    "    test_features_UserInteraction=transformerUserInteractionTFIDF.transform([docs[i]])\n",
    "    userInteraction_label=get_top_k_predictions(modelUserInteractionTFIDF,test_features_UserInteraction,1)\n",
    "    userInteraction_label=eval(str(userInteraction_label).strip('[]'))\n",
    "    dfTest.at[i, 'UserInteraction'] = str(userInteraction_label)\n",
    "\n",
    "    test_features_Privileges=transformerPrivilegesRequiredTFIDF.transform([docs[i]])\n",
    "    privileges_label=get_top_k_predictions(modelPrivilegesRequiredTFIDF,test_features_Privileges,1)\n",
    "    privileges_label=eval(str(privileges_label).strip('[]'))\n",
    "    dfTest.at[i, 'PrivilegesRequired'] = str(privileges_label)\n",
    "\n",
    "    test_features_Confidentiality=transformerConfidentialityTFIDF.transform([docs[i]])\n",
    "    confidentiality_label=get_top_k_predictions(modelConfidentialityTFIDF,test_features_Confidentiality,1)\n",
    "    confidentiality_label=eval(str(confidentiality_label).strip('[]'))\n",
    "    dfTest.at[i, 'ConfidentialityImpact'] = str(confidentiality_label)\n",
    "\n",
    "    test_features_Integrity=transformerIntegrityTFIDF.transform([docs[i]])\n",
    "    integrity_label=get_top_k_predictions(modelIntegrityTFIDF,test_features_Integrity,1)\n",
    "    integrity_label=eval(str(integrity_label).strip('[]'))\n",
    "    dfTest.at[i, 'IntegrityImpact'] = str(integrity_label)\n",
    "\n",
    "    test_features_Availability=transformerAvailabilityTFIDF.transform([docs[i]])\n",
    "    availability_label=get_top_k_predictions(modelAvailabilityTFIDF,test_features_Availability,1)\n",
    "    availability_label=eval(str(availability_label).strip('[]'))\n",
    "    dfTest.at[i, 'AvailabilityImpact'] = str(availability_label)\n",
    "\n",
    "    pred_score=calculate_baseScore([docs[i]])\n",
    "    dfTest.at[i, 'CVSSV3'] = str(float(pred_score))\n",
    "    \n",
    "dfTest.to_csv('testDataResult/testHMI_prediction.csv', float_format=\"%.2f\", encoding='utf-8', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CVE_ID</th>\n",
       "      <th>Report</th>\n",
       "      <th>CVSSV3</th>\n",
       "      <th>AttackVector</th>\n",
       "      <th>AttackComplexity</th>\n",
       "      <th>PrivilegesRequired</th>\n",
       "      <th>UserInteraction</th>\n",
       "      <th>Scope</th>\n",
       "      <th>ConfidentialityImpact</th>\n",
       "      <th>IntegrityImpact</th>\n",
       "      <th>AvailabilityImpact</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>CVE-2016-8374</td>\n",
       "      <td>An issue was discovered in Schneider Electric ...</td>\n",
       "      <td>7.50</td>\n",
       "      <td>NETWORK</td>\n",
       "      <td>LOW</td>\n",
       "      <td>NONE</td>\n",
       "      <td>NONE</td>\n",
       "      <td>UNCHANGED</td>\n",
       "      <td>NONE</td>\n",
       "      <td>NONE</td>\n",
       "      <td>HIGH</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           CVE_ID                                             Report  CVSSV3  \\\n",
       "55  CVE-2016-8374  An issue was discovered in Schneider Electric ...    7.50   \n",
       "\n",
       "   AttackVector AttackComplexity PrivilegesRequired UserInteraction  \\\n",
       "55      NETWORK              LOW               NONE            NONE   \n",
       "\n",
       "        Scope ConfidentialityImpact IntegrityImpact AvailabilityImpact  \n",
       "55  UNCHANGED                  NONE            NONE               HIGH  "
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfPred=pd.read_csv(\"testDataResult/testHMI_prediction.csv\")\n",
    "dfPred.iloc[[55]]"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}