diff --git a/mal_extrac.ipynb b/mal_extrac.ipynb
new file mode 100644
index 0000000..838a56a
--- /dev/null
+++ b/mal_extrac.ipynb
@@ -0,0 +1,3321 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 548,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "3d5CYN8JSQgp"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import cv2\n",
+    "import copy\n",
+    "import csv\n",
+    "import random\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import itertools\n",
+    "from scipy.stats import randint\n",
+    "from itertools import cycle\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.pyplot import figure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 549,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "iiKgZIzNSS1w"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn import preprocessing\n",
+    "from sklearn.manifold import TSNE\n",
+    "from sklearn.decomposition import TruncatedSVD\n",
+    "from sklearn import metrics\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn import preprocessing\n",
+    "from scipy.sparse import csr_matrix\n",
+    "from scipy import stats\n",
+    "from my_ml_lib import DataManipulationTools, MetricTools, PlotTools\n",
+    "from sklearn.model_selection import GridSearchCV\n",
+    "from sklearn.model_selection import RandomizedSearchCV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 550,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "V2Q6UcbgSWrc"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn import svm\n",
+    "from sklearn.neural_network import MLPClassifier\n",
+    "from xgboost import XGBClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.ensemble import BaggingClassifier, RandomForestClassifier, AdaBoostClassifier\n",
+    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
+    "from sklearn.decomposition import PCA\n",
+    "from skimage.feature import hog, local_binary_pattern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 551,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Sm2SnXjoS6m4"
+   },
+   "outputs": [],
+   "source": [
+    "def write_csv(file, a1, a2, a3, a4, a5, a6, a7, name):\n",
+    "    with open(file, mode='w') as csv_file:\n",
+    "        csv_writer = csv.writer(csv_file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "        csv_writer.writerow(name)\n",
+    "        for i in range(20):\n",
+    "            if a2[i] == None:\n",
+    "                a2[i] = 'None'\n",
+    "            if a4[i] == None:\n",
+    "                a4[i] = 'None'\n",
+    "            csv_writer.writerow([a1[i], a2[i], a3[i], a4[i], a5[i], a6[i], a7[i]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 733,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Fn456X2YTDka"
+   },
+   "outputs": [],
+   "source": [
+    "def read_images(path='content/sample_data/cell_images'):\n",
+    "    images = []\n",
+    "    labels = []\n",
+    "    num1 = 32\n",
+    "    num2 = 32\n",
+    "    file_name='Parasitized'\n",
+    "    for file_name in os.listdir(path):\n",
+    "        file_path = path + '/' + file_name\n",
+    "        for img_name in os.listdir(file_path):\n",
+    "            if not img_name.startswith('.'):\n",
+    "                if img_name.endswith('.png'):\n",
+    "                    img = cv2.imread(file_path + '/' + img_name)\n",
+    "                    new_img = cv2.resize(img, (num2, num1))\n",
+    "                    images.append(new_img)\n",
+    "                    if file_name == 'Parasitized':\n",
+    "                        label = 0\n",
+    "                    else:\n",
+    "                        label = 1\n",
+    "                    labels.append(label)\n",
+    "    \n",
+    "    return np.array(images), np.array(labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "xVCjuxcXW5Yy"
+   },
+   "source": [
+    "# New Section"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 692,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "LWIiqIVnuglw"
+   },
+   "outputs": [],
+   "source": [
+    "def save_feature(feature, name):\n",
+    "    # saving all our feature vectors in pickled file\n",
+    "    with open('content/sample_data/cache/' + name + '.pkl', 'wb') as fp:\n",
+    "        pickle.dump(csr_matrix(feature), fp)\n",
+    "    \n",
+    "    print(f'Feature saved with name cache/{name}.pkl')\n",
+    "\n",
+    "def load_feature(feature_name):\n",
+    "    return pickle.load(open(feature_name, 'rb')).A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 693,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "TlA-zG1dupbk"
+   },
+   "outputs": [],
+   "source": [
+    "def save_model(model):\n",
+    "    filename = input('Enter model file name:')\n",
+    "    pickle.dump(model, open('models/'+filename + '.pkl', 'wb'))\n",
+    "    print(f'Successfully saved model in models/{filename}.pkl')\n",
+    "\n",
+    "def load_model(model_name):\n",
+    "    return pickle.load(open(model_name, 'rb'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 555,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "xybS4ANyuzgJ"
+   },
+   "outputs": [],
+   "source": [
+    "def get_flattened(images, color=cv2.COLOR_RGB2GRAY, name='flattened', save=False):\n",
+    "    \"\"\"\n",
+    "    color: default RGB2GRAY, if None is passed then color is used as it is.\n",
+    "    \"\"\"\n",
+    "    color_images = []\n",
+    "    if color is not None:\n",
+    "        for img in images:\n",
+    "            color_images.append(cv2.cvtColor(img, color))\n",
+    "    else:\n",
+    "        color_images = images\n",
+    "    \n",
+    "    count = len(color_images)\n",
+    "    \n",
+    "    result = np.array(color_images).reshape(count, -1)\n",
+    "    \n",
+    "    if save:\n",
+    "        save_feature(result, name)\n",
+    "        \n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 556,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "mMKeYh-eu0cC"
+   },
+   "outputs": [],
+   "source": [
+    "def get_color_hist(images, name='color_hist', save=False):\n",
+    "    histograms = []\n",
+    "    for img in images:\n",
+    "        histograms.append(cv2.calcHist([img], [0, 1, 2],None, [8, 8, 8], [0, 256, 0, 256, 0, 256]).flatten())\n",
+    "    \n",
+    "    result = np.array(histograms)\n",
+    "    \n",
+    "    if save:\n",
+    "        save_feature(result, name)\n",
+    "        \n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 557,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "S5ZDXsPAu391"
+   },
+   "outputs": [],
+   "source": [
+    "def get_hog(images, name='hog', save=False):\n",
+    "    result = np.array([hog(img, block_norm='L2') for img in images])\n",
+    "    \n",
+    "    if save:\n",
+    "        save_feature(result, name)\n",
+    "        \n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 559,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4MLzrEs6vDxz"
+   },
+   "outputs": [],
+   "source": [
+    "def combine_features(features, horizontal=True):\n",
+    "    \"\"\"\n",
+    "    Array of features [f1, f2, f3] where each fi is a feature set \n",
+    "    eg. f1=rgb_flat, f2=SIFT, etc.\n",
+    "    \"\"\"\n",
+    "    if horizontal:\n",
+    "        return np.hstack(features)\n",
+    "    else:\n",
+    "        return np.vstack(features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 560,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "RYOB5B1MY8Xa"
+   },
+   "outputs": [],
+   "source": [
+    "def norm_features_minmax(train, test):\n",
+    "    min_max_scaler = preprocessing.MinMaxScaler()\n",
+    "    norm_train = min_max_scaler.fit_transform(train)\n",
+    "    norm_test = min_max_scaler.transform(test)\n",
+    "    \n",
+    "    return norm_train, norm_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 561,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "a9uuhPj1vHAA"
+   },
+   "outputs": [],
+   "source": [
+    "def norm_features_zscore(train, test):\n",
+    "    min_max_scaler = preprocessing.StandardScaler()\n",
+    "    norm_train = min_max_scaler.fit_transform(train)\n",
+    "    norm_test = min_max_scaler.transform(test)\n",
+    "    \n",
+    "    return norm_train, norm_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 562,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "YmxOnsvYK6Wx"
+   },
+   "outputs": [],
+   "source": [
+    "def train_model(train_x, train_y, model_name, validation=None):\n",
+    "   \n",
+    "    model = None\n",
+    "    if model_name == 'SVM':\n",
+    "        model = svm.SVC(gamma='scale', probability=True)\n",
+    "    elif model_name == 'XGB':\n",
+    "        model = XGBClassifier(n_estimators=200, max_depth=5, n_jobs=2)\n",
+    "#         model = XGBClassifier()\n",
+    "    elif model_name == 'MLP':\n",
+    "        model = MLPClassifier(hidden_layer_sizes=(100,100,100), max_iter=800, alpha=0.0001,\n",
+    "                     solver='sgd', verbose=10, tol=0.000000001)\n",
+    "    elif model_name == 'ADA':\n",
+    "        model = AdaBoostClassifier(n_estimators=50)\n",
+    "    elif model_name == 'BAG':\n",
+    "        model = BaggingClassifier(n_jobs=2, n_estimators=50)\n",
+    "    elif model_name == 'RF':\n",
+    "        model = RandomForestClassifier(n_estimators=200, max_depth=10)\n",
+    "    elif model_name == 'KNN':\n",
+    "        model = KNeighborsClassifier(n_neighbors=5, weights='distance', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)\n",
+    "    else:\n",
+    "        model = GaussianNB()\n",
+    "    \n",
+    "    model.fit(train_x, train_y)\n",
+    "    \n",
+    "    if validation is not None:\n",
+    "        y_hat = model.predict(validation[0])\n",
+    "        acc = metrics.accuracy_score(validation[1], y_hat)\n",
+    "        print(f\"Validation Accuracy in '{model_name}' = {acc}\")\n",
+    "        cm = metrics.confusion_matrix(validation[1], y_hat)\n",
+    "        print(cm)\n",
+    "        recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "        precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "        f1 = 2*(precision*recall)/(precision+recall)\n",
+    "        print(f\"Recall in '{model_name}' = {recall}\")\n",
+    "        print(f\"Precision in '{model_name}' = {precision}\")\n",
+    "        print(f\"F1 Score in '{model_name}' = {f1}\")\n",
+    "               \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 563,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "St6cuqR0vZXn"
+   },
+   "outputs": [],
+   "source": [
+    "def plot_roc(fpr, tpr, class_name, area):\n",
+    "    figure(num=None, figsize=(12, 6), dpi=80, facecolor='w', edgecolor='k')\n",
+    "    \n",
+    "    plt.plot(fpr,tpr)\n",
+    "\n",
+    "    plt.xlabel('False Positive Rate')\n",
+    "    plt.ylabel('True Positive Rate')\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 564,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "yPq7Z077vcx0"
+   },
+   "outputs": [],
+   "source": [
+    "def plot_combine_roc(test_y, prob):\n",
+    "    n_classes = 6\n",
+    "    name_arr = ['RF', 'BAG', 'NB', 'SVM', 'KNN', 'XGB']\n",
+    "    fpr = dict()\n",
+    "    tpr = dict()\n",
+    "    roc_auc = dict()\n",
+    "    for i in range(n_classes):\n",
+    "        fpr[i], tpr[i], _ = metrics.roc_curve(test_y, prob[:, i])\n",
+    "        roc_auc[i] = metrics.roc_auc_score(test_y,  prob[:, i])\n",
+    "\n",
+    "    figure(num=None, figsize=(12, 6), dpi=80, facecolor='w', edgecolor='k')\n",
+    "    colors = cycle(['darkorange', 'cornflowerblue', 'red', 'purple', 'pink', 'violet', 'green'])\n",
+    "    for i, color in zip(range(n_classes), colors):\n",
+    "        plt.plot(fpr[i], tpr[i], color=color,\n",
+    "                 label='ROC curve for ' + name_arr[i] + ' class (area = {1:0.2f})'\n",
+    "                 ''.format(i, roc_auc[i]))\n",
+    "\n",
+    "    plt.xlabel('False Positive Rate')\n",
+    "    plt.ylabel('True Positive Rate')\n",
+    "    plt.legend()\n",
+    "#     plt.savefig('output/roc_lda_on_pca_uninfected.png')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 565,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "cVC7wznFLG5i"
+   },
+   "outputs": [],
+   "source": [
+    "def confusion_mat(cm, classes, title='Confusion matrix', cmap=plt.cm.Blues, figsize=(7,7), path=None, filename=None):\n",
+    "        \"\"\"\n",
+    "        cm: confusion matrix to be plotted.\n",
+    "        classes: array of labels or class names.\n",
+    "        title: title of the confusion matrix.\n",
+    "        cmap: color of the plot matrix.\n",
+    "        figsize: tupple (width, height) representiong size of the plot.\n",
+    "        path: destination where the plot image will be saved.\n",
+    "        filename: name to save the file with on the specified path. (if None, title is used)\n",
+    "        \n",
+    "        # Source: https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html\n",
+    "        \"\"\"\n",
+    "        cm = cm.astype(np.int64)\n",
+    "        plt.figure(figsize=figsize)\n",
+    "        plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
+    "        plt.title(title)\n",
+    "        plt.colorbar()\n",
+    "        tick_marks = np.arange(len(classes))\n",
+    "        plt.xticks(tick_marks, classes, rotation=45)\n",
+    "        plt.yticks(tick_marks, classes)\n",
+    "\n",
+    "        fmt = 'd'\n",
+    "        thresh = cm.max() / 2.\n",
+    "        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
+    "            plt.text(j, i, format(cm[i, j], fmt),\n",
+    "                     horizontalalignment=\"center\",\n",
+    "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
+    "        plt.grid(False)\n",
+    "        plt.ylabel('True label')\n",
+    "        plt.xlabel('Predicted label')\n",
+    "        plt.tight_layout()\n",
+    "        \n",
+    "        if path:\n",
+    "            if filename is None:\n",
+    "                plt.savefig(path + title + '.png')\n",
+    "            else:\n",
+    "                plt.savefig(path + filename + '.png')\n",
+    "        plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 566,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "negSIe_DLJBq"
+   },
+   "outputs": [],
+   "source": [
+    "def pca_projection(mat, name_arr):\n",
+    "    plt.figure(figsize=(15,20))\n",
+    "    for i, img in enumerate(mat, start=1):\n",
+    "        plt.subplot(4, 2, i)\n",
+    "        y = np.var(mat[i-1], axis=0)\n",
+    "        x = list(range(1, len(y)+1))\n",
+    "        plt.plot(x, y, '--o')\n",
+    "        plt.ylabel('Variance')\n",
+    "        plt.xlabel('Data Projected on Eigen Vector Number')\n",
+    "        plt.xticks(x)\n",
+    "        plt.title(name_arr[i-1])\n",
+    "    plt.savefig('content/sample_data/output/pca/subplot.png')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 567,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "ebM1ar6zLMMi"
+   },
+   "outputs": [],
+   "source": [
+    "def draw_key_points(image, kp):\n",
+    "    img = cv2.drawKeypoints(image, kp, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n",
+    "    return img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 568,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "B58Lu9H0v87I"
+   },
+   "outputs": [],
+   "source": [
+    "full_data_x, full_data_y = read_images('content/sample_data/cell_images')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 569,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "WNGx8d9rwCpS",
+    "outputId": "d42bf387-7f69-4001-8336-14f19983c7ea"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((27558, 32, 32, 3), (27558,))"
+      ]
+     },
+     "execution_count": 569,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_data_x.shape, full_data_y.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 570,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "3BRPkwsowO3w",
+    "outputId": "561d0435-a94c-44b2-af1f-010e16aecda0"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(32, 32, 3)"
+      ]
+     },
+     "execution_count": 570,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_data_x[2].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 571,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "pS4kRrjW-6q9"
+   },
+   "outputs": [],
+   "source": [
+    "data_x, test_x, data_y, test_y = train_test_split(full_data_x, full_data_y, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 572,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "Exk8wQSQ-_or",
+    "outputId": "8c60cb46-e5c4-4128-f406-39defa2f7848"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((22046, 32, 32, 3), (5512, 32, 32, 3), (22046,), (5512,))"
+      ]
+     },
+     "execution_count": 572,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_x.shape, test_x.shape, data_y.shape, test_y.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 573,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "9wbi-cGo_Dm1"
+   },
+   "outputs": [],
+   "source": [
+    "train_imgs, val_imgs, train_y, val_y = train_test_split(data_x, data_y, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 574,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "rg3kkdj-_H2i",
+    "outputId": "29d8eb58-e7d0-4806-8fce-7bcb8cf1e02c"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 32, 32, 3), (4410, 32, 32, 3), (17636,), (4410,))"
+      ]
+     },
+     "execution_count": 574,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_imgs.shape, val_imgs.shape, train_y.shape, val_y.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 575,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "8tIiCMYU_Lgi"
+   },
+   "outputs": [],
+   "source": [
+    "np.save('content/sample_data/data/train_imgs.npy', train_imgs)\n",
+    "np.save('content/sample_data/data/train_y.npy', train_y)\n",
+    "np.save('content/sample_data/data/val_imgs.npy', val_imgs)\n",
+    "np.save('content/sample_data/data/val_y.npy', val_y)\n",
+    "\n",
+    "np.save('content/sample_data/data/data_x.npy', data_x)\n",
+    "np.save('content/sample_data/data/data_y.npy', data_y)\n",
+    "np.save('content/sample_data/data/test_x.npy', test_x)\n",
+    "np.save('content/sample_data/data/test_y.npy', test_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 576,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Ucs2-k9-_vwb"
+   },
+   "outputs": [],
+   "source": [
+    "train_imgs = np.load('content/sample_data/data/train_imgs.npy')\n",
+    "train_y = np.load('content/sample_data/data/train_y.npy')\n",
+    "val_imgs = np.load('content/sample_data/data/val_imgs.npy')\n",
+    "val_y = np.load('content/sample_data/data/val_y.npy')\n",
+    "\n",
+    "data_x = np.load('content/sample_data/data/data_x.npy')\n",
+    "data_y = np.load('content/sample_data/data/data_y.npy')\n",
+    "test_x = np.load('content/sample_data/data/test_x.npy')\n",
+    "test_y = np.load('content/sample_data/data/test_y.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 577,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "npXcpWe8J7-l",
+    "outputId": "b44bb311-be20-44db-8a40-34a98af69cf3"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((22046, 32, 32, 3), (5512, 32, 32, 3), (22046,), (5512,))"
+      ]
+     },
+     "execution_count": 577,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_x.shape, test_x.shape, data_y.shape, test_y.shape\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 578,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "jf7OBGoXJ_64",
+    "outputId": "d4ce4c4a-737a-4843-df7c-16d21144febf"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 32, 32, 3), (4410, 32, 32, 3), (17636,), (4410,))"
+      ]
+     },
+     "execution_count": 578,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_imgs.shape, val_imgs.shape, train_y.shape, val_y.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 579,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "skdWvOXaKG0G"
+   },
+   "outputs": [],
+   "source": [
+    "infected_img = train_imgs[train_y == 0][8]\n",
+    "uninfected_img = train_imgs[train_y == 1][4]\n",
+    "classes = []\n",
+    "classes.append(infected_img)\n",
+    "classes.append(uninfected_img)\n",
+    "class_label= []\n",
+    "class_label.append('infected image')\n",
+    "class_label.append('uninfected image')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 580,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "v5FY65VlZzbP"
+   },
+   "outputs": [],
+   "source": [
+    "vis_img = np.zeros((2, 32, 32))\n",
+    "for i in range(2):\n",
+    "    temp1, vis_img[i] = hog(classes[i], block_norm='L2', visualize=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 581,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "KzXZBogkKLZR"
+   },
+   "outputs": [],
+   "source": [
+    "data_vis = []\n",
+    "for i in range(len(classes)):\n",
+    "    data_vis.append(classes[i])\n",
+    "for i in range(len(classes)):\n",
+    "    data_vis.append(vis_img[i-1])\n",
+    "\n",
+    "\n",
+    "img_name_arr = []\n",
+    "for i in range(len(classes)):\n",
+    "    img_name_arr.append(class_label[i])\n",
+    "for i in range(len(classes)):\n",
+    "    img_name_arr.append('HOG')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 582,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 253.0
+    },
+    "colab_type": "code",
+    "id": "l-6ORhFULxcE",
+    "outputId": "6c961e8f-22e0-4960-9ba6-f99af01e5fe0"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(4,10))\n",
+    "for i, img in enumerate(data_vis, start=1):\n",
+    "    plt.subplot(5, 2, i)\n",
+    "    plt.title(img_name_arr[i-1])\n",
+    "    frame1 = plt.gca()\n",
+    "    for tick in frame1.axes.get_xticklines():\n",
+    "        tick.set_visible(False)\n",
+    "    for tick in frame1.axes.get_yticklines():\n",
+    "        tick.set_visible(False)\n",
+    "    for xlabel_i in frame1.axes.get_xticklabels():\n",
+    "        xlabel_i.set_visible(False)\n",
+    "    for xlabel_i in frame1.axes.get_yticklabels():\n",
+    "        xlabel_i.set_visible(False)\n",
+    "    plt.imshow(data_vis[i-1], cmap='gray')\n",
+    "#plt.savefig('/content/sample_data/output/feature_visualization.png')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 694,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 50.0
+    },
+    "colab_type": "code",
+    "id": "H0t-9SOraRwu",
+    "outputId": "13c05477-f310-4eb1-fc0b-fd57ff4824ec"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature saved with name cache/hog_train.pkl\n",
+      "Feature saved with name cache/hog_val.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "hog_train = get_hog(train_imgs, name='hog_train', save=True)\n",
+    "hog_val = get_hog(val_imgs, name='hog_val', save=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 690,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "mvM9qW-taWn9"
+   },
+   "outputs": [],
+   "source": [
+    "hog_train = load_feature('content/sample_data/cache/hog_train.pkl')\n",
+    "hog_val = load_feature('content/sample_data/cache/hog_val.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 691,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "MRP_VIKjam0N",
+    "outputId": "18bfaa3b-7a53-4971-ce88-42ffa71be184"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 324), (4410, 324))"
+      ]
+     },
+     "execution_count": 691,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hog_train.shape, hog_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 586,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 50.0
+    },
+    "colab_type": "code",
+    "id": "mlyaifDnanrm",
+    "outputId": "5832dd55-633c-4d21-9079-d6e26d577af5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature saved with name cache/flat_rgb_train.pkl\n",
+      "Feature saved with name cache/flat_rgb_val.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "flat_rgb_train = get_flattened(train_imgs, None, name='flat_rgb_train', save=True)\n",
+    "flat_rgb_val = get_flattened(val_imgs, None, name='flat_rgb_val', save=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 587,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Oa55L9F6bTs0"
+   },
+   "outputs": [],
+   "source": [
+    "flat_rgb_train = load_feature('content/sample_data/cache/flat_rgb_train.pkl')\n",
+    "flat_rgb_val = load_feature('content/sample_data/cache/flat_rgb_val.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 588,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "d_LqzqSAeQdo",
+    "outputId": "a3783836-ab89-4c58-9a5f-81d873955144"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 3072), (4410, 3072))"
+      ]
+     },
+     "execution_count": 588,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flat_rgb_train.shape, flat_rgb_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 589,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 50.0
+    },
+    "colab_type": "code",
+    "id": "unURj3KceUW2",
+    "outputId": "f909deb4-76fd-4c7d-8a97-4f83bb5d8ba7"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature saved with name cache/flat_gray_train.pkl\n",
+      "Feature saved with name cache/flat_gray_val.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "flat_gray_train = get_flattened(train_imgs, name='flat_gray_train', save=True)\n",
+    "flat_gray_val = get_flattened(val_imgs, name='flat_gray_val', save=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 590,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "k5o75zg6eYLk"
+   },
+   "outputs": [],
+   "source": [
+    "flat_gray_train = load_feature('content/sample_data/cache/flat_gray_train.pkl')\n",
+    "flat_gray_val = load_feature('content/sample_data/cache/flat_gray_val.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 591,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "mEo_uxdIecyk",
+    "outputId": "56073289-d130-4aab-ae16-44e53acf18ea"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 1024), (4410, 1024))"
+      ]
+     },
+     "execution_count": 591,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flat_gray_train.shape, flat_gray_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 592,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 50.0
+    },
+    "colab_type": "code",
+    "id": "AmmV8MR0hPuT",
+    "outputId": "c4abc8e0-4e9c-4146-d0f1-049528fb49f5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature saved with name cache/hist_train.pkl\n",
+      "Feature saved with name cache/hist_val.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "hist_train = get_color_hist(train_imgs, name='hist_train', save=True)\n",
+    "hist_val = get_color_hist(val_imgs, name='hist_val', save=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 593,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "e6oKRJm2hTgS"
+   },
+   "outputs": [],
+   "source": [
+    "hist_train = load_feature('content/sample_data/cache/hist_train.pkl')\n",
+    "hist_val = load_feature('content/sample_data/cache/hist_val.pkl')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 594,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "d8l4LLBhhXfV",
+    "outputId": "f92b7caa-6819-46eb-d0bc-f200aa581a11"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 512), (4410, 512))"
+      ]
+     },
+     "execution_count": 594,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hist_train.shape, hist_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 595,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "LZTFDZy0iE27"
+   },
+   "outputs": [],
+   "source": [
+    "norm_hog_train, norm_hog_val = norm_features_zscore(hog_train, hog_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 596,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4PBbVoWlhaPV"
+   },
+   "outputs": [],
+   "source": [
+    "pca = PCA(n_components=10)\n",
+    "pca_hog_train = pca.fit_transform(norm_hog_train)\n",
+    "pca_hog_val = pca.transform(norm_hog_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 597,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "w4dh3TxNh5Q7"
+   },
+   "outputs": [],
+   "source": [
+    "np.save('content/sample_data/cache/pca_hog_train.npy', pca_hog_train)\n",
+    "np.save('content/sample_data/cache/pca_hog_val.npy', pca_hog_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 598,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "zcmVvgK1iKm7"
+   },
+   "outputs": [],
+   "source": [
+    "pca_hog_train = np.load('content/sample_data/cache/pca_hog_train.npy')\n",
+    "pca_hog_val = np.load('content/sample_data/cache/pca_hog_val.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 599,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "-dZCDYtDijyb",
+    "outputId": "1012bd0b-ee99-4cf6-8f34-098a871d407c"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 10), (4410, 10))"
+      ]
+     },
+     "execution_count": 599,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pca_hog_train.shape, pca_hog_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 600,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "llO_csHfIHd4"
+   },
+   "outputs": [],
+   "source": [
+    "norm_flat_rgb_train, norm_flat_rgb_val = norm_features_zscore(flat_rgb_train, flat_rgb_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 601,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "DqDV3cA_IrSh"
+   },
+   "outputs": [],
+   "source": [
+    "pca = PCA(n_components=10)\n",
+    "pca_flat_rgb_train = pca.fit_transform(norm_flat_rgb_train)\n",
+    "pca_flat_rgb_val = pca.transform(norm_flat_rgb_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 602,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "skkLTv9TIwiq"
+   },
+   "outputs": [],
+   "source": [
+    "np.save('content/sample_data/cache/pca_flat_rgb_train.npy', pca_flat_rgb_train)\n",
+    "np.save('content/sample_data/cache/pca_flat_rgb_val.npy', pca_flat_rgb_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 603,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4BCY4ayQJEZL"
+   },
+   "outputs": [],
+   "source": [
+    "pca_flat_rgb_train = np.load('content/sample_data/cache/pca_flat_rgb_train.npy')\n",
+    "pca_flat_rgb_val = np.load('content/sample_data/cache/pca_flat_rgb_val.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 604,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "aH0Z1EIxJWjg",
+    "outputId": "784832e6-6f17-476b-fa3d-4fa0c77d4bb2"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 10), (4410, 10))"
+      ]
+     },
+     "execution_count": 604,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pca_flat_rgb_train.shape, pca_flat_rgb_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 605,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "JkYD3WpMJbKb"
+   },
+   "outputs": [],
+   "source": [
+    "norm_flat_gray_train, norm_flat_gray_val = norm_features_zscore(flat_gray_train, flat_gray_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 606,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "TmCHv2s1JgC7"
+   },
+   "outputs": [],
+   "source": [
+    "pca = PCA(n_components=10)\n",
+    "pca_flat_gray_train = pca.fit_transform(norm_flat_gray_train)\n",
+    "pca_flat_gray_val = pca.transform(norm_flat_gray_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 607,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "dFgOO5LDJlAd"
+   },
+   "outputs": [],
+   "source": [
+    "np.save('content/sample_data/cache/pca_flat_gray_train.npy', pca_flat_gray_train)\n",
+    "np.save('content/sample_data/cache/pca_flat_gray_val.npy', pca_flat_gray_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 608,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "RQj8nZrEJt15"
+   },
+   "outputs": [],
+   "source": [
+    "pca_flat_gray_train = np.load('content/sample_data/cache/pca_flat_gray_train.npy')\n",
+    "pca_flat_gray_val = np.load('content/sample_data/cache/pca_flat_gray_val.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 609,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "2wSvDuaSJ2Ls",
+    "outputId": "c5395119-944d-4170-c6af-efbf51937778"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 10), (4410, 10))"
+      ]
+     },
+     "execution_count": 609,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pca_flat_gray_train.shape, pca_flat_gray_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 610,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "f_qwShplKABz"
+   },
+   "outputs": [],
+   "source": [
+    "norm_hist_train, norm_hist_val = norm_features_zscore(hist_train, hist_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 611,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "bdLo8Iy5KC6c"
+   },
+   "outputs": [],
+   "source": [
+    "pca = PCA(n_components=10)\n",
+    "pca_hist_train = pca.fit_transform(norm_hist_train)\n",
+    "pca_hist_val = pca.transform(norm_hist_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 612,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "l1hzcAatKIHf"
+   },
+   "outputs": [],
+   "source": [
+    "np.save('content/sample_data/cache/pca_hist_train.npy', pca_hist_train)\n",
+    "np.save('content/sample_data/cache/pca_hist_val.npy', pca_hist_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 613,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "lZ55AXQqKR39"
+   },
+   "outputs": [],
+   "source": [
+    "pca_hist_train = np.load('content/sample_data/cache/pca_hist_train.npy')\n",
+    "pca_hist_val = np.load('content/sample_data/cache/pca_hist_val.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 614,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "fl1I7P5uKbFF",
+    "outputId": "55143c28-2f6a-4d0e-e5f5-5d4a23ccb9b2"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 10), (4410, 10))"
+      ]
+     },
+     "execution_count": 614,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pca_hist_train.shape, pca_hist_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 615,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "wKOJE0CHizFU",
+    "outputId": "edfef704-7984-4bdf-f381-c7cf1f0c1b9a"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 615,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pca_array = []\n",
+    "pca_array.append(pca_hog_train)\n",
+    "\n",
+    "pca_array.append(pca_hist_train)\n",
+    "pca_array.append(pca_flat_gray_train)\n",
+    "pca_array.append(pca_flat_rgb_train)\n",
+    "\n",
+    "\n",
+    "len(pca_array)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 616,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 598.0
+    },
+    "colab_type": "code",
+    "id": "FppOqCCPi7PF",
+    "outputId": "c9c3aff3-d2c3-4cd4-8733-7234043fdd94"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1440 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pca_projection(pca_array, ['HOG', 'Color Histogram', 'Flatten GRAY', 'Flatten RGB'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 617,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "oVIShD5UMK9u"
+   },
+   "outputs": [],
+   "source": [
+    "features_train = None\n",
+    "features_val = None\n",
+    "evs = []\n",
+    "for ft, fv in zip([hog_train, hist_train, flat_rgb_train], \n",
+    "                  [hog_val, hist_val, flat_rgb_val]):    \n",
+    "#     scaler = preprocessing.StandardScaler()\n",
+    "#     ft = scaler.fit_transform(ft)\n",
+    "#     fv = scaler.transform(fv)\n",
+    "#     ft = preprocessing.normalize(ft)\n",
+    "#     fv = preprocessing.normalize(fv)\n",
+    "    if features_train is None:\n",
+    "        features_train = ft\n",
+    "        features_val = fv\n",
+    "    else:\n",
+    "        features_train = combine_features([features_train, ft])\n",
+    "        features_val = combine_features([features_val, fv])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 618,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "HE1f2Kq2M8nu",
+    "outputId": "18cb5887-c5df-4b38-b934-c7e9620ca18d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 3908), (4410, 3908))"
+      ]
+     },
+     "execution_count": 618,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_train.shape, features_val.shape\n",
+    "       "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 619,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "HuvxeFpWNPMd"
+   },
+   "outputs": [],
+   "source": [
+    "features_train = None\n",
+    "features_val = None\n",
+    "evs = []\n",
+    "for ft, fv in zip([pca_hog_train, pca_flat_rgb_train, pca_hist_train,pca_flat_gray_train], \n",
+    "                  [pca_hog_val, pca_flat_rgb_val, pca_hist_val,pca_flat_gray_val]):    \n",
+    "#     scaler = preprocessing.StandardScaler()\n",
+    "#     ft = scaler.fit_transform(ft)\n",
+    "#     fv = scaler.transform(fv)\n",
+    "#     ft = preprocessing.normalize(ft)\n",
+    "#     fv = preprocessing.normalize(fv)\n",
+    "    if features_train is None:\n",
+    "        features_train = ft\n",
+    "        features_val = fv\n",
+    "    else:\n",
+    "        features_train = combine_features([features_train, ft])\n",
+    "        features_val = combine_features([features_val, fv])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 620,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "iNIrw_nvPMKI",
+    "outputId": "cb8e0887-5e61-4630-f889-a4dbbf62ac97"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 40), (4410, 40))"
+      ]
+     },
+     "execution_count": 620,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_train.shape, features_val.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 621,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "ws1R97uEPc3d"
+   },
+   "outputs": [],
+   "source": [
+    "features_t = pca_hist_train\n",
+    "features_v = pca_hist_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 622,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34.0
+    },
+    "colab_type": "code",
+    "id": "g8tzaqkAPopI",
+    "outputId": "5563464f-9b87-4eb2-cde9-199cbed794fd"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 10), (4410, 10))"
+      ]
+     },
+     "execution_count": 622,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_t.shape, features_v.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 623,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 118.0
+    },
+    "colab_type": "code",
+    "id": "2KPV1EDSPx9O",
+    "outputId": "0a065599-273f-49b8-a1f6-97d0b3ea9abe"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'RF' = 0.8809523809523809\n",
+      "[[1946  276]\n",
+      " [ 249 1939]]\n",
+      "Recall in 'RF' = 0.8757875787578758\n",
+      "Precision in 'RF' = 0.8865603644646924\n",
+      "F1 Score in 'RF' = 0.8811410459587956\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train, train_y, model_name='RF', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 624,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "zkL-9rbgQWss"
+   },
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val)\n",
+    "prob10 = prob1[:,0].reshape(prob1.shape[0], 1)\n",
+    "prob11 = prob1[:,1].reshape(prob1.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 625,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'BAG' = 0.8841269841269841\n",
+      "[[1977  245]\n",
+      " [ 266 1922]]\n",
+      "Recall in 'BAG' = 0.8897389738973898\n",
+      "Precision in 'BAG' = 0.8814088274632189\n",
+      "F1 Score in 'BAG' = 0.8855543113101905\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train, train_y, model_name='BAG', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 626,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob2 = model2.predict_proba(features_val)\n",
+    "prob20 = prob2[:,0].reshape(prob2.shape[0], 1)\n",
+    "prob21 = prob2[:,1].reshape(prob2.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 627,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'NB' = 0.6598639455782312\n",
+      "[[ 971 1251]\n",
+      " [ 249 1939]]\n",
+      "Recall in 'NB' = 0.436993699369937\n",
+      "Precision in 'NB' = 0.7959016393442623\n",
+      "F1 Score in 'NB' = 0.5642068564787914\n"
+     ]
+    }
+   ],
+   "source": [
+    "model4 = train_model(features_train, train_y, model_name='NB', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 628,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob4 = model4.predict_proba(features_val)\n",
+    "prob40 = prob4[:,0].reshape(prob4.shape[0], 1)\n",
+    "prob41 = prob4[:,1].reshape(prob4.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 629,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'SVM' = 0.8555555555555555\n",
+      "[[1848  374]\n",
+      " [ 263 1925]]\n",
+      "Recall in 'SVM' = 0.8316831683168316\n",
+      "Precision in 'SVM' = 0.8754144954997631\n",
+      "F1 Score in 'SVM' = 0.852988691437803\n"
+     ]
+    }
+   ],
+   "source": [
+    "model5 = train_model(features_train, train_y, model_name='SVM', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 630,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob5 = model5.predict_proba(features_val)\n",
+    "prob50 = prob5[:,0].reshape(prob5.shape[0], 1)\n",
+    "prob51 = prob5[:,1].reshape(prob5.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 631,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'XGB' = 0.9090702947845805\n",
+      "[[1993  229]\n",
+      " [ 172 2016]]\n",
+      "Recall in 'XGB' = 0.896939693969397\n",
+      "Precision in 'XGB' = 0.920554272517321\n",
+      "F1 Score in 'XGB' = 0.9085935719170276\n"
+     ]
+    }
+   ],
+   "source": [
+    "model6 = train_model(features_train, train_y, model_name='XGB', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 632,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob6 = model6.predict_proba(features_val)\n",
+    "prob60 = prob6[:,0].reshape(prob6.shape[0], 1)\n",
+    "prob61 = prob6[:,1].reshape(prob6.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 633,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'KNN' = 0.7401360544217687\n",
+      "[[1452  770]\n",
+      " [ 376 1812]]\n",
+      "Recall in 'KNN' = 0.6534653465346535\n",
+      "Precision in 'KNN' = 0.7943107221006565\n",
+      "F1 Score in 'KNN' = 0.7170370370370369\n"
+     ]
+    }
+   ],
+   "source": [
+    "model7 = train_model(np.array(features_train), train_y, model_name='KNN', validation=(features_val, val_y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 634,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob7 = model7.predict_proba(features_val)\n",
+    "prob70 = prob7[:,0].reshape(prob7.shape[0], 1)\n",
+    "prob71 = prob7[:,1].reshape(prob7.shape[0], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 635,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 960x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "prob = np.concatenate((prob10,prob20, prob40, prob50, prob60 ,prob70), axis=1)\n",
+    "plot_combine_roc(val_y, prob)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 636,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 960x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "prob = np.concatenate((prob11,prob21, prob41, prob51,prob61, prob71), axis=1)\n",
+    "plot_combine_roc(val_y, prob)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 696,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hog_comp_train = combine_features([hog_train, hog_val], horizontal=False)\n",
+    "flat_rgb_comp_train = combine_features([flat_rgb_train, flat_rgb_val], horizontal=False)\n",
+    "flat_gray_comp_train = combine_features([flat_gray_train, flat_gray_val], horizontal=False)\n",
+    "hist_comp_train = combine_features([hist_train, hist_val], horizontal=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 638,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_y = np.hstack([train_y, val_y])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 639,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pcas_array = []\n",
+    "\n",
+    "pca = PCA(n_components=10)\n",
+    "pca_hog_comp_train = pca.fit_transform(hog_comp_train)\n",
+    "pcas_array.append(pca)\n",
+    "\n",
+    "pca = PCA(n_components=20)\n",
+    "pca_flat_rgb_comp_train = pca.fit_transform(flat_rgb_comp_train)\n",
+    "pcas_array.append(pca)\n",
+    "\n",
+    "pca = PCA(n_components=20)\n",
+    "pca_flat_gray_comp_train = pca.fit_transform(flat_gray_comp_train)\n",
+    "pcas_array.append(pca)\n",
+    "\n",
+    "pca = PCA(n_components=10)\n",
+    "pca_hist_comp_train = pca.fit_transform(hist_comp_train)\n",
+    "pcas_array.append(pca)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 640,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reduced_train_features=[pca_hog_comp_train,                        \n",
+    "                        pca_flat_rgb_comp_train,\n",
+    "                        pca_flat_gray_comp_train,\n",
+    "                        pca_hist_comp_train]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 641,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature saved with name cache/hog_test.pkl\n",
+      "Feature saved with name cache/flat_rgb_test.pkl\n",
+      "Feature saved with name cache/flat_gray_test.pkl\n",
+      "Feature saved with name cache/hist_test.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "hog_test = get_hog(test_x, name='hog_test', save=True)\n",
+    "flat_rgb_test = get_flattened(test_x, None, name='flat_rgb_test', save=True)\n",
+    "flat_gray_test = get_flattened(test_x, name='flat_gray_test', save=True)\n",
+    "hist_test = get_color_hist(test_x, name='hist_test', save=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 642,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_features= [hog_test,\n",
+    "                \n",
+    "                flat_rgb_test,\n",
+    "                flat_gray_test,\n",
+    "                hist_test]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 643,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "features_comp_train = None\n",
+    "features_test = None\n",
+    "comp_pcas = []\n",
+    "\n",
+    "for i, (f_train, f_test) in enumerate(zip(reduced_train_features, \n",
+    "                                          test_features)):\n",
+    "    if i == 4:\n",
+    "        continue\n",
+    "    f_test = pcas_array[i].transform(f_test)\n",
+    "    \n",
+    "    if features_comp_train is None:\n",
+    "        features_comp_train = f_train\n",
+    "        features_test = f_test\n",
+    "    else:\n",
+    "        features_comp_train = combine_features([features_comp_train, f_train])\n",
+    "        features_test = combine_features([features_test, f_test])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 644,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((22046, 60), (5512, 60))"
+      ]
+     },
+     "execution_count": 644,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_comp_train.shape, features_test.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 645,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='XGB')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 646,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 647,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7948113207547169\n",
+      "[[2235  539]\n",
+      " [ 592 2146]]\n",
+      "0.7905907322249734 0.8056957462148522 0.7980717728976968\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 648,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='KNN')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 649,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 650,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.6469521044992743\n",
+      "[[1726 1048]\n",
+      " [ 898 1840]]\n",
+      "0.6577743902439024 0.6222062004325883 0.6394961096702482\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 651,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='RF')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 652,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 653,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7567126269956459\n",
+      "[[2142  632]\n",
+      " [ 709 2029]]\n",
+      "0.7513153279551035 0.772170151405912 0.7616\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 654,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='BAG')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 655,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 656,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7748548621190131\n",
+      "[[2207  567]\n",
+      " [ 674 2064]]\n",
+      "0.7660534536619229 0.7956020187454939 0.7805481874447391\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 657,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='SVM')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 658,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 659,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7213352685050798\n",
+      "[[2013  761]\n",
+      " [ 775 1963]]\n",
+      "0.7220229555236729 0.7256669069935112 0.7238403451995685\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 660,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_model = train_model(features_comp_train, data_y, model_name='NB')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 661,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat = comp_model.predict(features_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 662,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.6716255442670537\n",
+      "[[1884  890]\n",
+      " [ 920 1818]]\n",
+      "0.6718972895863052 0.6791636625811103 0.67551093581929\n"
+     ]
+    }
+   ],
+   "source": [
+    "acc = metrics.accuracy_score(test_y, y_hat)\n",
+    "print(acc)\n",
+    "cm = metrics.confusion_matrix(test_y, y_hat)\n",
+    "print(cm)\n",
+    "precision = cm[0][0] / (cm[0][0] + cm[1][0])\n",
+    "recall = cm[0][0] / (cm[0][0] + cm[0][1])\n",
+    "f1 = 2*(recall * precision) / (recall + precision)\n",
+    "print(precision, recall, f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 735,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clf = RandomForestClassifier(n_estimators=200)\n",
+    "\n",
+    "param_dist = {\"max_depth\": [3, None],\n",
+    "              \"class_weight\" : [\"balanced\", \"balanced_subsample\", None],\n",
+    "              \"min_samples_split\": randint(2, 11),\n",
+    "              \"bootstrap\": [True, False],\n",
+    "              \"criterion\": [\"gini\", \"entropy\"]}\n",
+    "\n",
+    "random_search = RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=20, cv=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 664,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "RandomizedSearchCV(cv=5, error_score=nan,\n",
+       "                   estimator=RandomForestClassifier(bootstrap=True,\n",
+       "                                                    ccp_alpha=0.0,\n",
+       "                                                    class_weight=None,\n",
+       "                                                    criterion='gini',\n",
+       "                                                    max_depth=None,\n",
+       "                                                    max_features='auto',\n",
+       "                                                    max_leaf_nodes=None,\n",
+       "                                                    max_samples=None,\n",
+       "                                                    min_impurity_decrease=0.0,\n",
+       "                                                    min_impurity_split=None,\n",
+       "                                                    min_samples_leaf=1,\n",
+       "                                                    min_samples_split=2,\n",
+       "                                                    min_weight_fraction_leaf=0.0,\n",
+       "                                                    n_estimators=200,\n",
+       "                                                    n_jobs...\n",
+       "                   iid='deprecated', n_iter=20, n_jobs=None,\n",
+       "                   param_distributions={'bootstrap': [True, False],\n",
+       "                                        'class_weight': ['balanced',\n",
+       "                                                         'balanced_subsample',\n",
+       "                                                         None],\n",
+       "                                        'criterion': ['gini', 'entropy'],\n",
+       "                                        'max_depth': [3, None],\n",
+       "                                        'min_samples_split': <scipy.stats._distn_infrastructure.rv_frozen object at 0x000001F0152A9888>},\n",
+       "                   pre_dispatch='2*n_jobs', random_state=None, refit=True,\n",
+       "                   return_train_score=False, scoring=None, verbose=0)"
+      ]
+     },
+     "execution_count": 664,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "random_search.fit(features_train, train_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 665,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['mean_fit_time', 'std_fit_time', 'mean_score_time', 'std_score_time', 'param_bootstrap', 'param_class_weight', 'param_criterion', 'param_max_depth', 'param_min_samples_split', 'params', 'split0_test_score', 'split1_test_score', 'split2_test_score', 'split3_test_score', 'split4_test_score', 'mean_test_score', 'std_test_score', 'rank_test_score'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(random_search.cv_results_.keys())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 666,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a1 = random_search.cv_results_['param_bootstrap']\n",
+    "a2 = random_search.cv_results_['param_class_weight']\n",
+    "a3 = random_search.cv_results_['param_criterion']\n",
+    "a4 = random_search.cv_results_['param_max_depth']\n",
+    "a5 = random_search.cv_results_['param_min_samples_split']\n",
+    "a6 = random_search.cv_results_['std_test_score']\n",
+    "\n",
+    "a7 = random_search.cv_results_['mean_test_score']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 667,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'bootstrap': False, 'class_weight': 'balanced', 'criterion': 'entropy', 'max_depth': None, 'min_samples_split': 2}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(random_search.best_params_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 668,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['bootstrap', 'class_weight', 'criterion', 'max_depth', 'min_samples_split', 'mean_train_score', 'mean_test_score']\n"
+     ]
+    }
+   ],
+   "source": [
+    "arr = []\n",
+    "for key in random_search.best_params_.keys():\n",
+    "    arr.append(key)\n",
+    "    \n",
+    "arr.append('mean_train_score')\n",
+    "arr.append('mean_test_score')\n",
+    "print(arr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 669,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8950113378684807"
+      ]
+     },
+     "execution_count": 669,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y1 = random_search.predict(features_val)\n",
+    "metrics.accuracy_score(y1, val_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 673,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_hat1 = model1.predict(features_val)\n",
+    "y_hat2 = model2.predict(features_val)\n",
+    "\n",
+    "y_hat4 = model4.predict(features_val)\n",
+    "y_hat5 = model5.predict(features_val)\n",
+    "y_hat6 = model6.predict(features_val)\n",
+    "y_hat7 = model7.predict(features_val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 676,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm1 = MetricTools.confusion_matrix(val_y, y_hat1, 2)\n",
+    "cm2 = MetricTools.confusion_matrix(val_y, y_hat2, 2)\n",
+    "\n",
+    "cm4 = MetricTools.confusion_matrix(val_y, y_hat4, 2)\n",
+    "cm5 = MetricTools.confusion_matrix(val_y, y_hat5, 2)\n",
+    "cm6 = MetricTools.confusion_matrix(val_y, y_hat6, 2)\n",
+    "cm7 = MetricTools.confusion_matrix(val_y, y_hat7, 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 677,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1946.  276.]\n",
+      " [ 249. 1939.]]\n",
+      "[[1977.  245.]\n",
+      " [ 266. 1922.]]\n",
+      "[[ 971. 1251.]\n",
+      " [ 249. 1939.]]\n",
+      "[[1848.  374.]\n",
+      " [ 263. 1925.]]\n",
+      "[[1993.  229.]\n",
+      " [ 172. 2016.]]\n",
+      "[[1452.  770.]\n",
+      " [ 376. 1812.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(cm1)\n",
+    "print(cm2)\n",
+    "\n",
+    "print(cm4)\n",
+    "print(cm5)\n",
+    "print(cm6)\n",
+    "print(cm7)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 678,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm1, list(range(2)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 679,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm2, list(range(2)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 680,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm4, list(range(2)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 681,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm5, list(range(2)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 682,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm7, list(range(2)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 697,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PlotTools.confusion_matrix(cm6, list(range(2))) #xgb  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 701,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 20), (4410, 20))"
+      ]
+     },
+     "execution_count": 701,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_train1 = None\n",
+    "features_val1 = None\n",
+    "evs = []\n",
+    "for ft, fv in zip([pca_hist_train, pca_hog_train], \n",
+    "                  [pca_hist_val, pca_hog_val]):    \n",
+    "#     scaler = preprocessing.StandardScaler()\n",
+    "#     ft = scaler.fit_transform(ft)\n",
+    "#     fv = scaler.transform(fv)\n",
+    "#     ft = preprocessing.normalize(ft)\n",
+    "#     fv = preprocessing.normalize(fv)\n",
+    "    if features_train1 is None:\n",
+    "        features_train1 = ft\n",
+    "        features_val1 = fv\n",
+    "    else:\n",
+    "        features_train1 = combine_features([features_train1, ft])\n",
+    "        features_val1 = combine_features([features_val1, fv])\n",
+    "features_train1.shape, features_val1.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 703,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((17636, 30), (4410, 30))"
+      ]
+     },
+     "execution_count": 703,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_train2 = None\n",
+    "features_val2 = None\n",
+    "evs = []\n",
+    "for ft, fv in zip([pca_hist_train, pca_flat_gray_train, pca_flat_rgb_train], \n",
+    "                  [pca_hist_val, pca_flat_gray_val, pca_flat_rgb_val]):    \n",
+    "#     scaler = preprocessing.StandardScaler()\n",
+    "#     ft = scaler.fit_transform(ft)\n",
+    "#     fv = scaler.transform(fv)\n",
+    "#     ft = preprocessing.normalize(ft)\n",
+    "#     fv = preprocessing.normalize(fv)\n",
+    "    if features_train2 is None:\n",
+    "        features_train2 = ft\n",
+    "        features_val2 = fv\n",
+    "    else:\n",
+    "        features_train2 = combine_features([features_train2, ft])\n",
+    "        features_val2 = combine_features([features_val2, fv])\n",
+    "features_train2.shape, features_val2.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 702,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'SVM' = 0.8802721088435375\n",
+      "[[1927  295]\n",
+      " [ 233 1955]]\n",
+      "Recall in 'SVM' = 0.8672367236723673\n",
+      "Precision in 'SVM' = 0.8921296296296296\n",
+      "F1 Score in 'SVM' = 0.8795070743952532\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "model1 = train_model(features_train1, train_y, model_name='SVM', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 704,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'SVM' = 0.7875283446712018\n",
+      "[[1689  533]\n",
+      " [ 404 1784]]\n",
+      "Recall in 'SVM' = 0.7601260126012601\n",
+      "Precision in 'SVM' = 0.8069756330625896\n",
+      "F1 Score in 'SVM' = 0.7828505214368482\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='SVM', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 705,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 706,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 707,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8768707482993198"
+      ]
+     },
+     "execution_count": 707,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 708,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'KNN' = 0.8412698412698413\n",
+      "[[1809  413]\n",
+      " [ 287 1901]]\n",
+      "Recall in 'KNN' = 0.8141314131413141\n",
+      "Precision in 'KNN' = 0.8630725190839694\n",
+      "F1 Score in 'KNN' = 0.8378879110699397\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train1, train_y, model_name='KNN', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 709,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'KNN' = 0.6727891156462585\n",
+      "[[1425  797]\n",
+      " [ 646 1542]]\n",
+      "Recall in 'KNN' = 0.6413141314131413\n",
+      "Precision in 'KNN' = 0.6880733944954128\n",
+      "F1 Score in 'KNN' = 0.6638714185883997\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='KNN', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 710,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 711,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 712,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8204081632653061"
+      ]
+     },
+     "execution_count": 712,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 713,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'RF' = 0.8802721088435375\n",
+      "[[1954  268]\n",
+      " [ 260 1928]]\n",
+      "Recall in 'RF' = 0.8793879387938794\n",
+      "Precision in 'RF' = 0.8825654923215899\n",
+      "F1 Score in 'RF' = 0.8809738503155997\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train1, train_y, model_name='RF', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 714,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'RF' = 0.8519274376417234\n",
+      "[[1806  416]\n",
+      " [ 237 1951]]\n",
+      "Recall in 'RF' = 0.8127812781278128\n",
+      "Precision in 'RF' = 0.8839941262848752\n",
+      "F1 Score in 'RF' = 0.8468933177022273\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='RF', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 715,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 716,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 717,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.881859410430839"
+      ]
+     },
+     "execution_count": 717,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 718,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'NB' = 0.654421768707483\n",
+      "[[ 912 1310]\n",
+      " [ 214 1974]]\n",
+      "Recall in 'NB' = 0.41044104410441046\n",
+      "Precision in 'NB' = 0.8099467140319716\n",
+      "F1 Score in 'NB' = 0.5448028673835126\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train1, train_y, model_name='NB', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 719,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'NB' = 0.5678004535147392\n",
+      "[[ 502 1720]\n",
+      " [ 186 2002]]\n",
+      "Recall in 'NB' = 0.22592259225922592\n",
+      "Precision in 'NB' = 0.7296511627906976\n",
+      "F1 Score in 'NB' = 0.3450171821305842\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='NB', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 720,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 721,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 722,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6219954648526077"
+      ]
+     },
+     "execution_count": 722,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 723,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'BAG' = 0.8834467120181406\n",
+      "[[1974  248]\n",
+      " [ 266 1922]]\n",
+      "Recall in 'BAG' = 0.8883888388838884\n",
+      "Precision in 'BAG' = 0.88125\n",
+      "F1 Score in 'BAG' = 0.8848050201703272\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train1, train_y, model_name='BAG', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 724,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'BAG' = 0.8680272108843538\n",
+      "[[1874  348]\n",
+      " [ 234 1954]]\n",
+      "Recall in 'BAG' = 0.8433843384338434\n",
+      "Precision in 'BAG' = 0.8889943074003795\n",
+      "F1 Score in 'BAG' = 0.8655889145496536\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='BAG', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 725,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 726,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 727,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8947845804988662"
+      ]
+     },
+     "execution_count": 727,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 728,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'XGB' = 0.9002267573696145\n",
+      "[[1985  237]\n",
+      " [ 203 1985]]\n",
+      "Recall in 'XGB' = 0.8933393339333934\n",
+      "Precision in 'XGB' = 0.9072212065813529\n",
+      "F1 Score in 'XGB' = 0.9002267573696145\n"
+     ]
+    }
+   ],
+   "source": [
+    "model1 = train_model(features_train1, train_y, model_name='XGB', validation=(features_val1, val_y))\n",
+    "prob1 = model1.predict_proba(features_val1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 741,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy in 'XGB' = 0.8886621315192744\n",
+      "[[1915  307]\n",
+      " [ 184 2004]]\n",
+      "Recall in 'XGB' = 0.8618361836183618\n",
+      "Precision in 'XGB' = 0.912339209147213\n",
+      "F1 Score in 'XGB' = 0.8863688960888684\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = train_model(features_train2, train_y, model_name='XGB', validation=(features_val2, val_y))\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 738,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob1 = model1.predict_proba(features_val1)\n",
+    "prob2 = model2.predict_proba(features_val2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 739,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prob = (prob1 + prob2 ) / 2\n",
+    "y_hat = np.argmax(prob, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 740,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9079365079365079"
+      ]
+     },
+     "execution_count": 740,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "metrics.accuracy_score(val_y, y_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "TPU",
+  "colab": {
+   "name": "mal-feat-extrac.ipynb",
+   "provenance": []
+  },
+  "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.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}