3_malware_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/shahrukh/Desktop/ml-cybersecurity/assignment3/shahrukh/data\n",
      "--2021-12-02 19:09:54--  https://nextcloud.mpi-klsb.mpg.de/index.php/s/pJrRGzm2So2PMZm/download\n",
      "Resolving nextcloud.mpi-klsb.mpg.de (nextcloud.mpi-klsb.mpg.de)... 139.19.205.150\n",
      "Connecting to nextcloud.mpi-klsb.mpg.de (nextcloud.mpi-klsb.mpg.de)|139.19.205.150|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 134409420 (128M) [application/x-gzip]\n",
      "Saving to: ‘train.tar.gz’\n",
      "\n",
      "train.tar.gz        100%[===================>] 128.18M  6.72MB/s    in 21s     \n",
      "\n",
      "2021-12-02 19:10:14 (6.23 MB/s) - ‘train.tar.gz’ saved [134409420/134409420]\n",
      "\n",
      "--2021-12-02 19:10:33--  https://nextcloud.mpi-klsb.mpg.de/index.php/s/zN3yeWzQB3i5WqE/download\n",
      "Resolving nextcloud.mpi-klsb.mpg.de (nextcloud.mpi-klsb.mpg.de)... 139.19.205.150\n",
      "Connecting to nextcloud.mpi-klsb.mpg.de (nextcloud.mpi-klsb.mpg.de)|139.19.205.150|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 96255569 (92M) [application/x-gzip]\n",
      "Saving to: ‘test.tar.gz’\n",
      "\n",
      "test.tar.gz         100%[===================>]  91.80M  5.92MB/s    in 16s     \n",
      "\n",
      "2021-12-02 19:10:49 (5.77 MB/s) - ‘test.tar.gz’ saved [96255569/96255569]\n",
      "\n",
      "/Users/shahrukh/Desktop/ml-cybersecurity/assignment3/shahrukh\n",
      "--2021-12-02 19:11:01--  https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/application_vocab_5521.pkl\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.108.133, 185.199.111.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 158028 (154K) [application/octet-stream]\n",
      "Saving to: ‘application_vocab_5521.pkl’\n",
      "\n",
      "application_vocab_5 100%[===================>] 154.32K  --.-KB/s    in 0.05s   \n",
      "\n",
      "2021-12-02 19:11:02 (3.24 MB/s) - ‘application_vocab_5521.pkl’ saved [158028/158028]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## install additional packages\n",
    "!pip install optuna seaborn\n",
    "\n",
    "## download and unzip train/test datasets\n",
    "!mkdir data\n",
    "%cd data\n",
    "!wget https://nextcloud.mpi-klsb.mpg.de/index.php/s/pJrRGzm2So2PMZm/download -O train.tar.gz \n",
    "!tar xzf train.tar.gz\n",
    "!wget https://nextcloud.mpi-klsb.mpg.de/index.php/s/zN3yeWzQB3i5WqE/download -O test.tar.gz \n",
    "!tar xzf test.tar.gz\n",
    "%cd ..\n",
    "\n",
    "## download precomputed vocab\n",
    "!wget https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/application_vocab_5521.pkl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qKo3S_fOsMim"
   },
   "source": [
    "## About this Project\n",
    "In this project, you will explore an application of ML to a popular task in cybersecurity: malware classification.\n",
    "You will be presented with precomputed behaviour analysis reports of thousands of program binaries, many of which are malwares.\n",
    "Your goal is to train a malware detector using this behavioural reports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "uyCiLbXbsMiq",
    "tags": []
   },
   "outputs": [],
   "source": [
    "import time \n",
    " \n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "import json \n",
    "import time \n",
    "import pickle \n",
    "import sys \n",
    "import csv \n",
    "import os \n",
    "import os.path as osp \n",
    "import shutil \n",
    "import pathlib\n",
    "from pathlib import Path\n",
    "\n",
    "from IPython.display import display, HTML\n",
    " \n",
    "%matplotlib inline \n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots \n",
    "plt.rcParams['image.interpolation'] = 'nearest' \n",
    "plt.rcParams['image.cmap'] = 'gray' \n",
    " \n",
    "# for auto-reloading external modules \n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython \n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "7dHogdxRsMis",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Some suggestions of our libraries that might be helpful for this project\n",
    "from collections import Counter          # an even easier way to count\n",
    "from multiprocessing import Pool         # for multiprocessing\n",
    "from tqdm import tqdm                    # fancy progress bars\n",
    "\n",
    "# Load other libraries here.\n",
    "import pandas as pd\n",
    "import warnings\n",
    "import seaborn as sns\n",
    "import optuna\n",
    "from optuna.visualization import plot_optimization_history, plot_parallel_coordinate, plot_param_importances, plot_slice\n",
    "from sklearn.metrics import recall_score, plot_confusion_matrix, accuracy_score, classification_report\n",
    "# Keep it minimal! We should be easily able to reproduce your code.\n",
    "\n",
    "# We preload pytorch as an example\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset, TensorDataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oJWkh3GUsMit"
   },
   "source": [
    "# Setup\n",
    "\n",
    "  * Download the datasets: [train](https://nextcloud.mpi-klsb.mpg.de/index.php/s/pJrRGzm2So2PMZm) (128M) and [test](https://nextcloud.mpi-klsb.mpg.de/index.php/s/zN3yeWzQB3i5WqE) (92M)\n",
    "  * Unpack them under `./data/train` and `./data/test`\n",
    "  * Hint: you can execute shell scripts from notebooks using the `!` prefix, e.g., `! wget <url>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "wlhs4w44sMit"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# train examples (Should be 13682) :  13682\n",
      "# test examples (Should be 10000) :  10000\n"
     ]
    }
   ],
   "source": [
    "# Check that you are prepared with the data\n",
    "try:\n",
    "    print(f\"# train examples (Should be 13682) : \", len(os.listdir('./data/train')))\n",
    "    print(f\"# test examples (Should be 10000) : \", len(os.listdir('./data/test')))\n",
    "\n",
    "except Exception as e:\n",
    "    print(\"You don't have the data!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zh1-JHNIsMiv"
   },
   "source": [
    "Now that you're set, let's briefly look at the data you have been handed.\n",
    "Each file encodes the behavior report of a program (potentially a malware), using an encoding scheme called \"The Malware Instruction Set\" (MIST for short).\n",
    "At this point, we highly recommend you briefly read-up Sec. 2 of the [MIST](http://www.mlsec.org/malheur/docs/mist-tr.pdf) documentation.\n",
    "\n",
    "You will find each file named as `filename.<malwarename>`:\n",
    "```\n",
    "» ls data/train | head\n",
    "00005ecc06ae3e489042e979717bb1455f17ac9d.NothingFound\n",
    "0008e3d188483aeae0de62d8d3a1479bd63ed8c9.Basun\n",
    "000d2eea77ee037b7ef99586eb2f1433991baca9.Patched\n",
    "000d996fa8f3c83c1c5568687bb3883a543ec874.Basun\n",
    "0010f78d3ffee61101068a0722e09a98959a5f2c.Basun\n",
    "0013cd0a8febd88bfc4333e20486bd1a9816fcbf.Basun\n",
    "0014aca72eb88a7f20fce5a4e000c1f7fff4958a.Texel\n",
    "001ffc75f24a0ae63a7033a01b8152ba371f6154.Texel\n",
    "0022d6ba67d556b931e3ab26abcd7490393703c4.Basun\n",
    "0028c307a125cf0fdc97d7a1ffce118c6e560a70.Swizzor\n",
    "...\n",
    "```\n",
    "and within each file, you will see a sequence of individual systems calls monitored duing the run-time of the binary - a malware named 'Basun' in the case:\n",
    "```\n",
    "» head data/train/000d996fa8f3c83c1c5568687bb3883a543ec874.Basun\n",
    "# process 000006c8 0000066a 022c82f4 00000000 thread 0001 #\n",
    "02 01 | 000006c8 0000066a 00015000\n",
    "02 02 | 00006b2c 047c8042 000b9000\n",
    "02 02 | 00006b2c 047c8042 00108000\n",
    "02 02 | 00006b2c 047c8042 00153000\n",
    "02 02 | 00006b2c 047c8042 00091000\n",
    "02 02 | 00006b2c 047c8042 00049000\n",
    "02 02 | 00006b2c 047c8042 000aa000\n",
    "02 02 | 00006b2c 047c8042 00092000\n",
    "02 02 | 00006b2c 047c8042 00011000\n",
    "...\n",
    "```\n",
    "(**Note**: Please ignore the first line that begins with `# process ...`.)\n",
    "\n",
    "Your task in this project is to train a malware detector, which given the sequence of system calls (in the MIST-formatted file like above), predicts one of 10 classes: `{ Agent, Allaple, AutoIt, Basun, NothingFound, Patched, Swizzor, Texel, VB, Virut }`, where `NothingFound` roughly represents no malware is present.\n",
    "In terms of machine learning terminology, your malware detector $F: X \\rightarrow Y$ should learn a mapping from the MIST-encoded behaviour report (the input $x \\in X$) to the malware class $y \\in Y$.\n",
    "\n",
    "Consequently, you will primarily tackle two challenges in this project:\n",
    "  1. \"Vectorizing\" the input data i.e., representing each input (file) as a tensor\n",
    "  1. Training an ML model\n",
    "  \n",
    "\n",
    "### Some tips:\n",
    "  * Begin with an extremely simple representation/ML model and get above chance-level classification performance\n",
    "  * Choose your evaluation metric wisely\n",
    "  * Save intermediate computations (e.g., a token to index mapping). This will avoid you parsing the entire dataset for every experiment\n",
    "  * Try using `multiprocessing.Pool` to parallelize your `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p8xloR8dsMiv"
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vXnyDAdbsMiw"
   },
   "source": [
    "# 1. Vectorize Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "7BSUdq_-sMiw",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train_path = './data/train'\n",
    "test_path = './data/test'\n",
    "n_workers = 10\n",
    "project_mode = 'trainval'    # trainval, traintest, debug, eval\n",
    "np.random.seed(123) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ia-xFIQtsMiw"
   },
   "source": [
    "## 1.a. Load Raw Data\n",
    "### => In the method, 'load_content' we converted list of list lines to string to save memory in order to load entire dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "ZScY-C2IsMiw",
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load_content(filepath):\n",
    "    '''Given a filepath, returns (content, classname), where content = [list of lines in file]'''\n",
    "    ## load file content\n",
    "    file = open(filepath, \"r\")\n",
    "    file_lines = file.read()\n",
    "    ## here converted list of list lines to string to save memory in order to load entire dataset\n",
    "    lines = \"\\n\".join(file_lines.splitlines())\n",
    "    file.close()\n",
    "\n",
    "    ## extracting label\n",
    "    label = filepath.split(\".\")[-1]\n",
    "    return lines, label\n",
    "\n",
    "\n",
    "def load_data(data_path, nworkers=10):\n",
    "    '''Returns each data sample as a tuple (x, y), x = sequence of strings (i.e., syscalls), y = malware program class'''\n",
    "    raw_data_samples = []\n",
    "    \n",
    "    file_paths = [f\"{data_path}/{filename}\" for filename in os.listdir(data_path)]\n",
    "    pool = Pool(processes=nworkers)\n",
    " \n",
    "    raw_data_samples = pool.map(load_content, file_paths)\n",
    "    return raw_data_samples\n",
    "\n",
    "def pickle_file(out_path, file_content):\n",
    "    with open(out_path, 'wb') as wf:\n",
    "        pickle.dump(file_content, wf)\n",
    "        \n",
    "def unpickle_file(in_path):\n",
    "    return pickle.load(open(in_path, \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Note on data splits:\n",
    "We perform the split 80%/20% the train set, to divide it to train and validation set when `project_mode` is `trainval`,\n",
    "however, we store the validation set in `test_raw_samples` for consistency purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "GG6tcSNJsMiw"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> Loading training data ... \n",
      "=> Loading testing data ... \n",
      "=> # Train samples =  13682\n",
      "=> # Test  samples =  10000\n"
     ]
    }
   ],
   "source": [
    "## in trainval mode we use test_raw_samples variable to hold validation dataset\n",
    "train_raw_samples, test_raw_samples = [], []\n",
    " \n",
    "if project_mode == 'trainval':\n",
    "    print('=> Loading training data ... ')\n",
    "    train_raw_samples = load_data(Path(train_path), nworkers=n_workers)\n",
    "    # To perform the same split across multiple runs\n",
    "    np.random.seed(123)          \n",
    "    # Split data into train and validation set\n",
    "    np.random.shuffle(train_raw_samples)\n",
    "    train_raw_samples, test_raw_samples = train_raw_samples[:int(len(train_raw_samples)*0.8)], train_raw_samples[int(len(train_raw_samples)*0.8):]\n",
    "\n",
    "elif project_mode == 'traintest':\n",
    "    ## loading train and test set\n",
    "    print('=> Loading training data ... ')\n",
    "    train_raw_samples = load_data(Path(train_path), nworkers=n_workers)\n",
    "    print('=> Loading testing data ... ')\n",
    "    test_raw_samples = load_data(Path(test_path), nworkers=n_workers)\n",
    "    \n",
    "elif project_mode == 'debug':\n",
    "    # Optional, use a small subset of the training and validation data for fast debugging\n",
    "    print('=> Loading training data ... ')\n",
    "    train_raw_samples = load_data(Path(train_path), nworkers=n_workers)[:100]\n",
    "    print('=> Loading testing data ... ')\n",
    "    test_raw_samples = load_data(Path(test_path), nworkers=n_workers)[:100]\n",
    "\n",
    "else:\n",
    "    raise ValueError('Unrecognized mode')\n",
    "\n",
    "if project_mode == 'trainval':\n",
    "    print('=> # Train samples = ', len(train_raw_samples))\n",
    "    print('=> # Validation  samples = ', len(test_raw_samples))\n",
    "else:\n",
    "    print('=> # Train samples = ', len(train_raw_samples))\n",
    "    print('=> # Test  samples = ', len(test_raw_samples))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GjiNiOVHsMiy"
   },
   "source": [
    "## 1.b. Vectorize: Setup\n",
    "\n",
    "Make one pass over the inputs to identify relevant features/tokens.\n",
    "\n",
    "Suggestion:\n",
    "  - identify tokens (e.g., unigrams, bigrams)\n",
    "  - create a token -> index (int) mapping. Note that you might have a >10K unique tokens. So, you will have to choose a suitable \"vocabulary\" size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "DAtmzL6PsMiy"
   },
   "outputs": [],
   "source": [
    "# Feel free to edit anything in this block\n",
    "\n",
    "def get_key_idx_map(counter, vocab_size, ukn_token='_ukn_'):\n",
    "    \"\"\"counter is a mapping: token -> count\n",
    "    build vectorizer using vocab_size most common elements\"\"\"\n",
    "    key_to_idx, idx_to_key = dict(), dict()\n",
    "    \n",
    "    for idx, (key, value) in tqdm(enumerate(list(train_counter.items())[:vocab_size-1])):\n",
    "        ## perform mapping for token\n",
    "        key_to_idx[key] = idx\n",
    "        idx_to_key[idx] = key\n",
    "    ## perform mapping for unk token at the end\n",
    "    key_to_idx[ukn_token] = vocab_size - 1\n",
    "    idx_to_key[vocab_size - 1] = ukn_token\n",
    "    \n",
    "    return key_to_idx, idx_to_key\n",
    "\n",
    "def preprocess(data):\n",
    "    \"\"\"concatenating all sys calls to single string for tokenization\n",
    "    removing extraneous information such as lines with '# process', white spaces and '|' characters\"\"\"\n",
    "    for i, (X,y) in enumerate(tqdm(data)):\n",
    "        example = \"\"\n",
    "        for line in X.split(\"\\n\"):\n",
    "            ## skip lines containing '# process'\n",
    "            if \"# process\" in line:\n",
    "                continue\n",
    "            ## remove extraneous white spaces and \n",
    "            example += line.replace(\"|\",\"\").replace(\"  \", \" \").strip() + \" \"\n",
    "        example = example.strip()\n",
    "        ## assign preprocessed sample\n",
    "        data[i] = (example, y)\n",
    "    return data\n",
    "        \n",
    "def count_words(data):\n",
    "    \"\"\"\n",
    "    count token occurences for building vocabulary later\n",
    "    \"\"\"\n",
    "    counter = {}\n",
    "    for X,y in tqdm(data):\n",
    "        counts = dict(Counter(X.split()))\n",
    "        counter = dict(counter, **counts)\n",
    "    return counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Preprocessing both train and test set and\n",
    "Creating token counter for building vocabulary on train set\n",
    "\"\"\"\n",
    "train_raw_samples = preprocess(train_raw_samples)\n",
    "train_counter = count_words(train_raw_samples)\n",
    "test_raw_samples = preprocess(test_raw_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code for finding appropriate threshold for setting `MAX_VOCAB_SIZE`\n",
    "def choose_vocab_size(min_frequency_threshold=10):\n",
    "    count = 0\n",
    "    for value,key in sorted([(value,key) for (key,value) in train_counter.items()], reverse=True):\n",
    "        if value > min_frequency_threshold:\n",
    "            count+=1\n",
    "    print(f\"Number of tokens are {count} for min. frequency threshold={min_frequency_threshold}\")\n",
    "#choose_vocab_size(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "## sorting the counters wrt to count values in decending order\n",
    "train_counter = {key:value for value, key in  sorted([(value,key) for (key,value) in train_counter.items()], reverse=True)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "LSMEAcgvsMiy",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Feel free to edit anything in this block\n",
    "## By keeping a minimum count threshold of 10 we get 5520 most frequent tokens in train dataset\n",
    "## adding one to MAX_VOCAB_SIZE for _ukn_ token\n",
    "MAX_VOCAB_SIZE = 5520 + 1\n",
    "token_to_idx, idx_to_token = {}, {}\n",
    "# Path for vocab for saving and loading\n",
    "vocab_path = 'application_vocab_{}.pkl'.format(MAX_VOCAB_SIZE)\n",
    "\n",
    "## check if vocab already exists on file system otherwise create one\n",
    "if os.path.isfile(vocab_path):\n",
    "    token_to_idx, idx_to_token = unpickle_file(vocab_path)['token_to_idx'], unpickle_file(vocab_path)['idx_to_token']\n",
    "    \n",
    "else:\n",
    "    token_to_idx, idx_to_token = get_key_idx_map(train_counter, MAX_VOCAB_SIZE)\n",
    "    with open(vocab_path, 'wb') as wf:\n",
    "        dct = {'token_to_idx': token_to_idx,\n",
    "              'idx_to_token': idx_to_token}\n",
    "        pickle.dump(dct, wf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QUefzVjFsMiy"
   },
   "source": [
    "## 1.c. Vectorize Data\n",
    "\n",
    "Use the (token $\\rightarrow$ index) mapping you created before to vectorize your data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "ffJJ0XOvsMiz"
   },
   "outputs": [],
   "source": [
    "def sample_to_idx(sample):\n",
    "    \"\"\"\n",
    "    Maps each document's tokens to their ids in the vocabulary\n",
    "    \"\"\"\n",
    "    idx_sample = []\n",
    "    for token in sample.split(' '):\n",
    "        if token not in token_to_idx:\n",
    "                token = '_ukn_'\n",
    "        idx_sample.append(token_to_idx[token])\n",
    "    return idx_sample\n",
    "\n",
    "\n",
    "## define mapping for labels\n",
    "label_encodings = {'Virut': 0,\n",
    " 'Swizzor': 1,\n",
    " 'Agent': 2,\n",
    " 'Patched': 3,\n",
    " 'Allaple': 4,\n",
    " 'Texel': 5,\n",
    " 'Basun': 6,\n",
    " 'AutoIt': 7,\n",
    " 'NothingFound': 8,\n",
    " 'VB': 9}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "CD5IqJmXsMiz"
   },
   "outputs": [],
   "source": [
    "def vectorize_raw_samples_bow(raw_samples, vocab_length, nworkers=10):\n",
    "    \"\"\"\n",
    "    BAG-OF-WORDS Vectorizer which vectorizes examples by adding '1' for\n",
    "    term i occuring in document j, hence producing a vector for each document\n",
    "    raw_samples: List of documents to vectorize\n",
    "    vocab_length: Size of the vocabulary\n",
    "    \"\"\"\n",
    "    vectorized_samples = []\n",
    "    labels = []\n",
    "    lengths = []\n",
    "    try:\n",
    "        for idx, (X,y) in tqdm(enumerate(raw_samples)):\n",
    "            vectorized_sample = []\n",
    "            ## map labeks to ids\n",
    "            label = label_encodings[y]\n",
    "            ## map tokens to ids\n",
    "            X_idx = sample_to_idx(X)\n",
    "\n",
    "            ## initializing placeholder vector with unknown tokens equivalent to max_length\n",
    "            vector_sample = [0] * vocab_length\n",
    "\n",
    "            ## creating Bag of Words Vectors \n",
    "            for index, val in enumerate(set(X_idx)):\n",
    "                vector_sample[val] = 1\n",
    "            sequence_length = len(X_idx)\n",
    "\n",
    "            ## append sample to respective lists\n",
    "            vectorized_samples.append(vector_sample)\n",
    "            labels.append(label)\n",
    "            lengths.append(sequence_length)\n",
    "    except:\n",
    "        pass\n",
    "            \n",
    "    return (torch.DoubleTensor(vectorized_samples), torch.LongTensor(labels), torch.LongTensor(lengths))\n",
    "\n",
    "\n",
    "\n",
    "def vectorize_raw_samples_count_vectorizer(raw_samples, vocab_length, nworkers=10):\n",
    "    \"\"\" \n",
    "    Count Vectorizer is similar to BAG-OF-WORDS Vectorizer, however this vectorizer places 'counts/frequency' for\n",
    "    term i occuring in document j, hence producing a vector for each document\n",
    "    raw_samples: List of documents to vectorize\n",
    "    vocab_length: Size of the vocabulary\n",
    "    \"\"\"\n",
    "    vectorized_samples = []\n",
    "    labels = []\n",
    "    lengths = []\n",
    "    try:\n",
    "        for idx, (X,y) in tqdm(enumerate(raw_samples)):\n",
    "            vectorized_sample = []\n",
    "            ## map labeks to ids\n",
    "            label = label_encodings[y]\n",
    "            ## map tokens to ids\n",
    "            X_idx = sample_to_idx(X)\n",
    "\n",
    "            ## initializing placeholder vector with unknown tokens equivalent to max_length\n",
    "            vector_sample = [0] * vocab_length\n",
    "            ## compute counts\n",
    "            counts = dict(Counter(X_idx))\n",
    "            ## creating Count Vectors \n",
    "            for index, (key, val) in enumerate(counts.items()):\n",
    "                vector_sample[key] = val\n",
    "            sequence_length = len(X_idx)\n",
    "\n",
    "            ## append sample to respective lists\n",
    "            vectorized_samples.append(vector_sample)\n",
    "            labels.append(label)\n",
    "            lengths.append(sequence_length)\n",
    "    except:\n",
    "        pass\n",
    "    \n",
    "    return (torch.DoubleTensor(vectorized_samples), torch.LongTensor(labels), torch.LongTensor(lengths))\n",
    "\n",
    "\n",
    "\n",
    "def vectorize_raw_samples_tfidf(raw_samples, vocab_length, nworkers=10):\n",
    "    \"\"\" \n",
    "    TF-IDF Vectorizer vectorizes examples computing term frequencies and inverse document\n",
    "    for freqyencies for term i occuring in document j, hence producing a vector for each document\n",
    "    raw_samples: List of documents to vectorize\n",
    "    vocab_length: Size of the vocabulary\n",
    "    \"\"\"\n",
    "    labels = []\n",
    "    lengths = []\n",
    "    tf_samples = [] ## term frequency vector for each sample\n",
    "    tf_idf = np.zeros(shape=(len(raw_samples), vocab_length))\n",
    "    try:\n",
    "        for idx, (X,y) in tqdm(enumerate(raw_samples)):\n",
    "            vectorized_sample = []\n",
    "            ## map labeks to ids\n",
    "            label = label_encodings[y]\n",
    "            ## map tokens to ids\n",
    "            X_idx = sample_to_idx(X)\n",
    "\n",
    "            ## initializing placeholder vector with unknown tokens equivalent to max_length\n",
    "            vector_sample = [0] * vocab_length\n",
    "            ## compute counts\n",
    "            counts = dict(Counter(X_idx))\n",
    "            ## creating Count Vectors \n",
    "            for index, (key, val) in enumerate(counts.items()):\n",
    "                vector_sample[key] = val\n",
    "            sequence_length = len(X_idx)\n",
    "            ## compute term frequencies 'tf => # of times term in the doc / total words in the doc'\n",
    "            term_frequencies = np.array(vector_sample) / sequence_length\n",
    "            ## append sample to respective lists\n",
    "            labels.append(label)\n",
    "            lengths.append(sequence_length)\n",
    "            tf_samples.append(term_frequencies)\n",
    "\n",
    "        # compute idf\n",
    "        # 1. computing BOW matrix \n",
    "        bow = np.zeros(shape=(len(raw_samples), vocab_length))\n",
    "        for i in range(len(tf_samples)):\n",
    "            for j in range(vocab_length):\n",
    "                if tf_samples[i][j] > 0:\n",
    "                    bow[i,j] = 1\n",
    "        # 2, compute idf scores 'idf(t) => log( ((1 + # of docs)/ # of docs with term t + 1) + 1 ) '\n",
    "        idf = [np.log(((1+len(raw_samples))/(1+sum(bow[:, i])))+1) for i in range(vocab_length)]\n",
    "\n",
    "        # compute tf-idf => tf * idf\n",
    "        tf = np.array(tf_samples)\n",
    "\n",
    "        for i in range(vocab_length):\n",
    "            tf_idf[:, i] = tf[:, i] * idf[i]\n",
    "    except:\n",
    "        pass\n",
    "    \n",
    "    return (torch.DoubleTensor(tf_idf), torch.LongTensor(labels), torch.LongTensor(lengths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "BtS10ASbsMi0",
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "## select vectorization_method from {'BOW','COUNT_VEC', 'TF_IDF'}\n",
    "vectorization_method = \"BOW\" \n",
    "train_data, test_data = None, None\n",
    "load_pre_computed_vectors = True  ##load vector pickles files from disk if set True\n",
    "\n",
    "def perform_vectorization():\n",
    "    \"\"\"\n",
    "    Performs vectorization based on the chosen technique \n",
    "    applies the method to convert documents to vectors\n",
    "    \"\"\"\n",
    "    if vectorization_method == \"BOW\":\n",
    "        print(f'=> {vectorization_method} Processing: Train')\n",
    "        train_data = vectorize_raw_samples_bow(train_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "        print()\n",
    "        print(f'=> {vectorization_method} Processing: Test')\n",
    "        test_data = vectorize_raw_samples_bow(test_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "\n",
    "    elif vectorization_method == \"COUNT_VEC\":\n",
    "        print(f'=> {vectorization_method} Processing: Train')\n",
    "        train_data = vectorize_raw_samples_count_vectorizer(train_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "        print()\n",
    "        print(f'=> {vectorization_method} Processing: Test')\n",
    "        test_data = vectorize_raw_samples_count_vectorizer(test_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "\n",
    "    elif vectorization_method == \"TF_IDF\":\n",
    "        print(f'=> {vectorization_method} Processing: Train')\n",
    "        train_data = vectorize_raw_samples_tfidf(train_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "        print()\n",
    "        print(f'=> {vectorization_method} Processing: Test')\n",
    "        test_data = vectorize_raw_samples_tfidf(test_raw_samples, vocab_length=MAX_VOCAB_SIZE)\n",
    "    else:\n",
    "        print(\"Please choose one of the following vectorization method: {'BOW','COUNT_VEC', 'TF_IDF'}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "if load_pre_computed_vectors:\n",
    "    if project_mode == 'trainval':\n",
    "        train_data = unpickle_file(f'train_v5521_{vectorization_method}.pkl')  \n",
    "        test_data = unpickle_file(f'val_v5521_{vectorization_method}.pkl')\n",
    "    elif project_mode == 'traintest':\n",
    "        train_data = unpickle_file(f'train_v5521_{vectorization_method}.pkl')  \n",
    "        test_data = unpickle_file(f'test_v5521_{vectorization_method}.pkl')    \n",
    "    else:\n",
    "        print(\"Please choose one of the following project modes: {'trainval','traintest', 'eval'}\")\n",
    "else:\n",
    "    perform_vectorization()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "0XOHr24usMi0"
   },
   "outputs": [],
   "source": [
    "\n",
    "# Suggestions: \n",
    "#\n",
    "# (a) You can use torch.utils.data.TensorDataset to represent the tensors you created previously\n",
    "# trainset = TensorDataset(train_x, train_y)\n",
    "# testset = TensorDataset(test_x, test_y)\n",
    "#\n",
    "# (b) Store your datasets to disk so that you do not need to precompute it every time\n",
    "\n",
    "\"\"\"\n",
    "Standard Pytorch Dataset class for loading datasets.\n",
    "\"\"\"\n",
    "class MalwareDataset(Dataset):\n",
    "\n",
    "    def __init__(self, data_tensor, target_tensor, length_tensor):\n",
    "        \"\"\"\n",
    "        initializes  and populates the the length, data and target tensors, and raw texts list\n",
    "        \"\"\"\n",
    "        assert data_tensor.size(0) == target_tensor.size(0) == length_tensor.size(0)\n",
    "        self.data_tensor = data_tensor\n",
    "        self.target_tensor = target_tensor\n",
    "        self.length_tensor = length_tensor\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        \"\"\"\n",
    "        returns the tuple of data tensor, targets, lengths of sequences tensor\n",
    "        \"\"\"\n",
    "        return self.data_tensor[index], self.target_tensor[index], self.length_tensor[index]\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"\n",
    "        returns the length of the data tensor.\n",
    "        \"\"\"\n",
    "        return self.data_tensor.size(0)\n",
    "\n",
    "## instantiate train and test datasets\n",
    "malware_testset = MalwareDataset(test_data[0], test_data[1], test_data[2])\n",
    "malware_trainset = MalwareDataset(train_data[0], train_data[1], train_data[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_l0tLsEVsMi0"
   },
   "source": [
    "# 2. Train Model\n",
    "\n",
    "You will now train an ML model on the vectorized datasets you created previously.\n",
    "\n",
    "_Note_: Although we often refer to each input as a 'vector' for simplicity, each of your inputs can also be higher dimensional tensors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UInY1YzksMi0"
   },
   "source": [
    "## 2.a. Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "VnSv0J75sMi0"
   },
   "outputs": [],
   "source": [
    "# Feel free to edit anything in this block\n",
    "\n",
    "def evaluate_preds(y_gt, y_pred):\n",
    "    recall = recall_score(y_gt, y_pred, average='micro')\n",
    "    return recall\n",
    "\n",
    "def load_model(model, out_path):\n",
    "    model.load_state_dict(torch.load(out_path, map_location=set_device))  \n",
    "\n",
    "def save_model(model, out_path):\n",
    "    torch.save(model.state_dict(), out_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PhbVzVLDsMi1"
   },
   "source": [
    "## 2.b. Define Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jrUKCNRgsMi1"
   },
   "source": [
    "Describe your model here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "ILB2fBRWsMi1"
   },
   "outputs": [],
   "source": [
    "# Feel free to edit anything in this block\n",
    "\n",
    "class MalwareNet(nn.Module):\n",
    "    \"\"\"\n",
    "    This class is created to specify the Neural Network on which vectorized datasets we have created previously\n",
    "    is trained on, validated and later tested.\n",
    "    It consist of one input layer, one output layer and multiple hidden layers.\n",
    "    ...\n",
    "    \"\"\"\n",
    "    def __init__(self, input_dim, output_dim, dropout=0.5):\n",
    "        super(MalwareNet, self).__init__()\n",
    "        # Layer definitions\n",
    "        self.layers = nn.Sequential(\n",
    "        nn.Linear(input_dim, 1024),\n",
    "        nn.ReLU(),\n",
    "        nn.Dropout(dropout),\n",
    "        nn.Linear(1024, 512),\n",
    "        nn.ReLU(),\n",
    "        nn.Dropout(dropout),\n",
    "        nn.Linear(512, 256),\n",
    "        nn.ReLU(),\n",
    "        nn.Dropout(dropout),\n",
    "        nn.Linear(256, 128),\n",
    "        nn.ReLU(),\n",
    "        nn.Dropout(dropout),\n",
    "        nn.Linear(128, output_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Forward pass\n",
    "        return self.layers(x)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _network_training(model, hyper_paramaters, criterion, optimizer, set_device, tuning=False):\n",
    "    '''\n",
    "    training the network given the hyperparameters, crtierion and optimizer\n",
    "    '''\n",
    "    best_accuracy = 0\n",
    "    train_loss_history, recall_train_history= list(), list()\n",
    "    validation_loss_history, recall_validation_history = list(), list()\n",
    "\n",
    "    for epoch in range(0, hyper_paramaters['NUM_EPOCHS']):\n",
    "        model.train()\n",
    "        train_loss_scores = []\n",
    "        training_acc_scores = []\n",
    "        y_pred, y_true= list(), list()\n",
    "\n",
    "        for batch, targets, lengths in trainloader:\n",
    "            \n",
    "            ## perform forward pass  \n",
    "            batch = batch.type(torch.FloatTensor).to(set_device)\n",
    "            pred = model(batch) \n",
    "            preds = torch.max(pred, 1)[1]\n",
    "\n",
    "            ## accumulate predictions per batch for the epoch\n",
    "            y_pred += list([x.item() for x in preds.detach().cpu().numpy()])\n",
    "            targets = torch.LongTensor([x.item() for x in list(targets)])\n",
    "            y_true +=  list([x.item() for x in targets.detach().cpu().numpy()])\n",
    "            \n",
    "            ## compute loss and perform backward pass\n",
    "            loss = criterion(pred.to(set_device), targets.to(set_device)) ## compute loss \n",
    "            optimizer.zero_grad()\n",
    "            loss.backward() \n",
    "            optimizer.step()\n",
    "\n",
    "            ## accumulate train loss\n",
    "            train_loss_scores.append(loss.item())\n",
    "        \n",
    "        ## accumulate loss, recall, f1, precision per epoch\n",
    "        train_loss_history.append((sum(train_loss_scores)/len(train_loss_scores)))\n",
    "        recall = evaluate_preds(y_true, y_pred)\n",
    "        recall_train_history.append(recall)\n",
    "        print(f'Training =>  Epoch : {epoch+1} | Loss : {train_loss_history[-1]} | Recall score: {recall_train_history[-1]}')\n",
    "       \n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            validation_loss_scores = list()\n",
    "            y_true_val, y_pred_val= list(), list()\n",
    "\n",
    "            ## perform validation pass\n",
    "            for batch, targets, lengths in testloader:\n",
    "                ## perform forward pass  \n",
    "                batch = batch.type(torch.FloatTensor).to(set_device)\n",
    "                pred = model(batch) \n",
    "                preds = torch.max(pred, 1)[1]\n",
    "\n",
    "                ## accumulate predictions per batch for the epoch\n",
    "                y_pred_val += list([x.item() for x in preds.detach().cpu().numpy()])\n",
    "                targets = torch.LongTensor([x.item() for x in list(targets)])\n",
    "                y_true_val +=  list([x.item() for x in targets.detach().cpu().numpy()])\n",
    "                \n",
    "                ## computing validate loss\n",
    "                loss = criterion(pred.to(set_device), targets.to(set_device)) ## compute loss \n",
    "\n",
    "                ## accumulate validate loss\n",
    "                validation_loss_scores.append(loss.item())\n",
    "            \n",
    "            ## accumulate loss, recall, f1, precision per epoch\n",
    "            validation_loss_history.append((sum(validation_loss_scores)/len(validation_loss_scores)))\n",
    "            recall = evaluate_preds(y_true_val, y_pred_val)\n",
    "            recall_validation_history.append(recall)\n",
    "\n",
    "            print(f'Validation =>  Epoch : {epoch+1} | Loss : {validation_loss_history[-1]} | Recall score: {recall_validation_history[-1]} ')\n",
    "            \n",
    "            if not tuning: \n",
    "                if recall_validation_history[-1]>best_accuracy:\n",
    "                    best_accuracy = recall_validation_history[-1]\n",
    "                    print('Saving the model...')\n",
    "                    save_model(model, out_path=f\"{vectorization_method}_model.ckpt\")\n",
    "                    \n",
    "            \n",
    "    if tuning:\n",
    "        return recall_validation_history\n",
    "        \n",
    "    \n",
    "    return train_loss_history, recall_train_history, validation_loss_history, recall_validation_history\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QO1yPx7YsMi1"
   },
   "source": [
    "## 2.c. Set Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0k0jLX5ksMi1"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:24:40,929]\u001b[0m A new study created in memory with name: no-name-c63ef8f2-3cfe-4598-89c1-ac20377d6b0c\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training =>  Epoch : 1 | Loss : 1.1000308754832246 | Recall score: 0.6229328460484239\n",
      "Validation =>  Epoch : 1 | Loss : 0.6988055608993353 | Recall score: 0.7778589696748265 \n",
      "Training =>  Epoch : 2 | Loss : 0.757027612262687 | Recall score: 0.7548652352672454\n",
      "Validation =>  Epoch : 2 | Loss : 0.634306073881859 | Recall score: 0.7815126050420168 \n",
      "Training =>  Epoch : 3 | Loss : 0.7072913878878881 | Recall score: 0.7735952489721334\n",
      "Validation =>  Epoch : 3 | Loss : 0.6608426945154057 | Recall score: 0.773109243697479 \n",
      "Training =>  Epoch : 4 | Loss : 0.7297432046643523 | Recall score: 0.7794426678848789\n",
      "Validation =>  Epoch : 4 | Loss : 0.6190982821375824 | Recall score: 0.7880891487029594 \n",
      "Training =>  Epoch : 5 | Loss : 0.6727094672793565 | Recall score: 0.786203746002741\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:25:04,026]\u001b[0m Trial 0 finished with value: 0.7924735111435879 and parameters: {'TRAIN_BATCH_SIZE': 64, 'LEARNING_RATE': 0.0031772254309900072, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 0 with value: 0.7924735111435879.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 0.6199188170044921 | Recall score: 0.7924735111435879 \n",
      "Training =>  Epoch : 1 | Loss : 1.340762806839721 | Recall score: 0.5659205116491549\n",
      "Validation =>  Epoch : 1 | Loss : 0.9056086554083713 | Recall score: 0.6887102667153818 \n",
      "Training =>  Epoch : 2 | Loss : 1.3719569503567939 | Recall score: 0.5785290086797624\n",
      "Validation =>  Epoch : 2 | Loss : 0.956783398639324 | Recall score: 0.6832298136645962 \n",
      "Training =>  Epoch : 3 | Loss : 1.593111372877692 | Recall score: 0.5058017359524897\n",
      "Validation =>  Epoch : 3 | Loss : 1.1819085728290468 | Recall score: 0.5717939349652905 \n",
      "Training =>  Epoch : 4 | Loss : 1.599911350150441 | Recall score: 0.48707172224760165\n",
      "Validation =>  Epoch : 4 | Loss : 1.3279902685520262 | Recall score: 0.5622944830105956 \n",
      "Training =>  Epoch : 5 | Loss : 1.5396957862255878 | Recall score: 0.473184102329831\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:25:27,234]\u001b[0m Trial 1 finished with value: 0.6887102667153818 and parameters: {'TRAIN_BATCH_SIZE': 64, 'LEARNING_RATE': 0.009860026136663418, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 5, 'DROPOUT': 0.1}. Best is trial 0 with value: 0.7924735111435879.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 1.245877465536428 | Recall score: 0.5699671172816952 \n",
      "Training =>  Epoch : 1 | Loss : 1.1130347106345864 | Recall score: 0.629968021927821\n",
      "Validation =>  Epoch : 1 | Loss : 0.7546563273252442 | Recall score: 0.752648885641213 \n",
      "Training =>  Epoch : 2 | Loss : 0.7582075332486088 | Recall score: 0.7539515760621288\n",
      "Validation =>  Epoch : 2 | Loss : 0.6403105092603106 | Recall score: 0.7800511508951407 \n",
      "Training =>  Epoch : 3 | Loss : 0.7438955574058169 | Recall score: 0.7732297852900868\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:25:41,344]\u001b[0m Trial 2 finished with value: 0.7873584216295214 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.0036830483085327007, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 3, 'DROPOUT': 0.5}. Best is trial 0 with value: 0.7924735111435879.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 3 | Loss : 0.6229036914747815 | Recall score: 0.7873584216295214 \n",
      "Training =>  Epoch : 1 | Loss : 1.0881398450150046 | Recall score: 0.6214709913202375\n",
      "Validation =>  Epoch : 1 | Loss : 0.658339340326398 | Recall score: 0.773109243697479 \n",
      "Training =>  Epoch : 2 | Loss : 0.7159273793438969 | Recall score: 0.7636363636363637\n",
      "Validation =>  Epoch : 2 | Loss : 0.6370741641798685 | Recall score: 0.7888198757763976 \n",
      "Training =>  Epoch : 3 | Loss : 0.6877163257016692 | Recall score: 0.7814527181361353\n",
      "Validation =>  Epoch : 3 | Loss : 0.6022555044917173 | Recall score: 0.7873584216295214 \n",
      "Training =>  Epoch : 4 | Loss : 0.6711319594449082 | Recall score: 0.7762448606669712\n",
      "Validation =>  Epoch : 4 | Loss : 0.611093049825624 | Recall score: 0.7888198757763976 \n",
      "Training =>  Epoch : 5 | Loss : 0.6742792302785918 | Recall score: 0.7820009136592051\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:26:04,450]\u001b[0m Trial 3 finished with value: 0.794665692363902 and parameters: {'TRAIN_BATCH_SIZE': 64, 'LEARNING_RATE': 0.0027997096218844567, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 0.5973551980284757 | Recall score: 0.794665692363902 \n",
      "Training =>  Epoch : 1 | Loss : 1.1155335272467413 | Recall score: 0.6155322064869804\n",
      "Validation =>  Epoch : 1 | Loss : 0.7723485390807308 | Recall score: 0.7599561563755937 \n",
      "Training =>  Epoch : 2 | Loss : 0.9586293518023435 | Recall score: 0.7307446322521699\n",
      "Validation =>  Epoch : 2 | Loss : 0.7087214415849641 | Recall score: 0.7793204238217026 \n",
      "Training =>  Epoch : 3 | Loss : 0.9621711087434791 | Recall score: 0.7272727272727273\n",
      "Validation =>  Epoch : 3 | Loss : 0.7176632084125696 | Recall score: 0.7778589696748265 \n",
      "Training =>  Epoch : 4 | Loss : 1.0297023425346408 | Recall score: 0.7301964367291001\n",
      "Validation =>  Epoch : 4 | Loss : 0.6956149755522262 | Recall score: 0.7763975155279503 \n",
      "Training =>  Epoch : 5 | Loss : 0.9561724016486213 | Recall score: 0.7392416628597533\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:26:27,325]\u001b[0m Trial 4 finished with value: 0.7793204238217026 and parameters: {'TRAIN_BATCH_SIZE': 64, 'LEARNING_RATE': 0.005363026429645663, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 0.6905260307844295 | Recall score: 0.7789550602849835 \n",
      "Training =>  Epoch : 1 | Loss : 2.2944126295488934 | Recall score: 0.21681132937414344\n",
      "Validation =>  Epoch : 1 | Loss : 2.284345809803453 | Recall score: 0.2502740226525393 \n",
      "Training =>  Epoch : 2 | Loss : 2.2757492508999135 | Recall score: 0.2488807674737323\n",
      "Validation =>  Epoch : 2 | Loss : 2.2659329869026363 | Recall score: 0.2502740226525393 \n",
      "Training =>  Epoch : 3 | Loss : 2.257688451644986 | Recall score: 0.2488807674737323\n",
      "Validation =>  Epoch : 3 | Loss : 2.2488337616587795 | Recall score: 0.2502740226525393 \n",
      "Training =>  Epoch : 4 | Loss : 2.240580371645994 | Recall score: 0.2492462311557789\n",
      "Validation =>  Epoch : 4 | Loss : 2.2324148388796075 | Recall score: 0.2502740226525393 \n",
      "Training =>  Epoch : 5 | Loss : 2.223242382670558 | Recall score: 0.2490634993147556\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:26:40,664]\u001b[0m Trial 5 finished with value: 0.2502740226525393 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.0013909155759201078, 'OPTIMIZER': 'SGD', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 2.2165011583372602 | Recall score: 0.2502740226525393 \n",
      "Training =>  Epoch : 1 | Loss : 2.297822406125623 | Recall score: 0.07291000456829602\n",
      "Validation =>  Epoch : 1 | Loss : 2.2853450276130856 | Recall score: 0.08878333942272561 \n",
      "Training =>  Epoch : 2 | Loss : 2.2744852831197337 | Recall score: 0.21279122887163088\n",
      "Validation =>  Epoch : 2 | Loss : 2.26320003908734 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 3 | Loss : 2.25255604954653 | Recall score: 0.25207857469164\n",
      "Validation =>  Epoch : 3 | Loss : 2.2424383662467777 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 4 | Loss : 2.2314580318539643 | Recall score: 0.25116491548652353\n",
      "Validation =>  Epoch : 4 | Loss : 2.222840808158697 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 5 | Loss : 2.212048189584599 | Recall score: 0.2535404294198264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:26:53,579]\u001b[0m Trial 6 finished with value: 0.24187066130800147 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.0015679535585867276, 'OPTIMIZER': 'SGD', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 2.2044096991073254 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 1 | Loss : 2.319662913333538 | Recall score: 0.050525354042941985\n",
      "Validation =>  Epoch : 1 | Loss : 2.3075776155604872 | Recall score: 0.03215199123127512 \n",
      "Training =>  Epoch : 2 | Loss : 2.2955671715181927 | Recall score: 0.08743718592964825\n",
      "Validation =>  Epoch : 2 | Loss : 2.2848962295887083 | Recall score: 0.09426379247351115 \n",
      "Training =>  Epoch : 3 | Loss : 2.273710022138995 | Recall score: 0.22311557788944725\n",
      "Validation =>  Epoch : 3 | Loss : 2.2635302599086318 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 4 | Loss : 2.252368748188019 | Recall score: 0.25582457743261766\n",
      "Validation =>  Epoch : 4 | Loss : 2.2434398296267486 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 5 | Loss : 2.2312754655993263 | Recall score: 0.25363179534033803\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:27:06,505]\u001b[0m Trial 7 finished with value: 0.24187066130800147 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.001476773324930558, 'OPTIMIZER': 'SGD', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 2.2241597120151964 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 1 | Loss : 2.251894724923511 | Recall score: 0.2201005025125628\n",
      "Validation =>  Epoch : 1 | Loss : 2.2101386314214664 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 2 | Loss : 2.171167740988177 | Recall score: 0.25701233439926907\n",
      "Validation =>  Epoch : 2 | Loss : 2.144756611003432 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 3 | Loss : 2.115110772986745 | Recall score: 0.2566468707172225\n",
      "Validation =>  Epoch : 3 | Loss : 2.0952961999316546 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 4 | Loss : 2.0650697516840557 | Recall score: 0.25874828688899043\n",
      "Validation =>  Epoch : 4 | Loss : 2.0558717139931613 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 5 | Loss : 2.0343749980593837 | Recall score: 0.26624029237094565\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:27:19,286]\u001b[0m Trial 8 finished with value: 0.24187066130800147 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.006919868586810927, 'OPTIMIZER': 'SGD', 'NUM_EPOCHS': 5, 'DROPOUT': 0.1}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 5 | Loss : 2.0236197876375774 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 1 | Loss : 2.268897827281508 | Recall score: 0.16738236637734125\n",
      "Validation =>  Epoch : 1 | Loss : 2.238264887831932 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 2 | Loss : 2.2051571164020274 | Recall score: 0.25637277295568756\n",
      "Validation =>  Epoch : 2 | Loss : 2.1818804075551586 | Recall score: 0.24187066130800147 \n",
      "Training =>  Epoch : 3 | Loss : 2.1549610453982684 | Recall score: 0.25829145728643216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2021-12-03 18:27:27,398]\u001b[0m Trial 9 finished with value: 0.24187066130800147 and parameters: {'TRAIN_BATCH_SIZE': 32, 'LEARNING_RATE': 0.00468226023599736, 'OPTIMIZER': 'SGD', 'NUM_EPOCHS': 3, 'DROPOUT': 0.5}. Best is trial 3 with value: 0.794665692363902.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation =>  Epoch : 3 | Loss : 2.1346853278404057 | Recall score: 0.24187066130800147 \n"
     ]
    }
   ],
   "source": [
    "# Data Loaders\n",
    "trainloader = DataLoader(malware_trainset, batch_size=64, shuffle=True)\n",
    "testloader = DataLoader(malware_testset, batch_size=64, shuffle=False)\n",
    "\n",
    "# Define your hyperparameters here\n",
    "def _hyper_parameter_tuning(trial):\n",
    "    \n",
    "    set_device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    \n",
    "    hyper_paramaters = {\n",
    "        'TRAIN_BATCH_SIZE' :  trial.suggest_categorical('TRAIN_BATCH_SIZE', (32, 64)),\n",
    "        'LEARNING_RATE' : trial.suggest_loguniform('LEARNING_RATE', 0.001, 0.01),\n",
    "        'OPTIMIZER': trial.suggest_categorical(\"OPTIMIZER\", [\"Adam\", \"RMSprop\", \"SGD\"]),\n",
    "        'NUM_EPOCHS' : trial.suggest_categorical(\"NUM_EPOCHS\", [3, 5]),\n",
    "        'DROPOUT' : trial.suggest_categorical(\"DROPOUT\", [0.1, 0.3, 0.5])\n",
    "    }\n",
    "    \n",
    "    model = MalwareNet(input_dim=train_data[0][0].shape[0], output_dim=len(label_encodings)).to(set_device)\n",
    "    criterion = nn.CrossEntropyLoss().to(set_device)\n",
    "    optimizer = getattr(optim, hyper_paramaters['OPTIMIZER'])(model.parameters(), lr=hyper_paramaters['LEARNING_RATE'])\n",
    "    \n",
    "    recall = _network_training(model, hyper_paramaters, criterion, optimizer, set_device, tuning=True)\n",
    "    return np.max(recall)\n",
    "\n",
    "with warnings.catch_warnings(record=True):\n",
    "    analysis_study = optuna.create_study(direction='maximize')\n",
    "    analysis_study.optimize(_hyper_parameter_tuning, n_trials=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Selection of hyper parameters on the basis of hyperparameter tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SELECTED BEST SET OF HYPER-PARAMETERS: {'TRAIN_BATCH_SIZE': 64, 'LEARNING_RATE': 0.0027997096218844567, 'OPTIMIZER': 'Adam', 'NUM_EPOCHS': 5, 'DROPOUT': 0.5}\n",
      "RECALL SCORE ACHEIVED USING THE BEST HYPER-PARAMTERS 0.794665692363902\n"
     ]
    }
   ],
   "source": [
    "print(\"SELECTED BEST SET OF HYPER-PARAMETERS:\",analysis_study.best_params)\n",
    "print(\"RECALL SCORE ACHEIVED USING THE BEST HYPER-PARAMTERS\", analysis_study.best_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "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>value</th>\n",
       "      <th>duration</th>\n",
       "      <th>params_DROPOUT</th>\n",
       "      <th>params_LEARNING_RATE</th>\n",
       "      <th>params_NUM_EPOCHS</th>\n",
       "      <th>params_OPTIMIZER</th>\n",
       "      <th>params_TRAIN_BATCH_SIZE</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trial</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.794666</td>\n",
       "      <td>0 days 00:00:23.105603</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.002800</td>\n",
       "      <td>5</td>\n",
       "      <td>Adam</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.792474</td>\n",
       "      <td>0 days 00:00:23.096978</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.003177</td>\n",
       "      <td>5</td>\n",
       "      <td>Adam</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.787358</td>\n",
       "      <td>0 days 00:00:14.110369</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.003683</td>\n",
       "      <td>3</td>\n",
       "      <td>Adam</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.779320</td>\n",
       "      <td>0 days 00:00:22.875442</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.005363</td>\n",
       "      <td>5</td>\n",
       "      <td>Adam</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.688710</td>\n",
       "      <td>0 days 00:00:23.207712</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.009860</td>\n",
       "      <td>5</td>\n",
       "      <td>Adam</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.250274</td>\n",
       "      <td>0 days 00:00:13.330855</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.001391</td>\n",
       "      <td>5</td>\n",
       "      <td>SGD</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.241871</td>\n",
       "      <td>0 days 00:00:12.915385</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.001568</td>\n",
       "      <td>5</td>\n",
       "      <td>SGD</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.241871</td>\n",
       "      <td>0 days 00:00:12.926099</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.001477</td>\n",
       "      <td>5</td>\n",
       "      <td>SGD</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.241871</td>\n",
       "      <td>0 days 00:00:12.763447</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.006920</td>\n",
       "      <td>5</td>\n",
       "      <td>SGD</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.241871</td>\n",
       "      <td>0 days 00:00:08.112415</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.004682</td>\n",
       "      <td>3</td>\n",
       "      <td>SGD</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          value               duration  params_DROPOUT  params_LEARNING_RATE  \\\n",
       "trial                                                                          \n",
       "3      0.794666 0 days 00:00:23.105603             0.5              0.002800   \n",
       "0      0.792474 0 days 00:00:23.096978             0.5              0.003177   \n",
       "2      0.787358 0 days 00:00:14.110369             0.5              0.003683   \n",
       "4      0.779320 0 days 00:00:22.875442             0.5              0.005363   \n",
       "1      0.688710 0 days 00:00:23.207712             0.1              0.009860   \n",
       "5      0.250274 0 days 00:00:13.330855             0.5              0.001391   \n",
       "6      0.241871 0 days 00:00:12.915385             0.5              0.001568   \n",
       "7      0.241871 0 days 00:00:12.926099             0.5              0.001477   \n",
       "8      0.241871 0 days 00:00:12.763447             0.1              0.006920   \n",
       "9      0.241871 0 days 00:00:08.112415             0.5              0.004682   \n",
       "\n",
       "       params_NUM_EPOCHS params_OPTIMIZER  params_TRAIN_BATCH_SIZE  \n",
       "trial                                                               \n",
       "3                      5             Adam                       64  \n",
       "0                      5             Adam                       64  \n",
       "2                      3             Adam                       32  \n",
       "4                      5             Adam                       64  \n",
       "1                      5             Adam                       64  \n",
       "5                      5              SGD                       32  \n",
       "6                      5              SGD                       32  \n",
       "7                      5              SGD                       32  \n",
       "8                      5              SGD                       32  \n",
       "9                      3              SGD                       32  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = analysis_study.trials_dataframe().drop(['state','datetime_start','datetime_complete','number'], axis=1)\n",
    "df.index.name = 'trial'\n",
    "df.sort_values(by='value', ascending=False).head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Hyper-parameters were important and how did they influence your results?\n",
    "> From the results of the hyper parameter tuning we can summarize and visualize in the plot below that for our network, **choice of optimizer had significance importance on our objective value (recall_scores)**. Adam was able to display good results and just within 5 epochs with a learning rate of around 0.002, we were able to reach more than 0.79 recall score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_param_importances(analysis_study)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![plot_param_importances](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/plot_params_importance_malware.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parallel coordinate plot displays the dependence of the objective value (recall scores) with respect to the hyper parameters. \n",
    "- The highest objective value corresponds to the droput value 0.5 and with 0.1 dropout we got lower recall scores. \n",
    "- Better learning rates lie below 0.009 and above 0.001.\n",
    "- As for optimizer, SGD has provided the worst scores and ADAM gave the best scores.\n",
    "- Objective value using batch size 32 ad 64 are reasonably similar but the training for **batch 32 is faster compartively to batch 64**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_parallel_coordinate(analysis_study)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![plot_parallel_coordinate](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/plot_parallel_coordinate_malware.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Below graph shows the history of the optimization trials that were conducted and this plot we can observe that trial 3 was able to achieve a higher recall (objective value), before that trial 0 and 2 were pretty close and they both had used ADAM with dropout 0.5 but with a higher learning rate and after that the next trials conducted using SGD gave worst results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_optimization_history(analysis_study)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![plot_optimization_history](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/plot_optimization_history_malware.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What were other design choices you faced?\n",
    "> Objective was able to reach above 0.60 recall score (as per the requirements of this project) with a simple 4 layered DNN model. However some regularisation techniques like dropout was included to have even better results and to reduce overfitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NtpgVAO1sMi2"
   },
   "source": [
    "## 2.d. Train your Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "id": "3afVBWVKsMi2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network structure is: <bound method Module.parameters of MalwareNet(\n",
      "  (layers): Sequential(\n",
      "    (0): Linear(in_features=5521, out_features=1024, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=1024, out_features=512, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=512, out_features=256, bias=True)\n",
      "    (5): ReLU()\n",
      "    (6): Linear(in_features=256, out_features=128, bias=True)\n",
      "    (7): ReLU()\n",
      "    (8): Linear(in_features=128, out_features=10, bias=True)\n",
      "    (9): Dropout(p=0.1, inplace=False)\n",
      "  )\n",
      ")>\n",
      "Total number of parameters: 6344842\n",
      "Training =>  Epoch : 1 | Loss : 1.0109317820779113 | Recall score: 0.6532663316582915\n",
      "Validation =>  Epoch : 1 | Loss : 0.6421010230862817 | Recall score: 0.7690902447935696 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 2 | Loss : 0.7094655324553334 | Recall score: 0.7472818638647785\n",
      "Validation =>  Epoch : 2 | Loss : 0.6110247948835063 | Recall score: 0.8019729630982828 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 3 | Loss : 0.6534487901385441 | Recall score: 0.7577889447236181\n",
      "Validation =>  Epoch : 3 | Loss : 0.5532514723234399 | Recall score: 0.8100109609061016 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 4 | Loss : 0.6067940627419671 | Recall score: 0.7767016902695295\n",
      "Validation =>  Epoch : 4 | Loss : 0.5581820329954458 | Recall score: 0.8092802338326635 \n",
      "Training =>  Epoch : 5 | Loss : 0.605486120942027 | Recall score: 0.7756966651439013\n",
      "Validation =>  Epoch : 5 | Loss : 0.558241469915523 | Recall score: 0.8070880526123493 \n",
      "Training =>  Epoch : 6 | Loss : 0.574553111037456 | Recall score: 0.7811786203746003\n",
      "Validation =>  Epoch : 6 | Loss : 0.578746076240096 | Recall score: 0.7917427840701498 \n",
      "Training =>  Epoch : 7 | Loss : 0.5623387897083926 | Recall score: 0.7854728186386478\n",
      "Validation =>  Epoch : 7 | Loss : 0.5400029448575752 | Recall score: 0.8118377785896967 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 8 | Loss : 0.5563782916382648 | Recall score: 0.7879396984924623\n",
      "Validation =>  Epoch : 8 | Loss : 0.5349775178487911 | Recall score: 0.8107416879795396 \n",
      "Training =>  Epoch : 9 | Loss : 0.5457051207506379 | Recall score: 0.792964824120603\n",
      "Validation =>  Epoch : 9 | Loss : 0.5584466263305309 | Recall score: 0.8089148702959444 \n",
      "Training =>  Epoch : 10 | Loss : 0.5485601840692378 | Recall score: 0.7888533576975788\n",
      "Validation =>  Epoch : 10 | Loss : 0.5317739012629487 | Recall score: 0.8187796857873584 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 11 | Loss : 0.5301180478445319 | Recall score: 0.7926907263590681\n",
      "Validation =>  Epoch : 11 | Loss : 0.5235855399176131 | Recall score: 0.8198757763975155 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 12 | Loss : 0.523733394696962 | Recall score: 0.7940612151667428\n",
      "Validation =>  Epoch : 12 | Loss : 0.5281579861807268 | Recall score: 0.8154914139568871 \n",
      "Training =>  Epoch : 13 | Loss : 0.5258011502500753 | Recall score: 0.7968935587026039\n",
      "Validation =>  Epoch : 13 | Loss : 0.5416863394338031 | Recall score: 0.8074534161490683 \n",
      "Training =>  Epoch : 14 | Loss : 0.5081714883793232 | Recall score: 0.8021927820922796\n",
      "Validation =>  Epoch : 14 | Loss : 0.5706404801024947 | Recall score: 0.8154914139568871 \n",
      "Training =>  Epoch : 15 | Loss : 0.5109112592803877 | Recall score: 0.803654636820466\n",
      "Validation =>  Epoch : 15 | Loss : 0.6040592900542325 | Recall score: 0.8217025940811107 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 16 | Loss : 0.5011653898413791 | Recall score: 0.8027409776153495\n",
      "Validation =>  Epoch : 16 | Loss : 0.5812824319961459 | Recall score: 0.8235294117647058 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 17 | Loss : 0.5019382860424907 | Recall score: 0.8072179077204202\n",
      "Validation =>  Epoch : 17 | Loss : 0.5667706935904747 | Recall score: 0.8052612349287541 \n",
      "Training =>  Epoch : 18 | Loss : 0.5001391241716784 | Recall score: 0.8030150753768844\n",
      "Validation =>  Epoch : 18 | Loss : 0.623129375452219 | Recall score: 0.8209718670076727 \n",
      "Training =>  Epoch : 19 | Loss : 0.5014182530170264 | Recall score: 0.8040201005025126\n",
      "Validation =>  Epoch : 19 | Loss : 0.627504650243493 | Recall score: 0.8184143222506394 \n",
      "Training =>  Epoch : 20 | Loss : 0.4977230909706884 | Recall score: 0.805207857469164\n",
      "Validation =>  Epoch : 20 | Loss : 0.5782254102618195 | Recall score: 0.8129338691998539 \n",
      "Training =>  Epoch : 21 | Loss : 0.4996323585510254 | Recall score: 0.8032891731384194\n",
      "Validation =>  Epoch : 21 | Loss : 0.596416481705599 | Recall score: 0.8191450493240775 \n",
      "Training =>  Epoch : 22 | Loss : 0.48778522872301033 | Recall score: 0.8095934216537232\n",
      "Validation =>  Epoch : 22 | Loss : 0.6106225002643674 | Recall score: 0.8067226890756303 \n",
      "Training =>  Epoch : 23 | Loss : 0.49303533318777415 | Recall score: 0.8110552763819096\n",
      "Validation =>  Epoch : 23 | Loss : 0.5771558374859566 | Recall score: 0.8268176835951772 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 24 | Loss : 0.48078462607389705 | Recall score: 0.8097761534947464\n",
      "Validation =>  Epoch : 24 | Loss : 0.5724151079044786 | Recall score: 0.8180489587139204 \n",
      "Training =>  Epoch : 25 | Loss : 0.4796848726827045 | Recall score: 0.8092279579716766\n",
      "Validation =>  Epoch : 25 | Loss : 0.6193290872629299 | Recall score: 0.8111070515162587 \n",
      "Training =>  Epoch : 26 | Loss : 0.4649208316144257 | Recall score: 0.8170854271356784\n",
      "Validation =>  Epoch : 26 | Loss : 0.59085486032242 | Recall score: 0.8312020460358056 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 27 | Loss : 0.4664344070262687 | Recall score: 0.8124257651895843\n",
      "Validation =>  Epoch : 27 | Loss : 0.6359316110610962 | Recall score: 0.8326635001826818 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 28 | Loss : 0.47113652873870937 | Recall score: 0.8148012791228871\n",
      "Validation =>  Epoch : 28 | Loss : 0.6166470889435258 | Recall score: 0.8333942272561199 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 29 | Loss : 0.45549098211665484 | Recall score: 0.8235724074920054\n",
      "Validation =>  Epoch : 29 | Loss : 0.6473832262116809 | Recall score: 0.8414322250639387 \n",
      "Saving the model...\n",
      "Training =>  Epoch : 30 | Loss : 0.45214549807268517 | Recall score: 0.8176336226587483\n",
      "Validation =>  Epoch : 30 | Loss : 0.6642394356949385 | Recall score: 0.8191450493240775 \n"
     ]
    }
   ],
   "source": [
    "\n",
    "set_device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    \n",
    "training_params = {\n",
    "        'TRAIN_BATCH_SIZE' : 64,\n",
    "        'TEST_BATCH_SIZE' : 64,\n",
    "        'LEARNING_RATE' : 0.001,\n",
    "        'OPTIMIZER': optim.Adam,\n",
    "        'NUM_EPOCHS' : 30\n",
    "        'DROPOUT' : 0.5\n",
    "}\n",
    "\n",
    "model = MalwareNet(input_dim=train_data[0][0].shape[0], output_dim=len(label_encodings)).to(set_device)\n",
    "print(f'Network structure is: {model.parameters}')\n",
    "print(f'Total number of parameters: {sum(p.numel() for p in model.parameters())}')\n",
    "    \n",
    "criterion = nn.CrossEntropyLoss().to(set_device)\n",
    "optimizer = training_params['OPTIMIZER'](model.parameters(), lr=training_params['LEARNING_RATE'])\n",
    "with warnings.catch_warnings(record=True):\n",
    "    train_loss_history, recall_train_history,  validation_loss_history, recall_validation_history = _network_training(model, training_params, criterion, optimizer, set_device, tuning=False)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss curves: Training Loss vs Validation Loss Per Epoch During Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "df = pd.DataFrame({'Training Loss':train_loss_history, 'Validation Loss':validation_loss_history})\n",
    "df.plot(linewidth=4, alpha=0.7, figsize=(12,7), label='Loss')\n",
    "plt.xlim([0,30])\n",
    "\n",
    "plt.title('Training Loss vs Validation Loss per Epoch', fontsize=20)\n",
    "plt.grid(axis='y', alpha=.5)\n",
    "plt.yticks(fontsize=12, alpha=.7)\n",
    "plt.xticks(fontsize=12, alpha=.7)\n",
    "plt.xlabel('Epoch', fontsize=18, alpha=.7)\n",
    "plt.ylabel('Loss Value', fontsize=18, alpha=.7)\n",
    "# Lighten borders\n",
    "plt.gca().spines[\"top\"].set_alpha(.0)\n",
    "plt.gca().spines[\"bottom\"].set_alpha(.3)\n",
    "plt.gca().spines[\"right\"].set_alpha(.0)\n",
    "plt.gca().spines[\"left\"].set_alpha(.3)\n",
    "\n",
    "plt.legend(loc='upper center')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recall curves: Training Recall vs Validation Recall Per Epoch During Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "df = pd.DataFrame({'Training Recall':recall_train_history, 'Validation Recall':recall_validation_history})\n",
    "df.plot(linewidth=4, alpha=0.7, figsize=(12,7), label='Loss')\n",
    "plt.xlim([0,30])\n",
    "# plt.ylim(-20,100)\n",
    "plt.title('Training Recall vs Validation Recall per Epoch', fontsize=20)\n",
    "plt.grid(axis='y', alpha=.5)\n",
    "plt.yticks(fontsize=12, alpha=.7)\n",
    "plt.xticks(fontsize=12, alpha=.7)\n",
    "plt.xlabel('Epoch', fontsize=18, alpha=.7)\n",
    "plt.ylabel('Recall', fontsize=18, alpha=.7)\n",
    "# Lighten borders\n",
    "plt.gca().spines[\"top\"].set_alpha(.0)\n",
    "plt.gca().spines[\"bottom\"].set_alpha(.3)\n",
    "plt.gca().spines[\"right\"].set_alpha(.0)\n",
    "plt.gca().spines[\"left\"].set_alpha(.3)\n",
    "\n",
    "plt.legend(loc='lower center')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z5w-7O5jsMi2"
   },
   "source": [
    "## 2.e. Evaluate model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "CMbzX1h4sMi2"
   },
   "outputs": [],
   "source": [
    "def test_model(model, dataloader, vectorization_method, checkpoint_path=None):\n",
    "    \"\"\"\n",
    "    Performs evaluation on the test set for a given model,\n",
    "    while loading pretrained checkpoint from disk.\n",
    "    \"\"\"\n",
    "    if checkpoint_path:\n",
    "        load_model(model, checkpoint_path)  \n",
    "    recall_test_history = list()\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        y_true_test, y_pred_test= list(), list()\n",
    "\n",
    "        for batch, targets, lengths in testloader:\n",
    "            ## perform forward pass  \n",
    "            batch = batch.type(torch.FloatTensor).to(set_device)\n",
    "            pred = model(batch) \n",
    "            preds = torch.max(pred, 1)[1]\n",
    "\n",
    "            ## accumulate predictions per batch for the epoch\n",
    "            y_pred_test += list([list(label_encodings.keys())[x.item()] for x in preds.detach().cpu().numpy()])\n",
    "            targets = torch.LongTensor([x.item() for x in list(targets)])\n",
    "            y_true_test +=  list([list(label_encodings.keys())[x.item()] for x in targets.detach().cpu().numpy()])\n",
    "\n",
    "        print(f\"{vectorization_method} Vectorization: Test set\")\n",
    "        print(f'Recall score (Micro Avg)=> {evaluate_preds(y_true_test, y_pred_test)}')\n",
    "        print(f'Classification Report =>\\n {classification_report(y_true_test, y_pred_test)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BOW Vectorization: Test set\n",
      "Recall score (Micro Avg)=> 0.8408\n",
      "Classification Report =>\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "       Agent       0.70      0.50      0.58       294\n",
      "     Allaple       0.99      1.00      1.00       345\n",
      "      AutoIt       0.99      1.00      1.00       467\n",
      "       Basun       0.82      0.94      0.88      1563\n",
      "NothingFound       0.80      0.74      0.77      2528\n",
      "     Patched       0.33      0.02      0.03       335\n",
      "     Swizzor       0.98      1.00      0.99       428\n",
      "       Texel       0.80      0.94      0.86      2585\n",
      "          VB       0.91      0.87      0.89       556\n",
      "       Virut       0.93      0.84      0.89       899\n",
      "\n",
      "    accuracy                           0.84     10000\n",
      "   macro avg       0.83      0.78      0.79     10000\n",
      "weighted avg       0.83      0.84      0.83     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## evaluate model on test set\n",
    "set_device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "with warnings.catch_warnings(record=True):\n",
    "    testloader = DataLoader(malware_testset, batch_size=32, shuffle=False)  \n",
    "    model = MalwareNet(input_dim=train_data[0][0].shape[0], output_dim=len(label_encodings)).to(set_device)\n",
    "    test_model(model, testloader, vectorization_method, f'{vectorization_method}_model.ckpt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U_GE1BQjsMi3"
   },
   "source": [
    "## 2.f. Save Model + Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "## saving the model\n",
    "save_model(model, out_path=f\"{vectorization_method}_model.ckpt\")\n",
    "\n",
    "## saving the train dataset\n",
    "pickle_file(f\"train_v{MAX_VOCAB_SIZE}_{vectorization_method}.pkl\", train_data)\n",
    "\n",
    "## saving the test dataset\n",
    "pickle_file(f\"test_v{MAX_VOCAB_SIZE}_{vectorization_method}.pkl\", test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uLD6dur1sMi3"
   },
   "source": [
    "# 3. Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1QRKxLsPsMi3"
   },
   "source": [
    "## 3.a. Summary: Main Results\n",
    "\n",
    "**Vectorization Approach:** For vectorization we considered three approaches which include **Bag-Of-Words** which places '1' if a certain token from dictionary occurs in the given document then it adds '1' at the index of that token for that given document, hence resulting in a matrix equivalent to (number of documents x vocabulary size), secondly, we opted for **Count Vectorizer** which similar to Bag-Of-Words however instead of placing '1' it places the count of that perticular term in the given document at the index. Finally, we chose **TF-IDF (term frequency–inverse document frequency)** which more sphosticated as it computes term importance by computing term frequencies and inverse document frequencies in order to give weight to rare terms which could be important for a given document during training of a classifier. After computing the vectors using the above mentioned approaches we then trained separate malware classifiers for each vectorized dataset, and performed hyperparameter tuning for each. Also, we chose **recall** also known as true positive rate as **evaluation metric**, since we it computes the rate of correctly predicted malwares out of the true class of malware, since our goal is to correctly identify the category of malware since that would greatly help in the consequent diagnostic measures.\n",
    "\n",
    "Following are the results for the best models from each vectorizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BOW Vectorization: Test set\n",
      "Recall score (Micro Avg)=> 0.8388\n",
      "Classification Report =>\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "       Agent       0.62      0.57      0.60       294\n",
      "     Allaple       1.00      1.00      1.00       345\n",
      "      AutoIt       0.99      1.00      1.00       467\n",
      "       Basun       0.82      0.94      0.88      1563\n",
      "NothingFound       0.81      0.71      0.76      2528\n",
      "     Patched       0.60      0.01      0.02       335\n",
      "     Swizzor       0.98      1.00      0.99       428\n",
      "       Texel       0.79      0.96      0.86      2585\n",
      "          VB       0.90      0.87      0.88       556\n",
      "       Virut       0.95      0.84      0.89       899\n",
      "\n",
      "    accuracy                           0.84     10000\n",
      "   macro avg       0.85      0.79      0.79     10000\n",
      "weighted avg       0.83      0.84      0.82     10000\n",
      "\n",
      "COUNT_VEC Vectorization: Test set\n",
      "Recall score (Micro Avg)=> 0.7735\n",
      "Classification Report =>\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "       Agent       0.00      0.00      0.00       294\n",
      "     Allaple       1.00      1.00      1.00       345\n",
      "      AutoIt       0.99      1.00      0.99       467\n",
      "       Basun       0.76      1.00      0.86      1563\n",
      "NothingFound       0.68      0.65      0.67      2528\n",
      "     Patched       0.00      0.00      0.00       335\n",
      "     Swizzor       0.96      0.98      0.97       428\n",
      "       Texel       0.75      0.89      0.81      2585\n",
      "          VB       0.72      0.58      0.64       556\n",
      "       Virut       0.93      0.74      0.83       899\n",
      "\n",
      "    accuracy                           0.77     10000\n",
      "   macro avg       0.68      0.68      0.68     10000\n",
      "weighted avg       0.73      0.77      0.75     10000\n",
      "\n",
      "TF_IDF Vectorization: Test set\n",
      "Recall score (Micro Avg)=> 0.8084\n",
      "Classification Report =>\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "       Agent       0.64      0.37      0.47       294\n",
      "     Allaple       1.00      1.00      1.00       345\n",
      "      AutoIt       0.99      1.00      1.00       467\n",
      "       Basun       0.76      1.00      0.86      1563\n",
      "NothingFound       0.74      0.67      0.70      2528\n",
      "     Patched       0.00      0.00      0.00       335\n",
      "     Swizzor       0.97      1.00      0.99       428\n",
      "       Texel       0.79      0.91      0.85      2585\n",
      "          VB       0.83      0.80      0.82       556\n",
      "       Virut       0.96      0.76      0.85       899\n",
      "\n",
      "    accuracy                           0.81     10000\n",
      "   macro avg       0.77      0.75      0.75     10000\n",
      "weighted avg       0.78      0.81      0.79     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Print recall score and classification reports of all three vectorization methods\n",
    "vectorization_methods = [\"BOW\", \"COUNT_VEC\", \"TF_IDF\"]\n",
    "\n",
    "for vec_method in vectorization_methods:\n",
    "    ## read test data from disk\n",
    "    test_data = unpickle_file(f'test_v{MAX_VOCAB_SIZE}_{vec_method}.pkl')\n",
    "    \n",
    "    ## wrap it with torch data set\n",
    "    malware_testset = MalwareDataset(test_data[0], test_data[1], test_data[2])\n",
    "    \n",
    "    ## create dataloader from the dataset\n",
    "    testloader = DataLoader(malware_testset, batch_size=32, shuffle=False)  \n",
    "    \n",
    "    ## init empty model\n",
    "    model = MalwareNet(input_dim=test_data[0][0].shape[0], output_dim=len(label_encodings)).to(set_device)\n",
    "    \n",
    "    ## perform evaluation by providing path to checkpoint\n",
    "    test_model(model, testloader, vec_method, f'{vec_method}_model.ckpt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dNKqJAoasMi4"
   },
   "source": [
    "## 3.b. Discussion\n",
    "\n",
    "Enter your final summary here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance, you can address:\n",
    "- **What was the performance you obtained with the simplest approach?** <br/>\n",
    "We achieved the recall score of 84% (micro averaged) with the simplest approach Bag-Of-Words which computes sparse vectors each documents by placing '1' for each occurence of a term in the given document."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Which vectorized input representations helped more than the others?** <br/>\n",
    "The simplest Bag-of-words approach outperformed the other counter vectorizer and tf-idf vectorizer. One potential reason for this result is since BOW gives equal weightage to each term in the document vector that would have proved to be pivotal count vectorizer puts emphasis to more frequent terms hence that may not be of much importance for some malware classes and since TF-IDF normalizes those terms more if they occur frequently across the corpus hence it  outperformed count vectorizer however, giving equal weights to each vector proved more effective in this dataset since we were training a simple DNN with linear layers and ReLU as non linearity. Also, following is the plot of per batch recall scores (micro averaged) of each of the vectorizer's best model on the test set. It can be seen that BOW approach makes more stable and quality predictions as compared to the other two across all batches of test set.\n",
    "![Malware Per Batch Test Recall](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/recall_scores_test_scores_malware.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Which malwares are difficult to detect and why?** <br/>\n",
    "Malware **'Patched'** proved to be the most difficult to detect the best model producing a recall score of mere 1% whereas the other two approaches yielded 0% recall. Secondly, malware **'Agent'** was also slightly tricky to detect for all the model which yielded the accuracy of 57% by the best model. \n",
    "<br/>This could be down to the following reasons: <br/>\n",
    "Firstly, **class imbalance** it can be seen in the following plot of labels distribution in terms of frequency in the training dataset. It is clearly evident both malwares Agent and Patched have less than 1/5 of the number of training samples as compared to the most frequent malware 'Texel', this could've prevented the classifier to not find any reasonable patterns since the number of samples were too small for these two malwares.\n",
    "\n",
    "![Malware Labels Histogram](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/freq_malware.png)\n",
    "\n",
    "Secondly, another potential reason could be **small document content length** it can be seen below where we present the average document length for each type of malware in training dataset. Also, both these malwares have small average content length, however, the smallest content length based malware **texel** still manages to achieve a recall score of 91% on the best model. So, potentially either one of these two reasons or both have contributed to make them very hard to detect.\n",
    "<br />\n",
    "![Malware Document Length](https://raw.githubusercontent.com/shahrukhx01/ocr-test/main/document_len_malware.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Which approach do you recommend to perform malware classification?** <br/>\n",
    "Empirically, BOW (Bag-Of-Words) outperformed the other two vectorization approaches. So Bag-of-Words approach with techniques like **oversampling** to counter class imbalance can serve as a strong baseline for malware classification, however, more sphosticated vectorizers which incorporate contextual information from the sequences such as word embeddings (Word2Vec) and recent state-of-the-art attention mechanism based transformer model based approaches such as BERT, GPT-2/3 can potentially produce far better quality of results when detecting the type of malware. However, the downside would such approaches are more effective on sequences of smaller to medium length sequnces (512 to 2k tokens per document/sequence), however, in our case some of the malware files was 300k token per document/sequence. However, incorporating some contextual information could prove to be interesting."
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}