project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project: Machine Learning Techniques for Packer Detection\n",
    "*Team #1 - Connie Dunlap, Ryne Krueger, Jackson Robbins, Wyatt Tauber*\n",
    "\n",
    "*CSEC-520/620 Cyber Analytics & Machine Learning*\n",
    "\n",
    "## Prerequisites\n",
    "This notebook must be run on Ubuntu 20.04.3.\n",
    "\n",
    "This notebook requires the following packages:\n",
    "* matplotlib\n",
    "* sklearn\n",
    "* numpy\n",
    "\n",
    "This notebook requires the following software be runnable from the terminal:\n",
    "* rahash2 (part of radare2)\n",
    "\n",
    "The following folders should be in the same directory as this notebook:\n",
    "* ASPack/\n",
    "* MEW/\n",
    "* MPRESS/\n",
    "* PECompact/\n",
    "* PEtite/\n",
    "* UPX/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Data Selection & Processing\n",
    "\n",
    "Process the data from raw executable files into useable features for our selected ML models. See the project PDF for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 485,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "1.1 Data Analysis/1.2 Feature Extraction\n",
    "Author: Wyatt Tauber\n",
    "\n",
    "Convert the raw executable files into sha256_hash,packer,entropy lists\n",
    "Plot packer types and entropies in dataset\n",
    "\"\"\"\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import subprocess\n",
    "\n",
    "# the feature lists\n",
    "packed_data = []\n",
    "unpacked_data = []\n",
    "\n",
    "# loop through each packer directory and process the files\n",
    "for dir in os.listdir():\n",
    "    if '.' not in dir:\n",
    "        for file in os.listdir(dir):\n",
    "            # call radare2 to calculate entropy and store the result\n",
    "            command = \"rahash2 -a entropy\"\n",
    "            string = dir + \"/\" + file\n",
    "            proc = subprocess.Popen([command + \" \" + string], stdout=subprocess.PIPE, shell=True)\n",
    "            (out, err) = proc.communicate()\n",
    "\n",
    "            # get the hash and entropy of the file\n",
    "            file_info = out.decode().strip().split()\n",
    "            \n",
    "            file_hash = file_info[0].split(\"/\")[-1][0:-1]\n",
    "            file_entropy = file_info[-1]\n",
    "            \n",
    "            # place the file information in the appropriate list\n",
    "            if 'unpacked' in file_hash:\n",
    "                file_hash = file_hash.split('_')[-1]\n",
    "                file_packer = \"none\"\n",
    "                datapoint = [file_hash,file_packer,file_entropy]\n",
    "                unpacked_data.append(datapoint)\n",
    "            else:\n",
    "                file_packer = dir\n",
    "                datapoint = [file_hash,file_packer,file_entropy]\n",
    "                packed_data.append(datapoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get dataset packer statistics\n",
    "packer_dict = {}\n",
    "\n",
    "for data in packed_data:\n",
    "    if data[1] in packer_dict:\n",
    "        packer_dict[data[1]] += 1\n",
    "    else:\n",
    "        packer_dict[data[1]] = 1\n",
    "\n",
    "# add the unpacked data\n",
    "packer_dict[\"none\"] = len(unpacked_data)\n",
    "\n",
    "# plot the data on a graph\n",
    "names = list(packer_dict.keys())\n",
    "values = list(packer_dict.values())\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)\n",
    "fig.subplots_adjust(hspace=0.05)  # adjust space between axes\n",
    "\n",
    "# plot the same data on both axes\n",
    "ax1.bar(range(len(packer_dict)), values, tick_label=names)\n",
    "ax2.bar(range(len(packer_dict)), values, tick_label=names)\n",
    "\n",
    "# zoom-in / limit the view to different portions of the data\n",
    "ax1.set_ylim(80, 500)  # outliers only\n",
    "ax2.set_ylim(0, 20)  # most of the data\n",
    "\n",
    "# hide the spines between ax and ax2\n",
    "ax1.spines.bottom.set_visible(False)\n",
    "ax2.spines.top.set_visible(False)\n",
    "ax1.xaxis.tick_top()\n",
    "ax1.tick_params(labeltop=False)  # don't put tick labels at the top\n",
    "ax2.xaxis.tick_bottom()\n",
    "\n",
    "d = .5  # proportion of vertical to horizontal extent of the slanted line\n",
    "kwargs = dict(marker=[(-1, -d), (1, d)], markersize=12,\n",
    "              linestyle=\"none\", color='k', mec='k', mew=1, clip_on=False)\n",
    "ax1.plot([0, 1], [0, 0], transform=ax1.transAxes, **kwargs)\n",
    "ax2.plot([0, 1], [1, 1], transform=ax2.transAxes, **kwargs)\n",
    "\n",
    "# labels\n",
    "plt.title(\"Figure 1: Packer Types in Dataset\", y=2.1)\n",
    "ax2.set_xlabel('Packer Type')\n",
    "ax2.set_ylabel('Number of Samples', y=1, labelpad=8)\n",
    "\n",
    "# prevent x-axis labels from running together\n",
    "plt.xticks(rotation=30)\n",
    "\n",
    "# show the plot\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# entropy lists\n",
    "packed_entropies = []\n",
    "unpacked_entropies = []\n",
    "\n",
    "# create entropy lists\n",
    "for data in packed_data:\n",
    "    packed_entropies.append(float(data[2]))\n",
    "\n",
    "for data in unpacked_data:\n",
    "    unpacked_entropies.append(float(data[2]))\n",
    "\n",
    "# convert entropy lists to numpy arrays\n",
    "packed_entropies = np.asarray(packed_entropies)\n",
    "unpacked_entropies = np.asarray(unpacked_entropies)\n",
    "\n",
    "# plot packed sample entropies\n",
    "fig1,ax1 = plt.subplots(1,1)\n",
    "ax1.hist(packed_entropies, bins = range(8))\n",
    "ax1.set_title(\"Figure 2: Packed Sample Entropy\")\n",
    "ax1.set_xticks([0,1,2,3,4,5,6,7,8])\n",
    "ax1.set_xlabel('Entropy')\n",
    "ax1.set_ylabel('Number of Samples')\n",
    "plt.show()\n",
    "\n",
    "# plot unpacked sample entropies\n",
    "fig2,ax2 = plt.subplots(1,1)\n",
    "ax2.hist(unpacked_entropies, bins = range(8))\n",
    "ax2.set_title(\"Figure 3: Unpacked Sample Entropy\")\n",
    "ax2.set_xticks([0,1,2,3,4,5,6,7,8])\n",
    "ax2.set_xlabel('Entropy')\n",
    "ax2.set_ylabel('Number of Samples')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 488,
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "1.3 Dataset Cleaning\n",
    "Author: Jackson Robbins, Wyatt Tauber\n",
    "\n",
    "Convert the lists into numeric values supported by Numpy\n",
    "\"\"\"\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "\n",
    "# create train/test splits of all of the data\n",
    "total_data = packed_data + unpacked_data\n",
    "train_set, test_set = train_test_split(total_data, test_size=0.4, random_state=7294802)\n",
    "\n",
    "# create the label and data lists for the splits\n",
    "train_label = []\n",
    "test_label = []\n",
    "train_data = []\n",
    "test_data = []\n",
    "\n",
    "for data in train_set:\n",
    "    #  store the training labels\n",
    "    if data[1] == \"none\":\n",
    "        train_label.append(0)\n",
    "    else:\n",
    "        train_label.append(1)\n",
    "\n",
    "    # store the training data\n",
    "    train_data.append(float(data[2]))\n",
    "\n",
    "for data in test_set:\n",
    "    # store the testing labels\n",
    "    if data[1] == \"none\":\n",
    "        test_label.append(0)\n",
    "    else:\n",
    "        test_label.append(1)\n",
    "\n",
    "    # store the testing data\n",
    "    test_data.append(float(data[2]))\n",
    "\n",
    "# convert the data to Numpy arrays\n",
    "train_label = np.asarray(train_label)\n",
    "test_label = np.asarray(test_label)\n",
    "train_data = np.asarray(train_data)\n",
    "test_data = np.asarray(test_data)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Experiments & Results\n",
    "\n",
    "Implement various ML models, tune hyperparameters, and present metrics. See the project PDF for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 489,
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "2.1 Metrics\n",
    "Author: Wyatt Tauber\n",
    "\n",
    "Plot the accuracy versus hyperparameter values.\n",
    "\"\"\"\n",
    "\n",
    "def make_hp_plot(x_axis, acc_lst, prec_lst, rec_lst, f1_lst, x_label, title):\n",
    "    \"\"\"\n",
    "    Make a hyperparameter tuning plot out of the metrics\n",
    "    :param x_axis: x-axis scale\n",
    "    :param acc_lst: list of accuracies the size of x\n",
    "    :param prec_lst: list of precisions the size of x\n",
    "    :param rec_lst: list of recalls the size of x\n",
    "    :param f1_lst: list of F1-scores the size of x\n",
    "    :param x_label: x-axis label\n",
    "    :param title: graph title\n",
    "    \"\"\"\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    ax.plot(x_axis, acc_lst, label=\"Accuracy\")\n",
    "    ax.plot(x_axis, prec_lst, label=\"Precision\")\n",
    "    ax.plot(x_axis, rec_lst, label=\"Recall\")\n",
    "    ax.plot(x_axis, f1_lst, label=\"F1-Score\")\n",
    "\n",
    "    plt.title(title)\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.xlabel(x_label)\n",
    "    plt.ylabel(\"Metric Performance\")\n",
    "    plt.show()\n",
    "\n",
    "def metric_lists_append(acc_lst, prec_lst, rec_lst, f1_lst, acc, prec, rec, f1):\n",
    "    \"\"\"\n",
    "    Append the metrics to the metric lists\n",
    "    :param acc_lst: accuracy list\n",
    "    :param prec_lst: precision list\n",
    "    :param rec_lst: recall list\n",
    "    :param f1_lst: f1-score list\n",
    "    :param acc: accuracy\n",
    "    :param prec: precision\n",
    "    :param rec: recall\n",
    "    :param f1: f1-score\n",
    "    :return: appended lists\n",
    "    \"\"\"\n",
    "    acc_lst.append(acc)\n",
    "    prec_lst.append(prec)\n",
    "    rec_lst.append(rec)\n",
    "    f1_lst.append(f1)\n",
    "\n",
    "    return acc_lst, prec_lst, rec_lst, f1_lst"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 2.2 Logistic Regression"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Metrics:\n",
      "Accuracy: 0.8860759493670886\n",
      "Precision: 0.875\n",
      "Recall: 0.9054726368159204\n",
      "F1-score: 0.8899755501222493\n",
      "\n",
      "Figure 4: Logistic Regression Confusion Matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "2.2 Logistic Regression\n",
    "Author: Jackson Robbins, Wyatt Tauber\n",
    "\n",
    "An sklearn logistic regression implementation\n",
    "\"\"\"\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay\n",
    "\n",
    "# reshape the data into 2 dimensions\n",
    "logistic_train_data = train_data.reshape(-1,1)\n",
    "logistic_test_data = test_data.reshape(-1,1)\n",
    "\n",
    "# perform logistic regression on the train data\n",
    "logisticRegr = LogisticRegression()\n",
    "logisticRegr.fit(logistic_train_data, train_label)\n",
    "\n",
    "# make predictions on the test data\n",
    "logistic_predictions = logisticRegr.predict(logistic_test_data)\n",
    "\n",
    "# print the metrics\n",
    "logistic_accuracy = accuracy_score(logistic_predictions, test_label)\n",
    "logistic_precision = precision_score(logistic_predictions, test_label)\n",
    "logistic_recall = recall_score(logistic_predictions, test_label)\n",
    "logistic_f1 = f1_score(logistic_predictions, test_label)\n",
    "\n",
    "print(\"Logistic Regression Metrics:\")\n",
    "print(\"Accuracy:\", logistic_accuracy)\n",
    "print(\"Precision:\", logistic_precision)\n",
    "print(\"Recall:\", logistic_recall)\n",
    "print(\"F1-score:\", logistic_f1)\n",
    "\n",
    "# create the confusion matrix\n",
    "logistic_cf_matrix = confusion_matrix(logistic_predictions, test_label)\n",
    "display = ConfusionMatrixDisplay(confusion_matrix=logistic_cf_matrix, display_labels=[\"Packed\", \"Unpacked\"])\n",
    "display.plot()\n",
    "\n",
    "# display the confusion matrix\n",
    "print(\"\\nFigure 4: Logistic Regression Confusion Matrix\")\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 2.3 Linear SVM"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 491,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear SVM Metrics:\n",
      "Accuracy: 0.8784810126582279\n",
      "Precision: 0.875\n",
      "Recall: 0.8921568627450981\n",
      "F1-score: 0.883495145631068\n",
      "\n",
      "Figure 5: Linear SVM Confusion Matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "2.3 Linear SVM\n",
    "Author: Jackson Robbins, Wyatt Tauber\n",
    "\n",
    "A sklearn linear SVM implementation\n",
    "\"\"\"\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# reshape the data into 2 dimensions\n",
    "svm_train_data = train_data.reshape(-1,1)\n",
    "svm_test_data = test_data.reshape(-1,1)\n",
    "\n",
    "# run linear SVM on the train data\n",
    "clf = SVC(kernel='linear')\n",
    "clf.fit(svm_train_data, train_label)\n",
    "\n",
    "# make predictions on the test data\n",
    "svm_predictions = clf.predict(svm_test_data)\n",
    "\n",
    "# print the metrics\n",
    "svm_accuracy = accuracy_score(svm_predictions, test_label)\n",
    "svm_precision = precision_score(svm_predictions, test_label)\n",
    "svm_recall = recall_score(svm_predictions, test_label)\n",
    "svm_f1 = f1_score(svm_predictions, test_label)\n",
    "\n",
    "print(\"Linear SVM Metrics:\")\n",
    "print(\"Accuracy:\", svm_accuracy)\n",
    "print(\"Precision:\", svm_precision)\n",
    "print(\"Recall:\", svm_recall)\n",
    "print(\"F1-score:\", svm_f1)\n",
    "\n",
    "# create the confusion matrix\n",
    "svm_cf_matrix = confusion_matrix(svm_predictions, test_label)\n",
    "display = ConfusionMatrixDisplay(confusion_matrix=svm_cf_matrix, display_labels=[\"Packed\", \"Unpacked\"])\n",
    "display.plot()\n",
    "\n",
    "# display the confusion matrix\n",
    "print(\"\\nFigure 5: Linear SVM Confusion Matrix\")\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wyatt/anaconda3/lib/python3.9/site-packages/sklearn/svm/_base.py:255: ConvergenceWarning: Solver terminated early (max_iter=200).  Consider pre-processing your data with StandardScaler or MinMaxScaler.\n",
      "  warnings.warn('Solver terminated early (max_iter=%i).'\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hyperparameter tuning\n",
    "\n",
    "# adjusting C\n",
    "svm_acc, svm_prec, svm_rec, svm_f1 = 0, 0, 0, 0\n",
    "svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst = [], [], [], []\n",
    "x = np.arange(0.1, 5.1, 0.1)\n",
    "x_c = [*x]\n",
    "\n",
    "for c_i in x:\n",
    "    # run linear SVM on the train data\n",
    "    clf = SVC(kernel='linear', C=c_i)\n",
    "    clf.fit(svm_train_data, train_label)\n",
    "\n",
    "    # make predictions on the test data\n",
    "    svm_predictions = clf.predict(svm_test_data)\n",
    "\n",
    "    # get the metrics\n",
    "    svm_acc = accuracy_score(svm_predictions, test_label)\n",
    "    svm_prec = precision_score(svm_predictions, test_label)\n",
    "    svm_rec = recall_score(svm_predictions, test_label)\n",
    "    svm_f1 = f1_score(svm_predictions, test_label)\n",
    "\n",
    "    svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst = \\\n",
    "        metric_lists_append(svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst,\n",
    "                            svm_acc, svm_prec, svm_rec, svm_f1)\n",
    "\n",
    "make_hp_plot(x_c, svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst, \"C Value\", \"Figure 6: Linear SVM Hyperparameter Tuning: C Value\")\n",
    "\n",
    "# adjusting max_iter\n",
    "svm_acc, svm_prec, svm_rec, svm_f1 = 0, 0, 0, 0\n",
    "svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst = [], [], [], []\n",
    "x = np.arange(200, 500, 100)\n",
    "x_mi = [*x]\n",
    "\n",
    "for mi_i in x:\n",
    "    # run linear SVM on the train data\n",
    "    clf = SVC(kernel='linear', max_iter=mi_i)\n",
    "    clf.fit(svm_train_data, train_label)\n",
    "\n",
    "    # make predictions on the test data\n",
    "    svm_predictions = clf.predict(svm_test_data)\n",
    "\n",
    "    # get the metrics\n",
    "    svm_acc = accuracy_score(svm_predictions, test_label)\n",
    "    svm_prec = precision_score(svm_predictions, test_label)\n",
    "    svm_rec = recall_score(svm_predictions, test_label)\n",
    "    svm_f1 = f1_score(svm_predictions, test_label)\n",
    "\n",
    "    svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst = \\\n",
    "        metric_lists_append(svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst,\n",
    "                            svm_acc, svm_prec, svm_rec, svm_f1)\n",
    "\n",
    "make_hp_plot(x_mi, svm_acc_lst, svm_prec_lst, svm_rec_lst, svm_f1_lst, \"Maximum Iterations\", \"Figure 7: Linear SVM Hyperparameter Tuning: Maximum Iterations\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 2.4 Naive Bayes"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 493,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive Bayes Metrics:\n",
      "Accuracy: 0.8556962025316456\n",
      "Precision: 0.7644230769230769\n",
      "Recall: 0.9520958083832335\n",
      "F1-score: 0.8480000000000001\n",
      "\n",
      "Figure 8: Naive Bayes Confusion Matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "2.4 Naive Bayes\n",
    "Author: Wyatt Tauber\n",
    "\n",
    "A sklearn Naive Bayes implementation\n",
    "\"\"\"\n",
    "from sklearn.naive_bayes import GaussianNB, MultinomialNB, ComplementNB, BernoulliNB, CategoricalNB\n",
    "\n",
    "# reshape the data into 2 dimensions\n",
    "nb_train_data = train_data.reshape(-1,1)\n",
    "nb_test_data = test_data.reshape(-1,1)\n",
    "\n",
    "# run Naive Bayes on the training data\n",
    "nb = CategoricalNB()\n",
    "nb.fit(nb_train_data, train_label)\n",
    "\n",
    "# make predictions on the test data\n",
    "nb_predictions = nb.predict(nb_test_data)\n",
    "\n",
    "# print the metrics\n",
    "nb_accuracy = accuracy_score(nb_predictions, test_label)\n",
    "nb_precision = precision_score(nb_predictions, test_label)\n",
    "nb_recall = recall_score(nb_predictions, test_label)\n",
    "nb_f1 = f1_score(nb_predictions, test_label)\n",
    "\n",
    "print(\"Naive Bayes Metrics:\")\n",
    "print(\"Accuracy:\", nb_accuracy)\n",
    "print(\"Precision:\", nb_precision)\n",
    "print(\"Recall:\", nb_recall)\n",
    "print(\"F1-score:\", nb_f1)\n",
    "\n",
    "# create the confusion matrix\n",
    "nb_cf_matrix = confusion_matrix(nb_predictions, test_label)\n",
    "display = ConfusionMatrixDisplay(confusion_matrix=nb_cf_matrix, display_labels=[\"Packed\", \"Unpacked\"])\n",
    "display.plot()\n",
    "\n",
    "# display the confusion matrix\n",
    "print(\"\\nFigure 8: Naive Bayes Confusion Matrix\")\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}