diff --git "a/core/bicep_model/4.evaluation.ipynb" "b/core/bicep_model/4.evaluation.ipynb"
new file mode 100644--- /dev/null
+++ "b/core/bicep_model/4.evaluation.ipynb"
@@ -0,0 +1,912 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[61196]: Class CaptureDelegate is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_videoio.3.4.16.dylib (0x10ab48860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15eece480). One of the two will be used. Which one is undefined.\n",
+      "objc[61196]: Class CVWindow is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x105918a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15eece4d0). One of the two will be used. Which one is undefined.\n",
+      "objc[61196]: Class CVView is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x105918a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15eece4f8). One of the two will be used. Which one is undefined.\n",
+      "objc[61196]: Class CVSlider is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x105918ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15eece520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score, confusion_matrix, roc_curve, auc\n",
+    "\n",
+    "from keras.utils.np_utils import to_categorical\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# Drawing helpers\n",
+    "mp_drawing = mp.solutions.drawing_utils\n",
+    "mp_pose = mp.solutions.pose"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Set ups"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1. Load models & scaler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metal device set to: Apple M1\n",
+      "\n",
+      "systemMemory: 16.00 GB\n",
+      "maxCacheSize: 5.33 GB\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-28 10:16:34.709228: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
+      "2022-11-28 10:16:34.709336: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load all sklearn models\n",
+    "with open(\"./model/all_sklearn.pkl\", \"rb\") as f:\n",
+    "    sklearn_models = pickle.load(f)\n",
+    "\n",
+    "# Load all deep learning models\n",
+    "with open(\"./model/all_dp.pkl\", \"rb\") as f:\n",
+    "    dp_models = pickle.load(f)\n",
+    "\n",
+    "# Load input scaler\n",
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    sc = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def describe_dataset(dataset_path: str):\n",
+    "    '''\n",
+    "    Describe dataset\n",
+    "    '''\n",
+    "\n",
+    "    data = pd.read_csv(dataset_path)\n",
+    "    print(f\"Headers: {list(data.columns.values)}\")\n",
+    "    print(f'Number of rows: {data.shape[0]} \\nNumber of columns: {data.shape[1]}\\n')\n",
+    "    print(f\"Labels: \\n{data['label'].value_counts()}\\n\")\n",
+    "    print(f\"Missing values: {data.isnull().values.any()}\\n\")\n",
+    "    \n",
+    "    duplicate = data[data.duplicated()]\n",
+    "    print(f\"Duplicate Rows : {len(duplicate.sum(axis=1))}\")\n",
+    "\n",
+    "    return data\n",
+    "\n",
+    "\n",
+    "def round_up_metric_results(results) -> list:\n",
+    "    '''Round up metrics results such as precision score, recall score, ...'''\n",
+    "    return list(map(lambda el: round(el, 3), results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Process Test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Headers: ['label', 'nose_x', 'nose_y', 'nose_z', 'nose_v', 'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z', 'left_shoulder_v', 'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z', 'right_shoulder_v', 'right_elbow_x', 'right_elbow_y', 'right_elbow_z', 'right_elbow_v', 'left_elbow_x', 'left_elbow_y', 'left_elbow_z', 'left_elbow_v', 'right_wrist_x', 'right_wrist_y', 'right_wrist_z', 'right_wrist_v', 'left_wrist_x', 'left_wrist_y', 'left_wrist_z', 'left_wrist_v', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v']\n",
+      "Number of rows: 604 \n",
+      "Number of columns: 37\n",
+      "\n",
+      "Labels: \n",
+      "C    339\n",
+      "L    265\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "test_df = describe_dataset(\"./test.csv\")\n",
+    "\n",
+    "# Categorizing label\n",
+    "test_df.loc[test_df[\"label\"] == \"C\", \"label\"] = 0\n",
+    "test_df.loc[test_df[\"label\"] == \"L\", \"label\"] = 1\n",
+    "\n",
+    "# Standard Scaling of features\n",
+    "test_x = test_df.drop(\"label\", axis = 1)\n",
+    "test_x = pd.DataFrame(sc.transform(test_x))\n",
+    "\n",
+    "test_y = test_df[\"label\"].astype('int')\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "test_y_cat = to_categorical(test_y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Test set evaluation for all models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1. Sklearn models evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>Precision Score</th>\n",
+       "      <th>Recall Score</th>\n",
+       "      <th>Accuracy Score</th>\n",
+       "      <th>F1 Score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>0.792694</td>\n",
+       "      <td>0.737775</td>\n",
+       "      <td>0.761589</td>\n",
+       "      <td>0.740550</td>\n",
+       "      <td>[[316, 23], [121, 144]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>0.929966</td>\n",
+       "      <td>0.933762</td>\n",
+       "      <td>0.932119</td>\n",
+       "      <td>0.931420</td>\n",
+       "      <td>[[312, 27], [14, 251]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>0.975401</td>\n",
+       "      <td>0.968336</td>\n",
+       "      <td>0.971854</td>\n",
+       "      <td>0.971230</td>\n",
+       "      <td>[[338, 1], [16, 249]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>0.684255</td>\n",
+       "      <td>0.650782</td>\n",
+       "      <td>0.675497</td>\n",
+       "      <td>0.647579</td>\n",
+       "      <td>[[289, 50], [146, 119]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>0.712457</td>\n",
+       "      <td>0.715011</td>\n",
+       "      <td>0.715232</td>\n",
+       "      <td>0.712937</td>\n",
+       "      <td>[[243, 96], [76, 189]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>0.797368</td>\n",
+       "      <td>0.564151</td>\n",
+       "      <td>0.617550</td>\n",
+       "      <td>0.486650</td>\n",
+       "      <td>[[339, 0], [231, 34]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>0.947230</td>\n",
+       "      <td>0.924528</td>\n",
+       "      <td>0.933775</td>\n",
+       "      <td>0.931329</td>\n",
+       "      <td>[[339, 0], [40, 225]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model  Precision Score  Recall Score  Accuracy Score  F1 Score  \\\n",
+       "0    LR         0.792694      0.737775        0.761589  0.740550   \n",
+       "1   SVC         0.929966      0.933762        0.932119  0.931420   \n",
+       "2   KNN         0.975401      0.968336        0.971854  0.971230   \n",
+       "3   DTC         0.684255      0.650782        0.675497  0.647579   \n",
+       "4  SGDC         0.712457      0.715011        0.715232  0.712937   \n",
+       "5    NB         0.797368      0.564151        0.617550  0.486650   \n",
+       "6    RF         0.947230      0.924528        0.933775  0.931329   \n",
+       "\n",
+       "          Confusion Matrix  \n",
+       "0  [[316, 23], [121, 144]]  \n",
+       "1   [[312, 27], [14, 251]]  \n",
+       "2    [[338, 1], [16, 249]]  \n",
+       "3  [[289, 50], [146, 119]]  \n",
+       "4   [[243, 96], [76, 189]]  \n",
+       "5    [[339, 0], [231, 34]]  \n",
+       "6    [[339, 0], [40, 225]]  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "testset_final_results = []\n",
+    "\n",
+    "for name, model in sklearn_models.items():\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(test_x)\n",
+    "\n",
+    "    p_score = precision_score(test_y, model_results, average=\"macro\")\n",
+    "    a_score = accuracy_score(test_y, model_results)\n",
+    "    r_score = recall_score(test_y, model_results, average=\"macro\")\n",
+    "    f1_score_result = f1_score(test_y, model_results, average=\"macro\")\n",
+    "    cm = confusion_matrix(test_y, model_results, labels=[0, 1])\n",
+    "    testset_final_results.append(( name,  p_score, r_score, a_score, f1_score_result, cm ))\n",
+    "\n",
+    "\n",
+    "sklearn_eval = pd.DataFrame(testset_final_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"Accuracy Score\", \"F1 Score\", \"Confusion Matrix\"])\n",
+    "\n",
+    "sklearn_eval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2. Deep learning models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>Precision Score</th>\n",
+       "      <th>Recall Score</th>\n",
+       "      <th>Accuracy Score</th>\n",
+       "      <th>F1 Score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>3_layers</td>\n",
+       "      <td>0.939165</td>\n",
+       "      <td>0.920515</td>\n",
+       "      <td>0.928808</td>\n",
+       "      <td>0.926411</td>\n",
+       "      <td>[[335, 4], [39, 226]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>0.963115</td>\n",
+       "      <td>0.949057</td>\n",
+       "      <td>0.955298</td>\n",
+       "      <td>0.954012</td>\n",
+       "      <td>[[339, 0], [27, 238]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7_layers_with_dropout</td>\n",
+       "      <td>0.935873</td>\n",
+       "      <td>0.924462</td>\n",
+       "      <td>0.930464</td>\n",
+       "      <td>0.928583</td>\n",
+       "      <td>[[330, 9], [33, 232]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>0.972145</td>\n",
+       "      <td>0.962264</td>\n",
+       "      <td>0.966887</td>\n",
+       "      <td>0.966066</td>\n",
+       "      <td>[[339, 0], [20, 245]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Model  Precision Score  Recall Score  Accuracy Score  \\\n",
+       "0               3_layers         0.939165      0.920515        0.928808   \n",
+       "1               5_layers         0.963115      0.949057        0.955298   \n",
+       "2  7_layers_with_dropout         0.935873      0.924462        0.930464   \n",
+       "3               7_layers         0.972145      0.962264        0.966887   \n",
+       "\n",
+       "   F1 Score       Confusion Matrix  \n",
+       "0  0.926411  [[335, 4], [39, 226]]  \n",
+       "1  0.954012  [[339, 0], [27, 238]]  \n",
+       "2  0.928583  [[330, 9], [33, 232]]  \n",
+       "3  0.966066  [[339, 0], [20, 245]]  "
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_set_results = []\n",
+    "\n",
+    "for name, model in dp_models.items():\n",
+    "    # Evaluate model\n",
+    "    predict_x = model.predict(test_x, verbose=False) \n",
+    "    y_pred_class = np.argmax(predict_x, axis=1)\n",
+    "    y_test_class = np.argmax(test_y_cat, axis=1)\n",
+    "\n",
+    "    cm = confusion_matrix(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    p_score = precision_score(y_test_class, y_pred_class, average=\"macro\")\n",
+    "    a_score = accuracy_score(y_test_class, y_pred_class)\n",
+    "    r_score = recall_score(y_test_class, y_pred_class, average=\"macro\")\n",
+    "    f1_score_result = f1_score(y_test_class, y_pred_class, average=\"macro\")\n",
+    "    \n",
+    "    test_set_results.append(( name,  (p_score), r_score, (a_score), (f1_score_result), cm ))\n",
+    "\n",
+    "dp_eval = pd.DataFrame(test_set_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"Accuracy Score\", \"F1 Score\", \"Confusion Matrix\"])\n",
+    "\n",
+    "dp_eval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.3. Final Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>Precision Score</th>\n",
+       "      <th>Recall Score</th>\n",
+       "      <th>Accuracy Score</th>\n",
+       "      <th>F1 Score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>0.975401</td>\n",
+       "      <td>0.968336</td>\n",
+       "      <td>0.971854</td>\n",
+       "      <td>0.971230</td>\n",
+       "      <td>[[338, 1], [16, 249]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>0.972145</td>\n",
+       "      <td>0.962264</td>\n",
+       "      <td>0.966887</td>\n",
+       "      <td>0.966066</td>\n",
+       "      <td>[[339, 0], [20, 245]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>0.963115</td>\n",
+       "      <td>0.949057</td>\n",
+       "      <td>0.955298</td>\n",
+       "      <td>0.954012</td>\n",
+       "      <td>[[339, 0], [27, 238]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>0.929966</td>\n",
+       "      <td>0.933762</td>\n",
+       "      <td>0.932119</td>\n",
+       "      <td>0.931420</td>\n",
+       "      <td>[[312, 27], [14, 251]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>0.947230</td>\n",
+       "      <td>0.924528</td>\n",
+       "      <td>0.933775</td>\n",
+       "      <td>0.931329</td>\n",
+       "      <td>[[339, 0], [40, 225]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>7_layers_with_dropout</td>\n",
+       "      <td>0.935873</td>\n",
+       "      <td>0.924462</td>\n",
+       "      <td>0.930464</td>\n",
+       "      <td>0.928583</td>\n",
+       "      <td>[[330, 9], [33, 232]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>3_layers</td>\n",
+       "      <td>0.939165</td>\n",
+       "      <td>0.920515</td>\n",
+       "      <td>0.928808</td>\n",
+       "      <td>0.926411</td>\n",
+       "      <td>[[335, 4], [39, 226]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>0.792694</td>\n",
+       "      <td>0.737775</td>\n",
+       "      <td>0.761589</td>\n",
+       "      <td>0.740550</td>\n",
+       "      <td>[[316, 23], [121, 144]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>0.712457</td>\n",
+       "      <td>0.715011</td>\n",
+       "      <td>0.715232</td>\n",
+       "      <td>0.712937</td>\n",
+       "      <td>[[243, 96], [76, 189]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>0.684255</td>\n",
+       "      <td>0.650782</td>\n",
+       "      <td>0.675497</td>\n",
+       "      <td>0.647579</td>\n",
+       "      <td>[[289, 50], [146, 119]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>0.797368</td>\n",
+       "      <td>0.564151</td>\n",
+       "      <td>0.617550</td>\n",
+       "      <td>0.486650</td>\n",
+       "      <td>[[339, 0], [231, 34]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                    Model  Precision Score  Recall Score  Accuracy Score  \\\n",
+       "0                     KNN         0.975401      0.968336        0.971854   \n",
+       "1                7_layers         0.972145      0.962264        0.966887   \n",
+       "2                5_layers         0.963115      0.949057        0.955298   \n",
+       "3                     SVC         0.929966      0.933762        0.932119   \n",
+       "4                      RF         0.947230      0.924528        0.933775   \n",
+       "5   7_layers_with_dropout         0.935873      0.924462        0.930464   \n",
+       "6                3_layers         0.939165      0.920515        0.928808   \n",
+       "7                      LR         0.792694      0.737775        0.761589   \n",
+       "8                    SGDC         0.712457      0.715011        0.715232   \n",
+       "9                     DTC         0.684255      0.650782        0.675497   \n",
+       "10                     NB         0.797368      0.564151        0.617550   \n",
+       "\n",
+       "    F1 Score         Confusion Matrix  \n",
+       "0   0.971230    [[338, 1], [16, 249]]  \n",
+       "1   0.966066    [[339, 0], [20, 245]]  \n",
+       "2   0.954012    [[339, 0], [27, 238]]  \n",
+       "3   0.931420   [[312, 27], [14, 251]]  \n",
+       "4   0.931329    [[339, 0], [40, 225]]  \n",
+       "5   0.928583    [[330, 9], [33, 232]]  \n",
+       "6   0.926411    [[335, 4], [39, 226]]  \n",
+       "7   0.740550  [[316, 23], [121, 144]]  \n",
+       "8   0.712937   [[243, 96], [76, 189]]  \n",
+       "9   0.647579  [[289, 50], [146, 119]]  \n",
+       "10  0.486650    [[339, 0], [231, 34]]  "
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eval_df = pd.concat([sklearn_eval, dp_eval])\n",
+    "eval_df = eval_df.sort_values(by=['F1 Score'], ascending=False).reset_index(drop=True)\n",
+    "eval_df.to_csv(f\"evaluation.csv\", sep=',', encoding='utf-8', index=False)\n",
+    "eval_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Best model - ROC - Confusion Matrix\n",
+    "\n",
+    "As we can see from the evaluation, the best model according to the F1 Score is the KNN model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0.95480226, 0.996     ]),\n",
+       " array([0.99705015, 0.93962264]),\n",
+       " array([0.97546898, 0.96699029]))"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "best_model = sklearn_models[\"KNN\"]\n",
+    "y_predictions = best_model.predict(test_x)\n",
+    "\n",
+    "p_score = precision_score(test_y, y_predictions, labels=[0, 1], average=None)\n",
+    "r_score = recall_score(test_y, y_predictions, labels=[0, 1], average=None)\n",
+    "f1_score_result = f1_score(test_y, y_predictions, labels=[0, 1], average=None)\n",
+    "\n",
+    "p_score, r_score, f1_score_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.971"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(0.975 + 0.967) / 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Confusion Matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "KNN_cm = eval_df[ eval_df[\"Model\"] == 'KNN' ][\"Confusion Matrix\"].values[0]\n",
+    "\n",
+    "cm_array_df = pd.DataFrame(KNN_cm, index=[\"C\", \"L\"], columns=[\"C\", \"L\"])\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8,4)) \n",
+    "sns.heatmap(cm_array_df, linewidths=1, annot=True, ax=ax, fmt='g')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3. F1 Score and Confidence correlation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def to_labels(y_pred, y_pred_proba, threshold):\n",
+    "    '''Return prediction taking confidence threshold into account'''\n",
+    "    results = []\n",
+    "\n",
+    "    for index, predicted_class in enumerate(y_pred):\n",
+    "        prediction_probabilities = y_pred_proba[index]\n",
+    "        class_prediction_probability = round(prediction_probabilities[np.argmax(prediction_probabilities)], 2)\n",
+    "\n",
+    "        results.append(predicted_class if class_prediction_probability >= threshold else -1)\n",
+    "    \n",
+    "    return results\n",
+    "\n",
+    "\n",
+    "def calculate_correlation_score_confidence(test_x, test_y):\n",
+    "    '''Calculate correlation between Precision score/Recall score/F1 score and confidence threshold'''\n",
+    "    y_predictions = best_model.predict(test_x)\n",
+    "    y_predict_proba = best_model.predict_proba(test_x)\n",
+    "\n",
+    "    thresholds = list(np.arange(0, 1.01, 0.01))\n",
+    "\n",
+    "    f1_score_results = []\n",
+    "\n",
+    "    for threshold in thresholds:\n",
+    "        true_predictions = to_labels(y_predictions, y_predict_proba, threshold)\n",
+    "        f1_s = list(f1_score(test_y, true_predictions, labels=[0, 1], average=None))\n",
+    "        all_class_f1 = f1_score(test_y, true_predictions, labels=[0, 1, 2], average=\"weighted\")\n",
+    "        f1_s.append(all_class_f1)\n",
+    "        f1_score_results.append(f1_s)\n",
+    "    \n",
+    "    return thresholds, f1_score_results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "thresholds, f1_scores = calculate_correlation_score_confidence(test_x, test_y)\n",
+    "\n",
+    "first_class = [ el[0] for el in f1_scores ]\n",
+    "second_class = [ el[1] for el in f1_scores ]\n",
+    "all_classes = [ el[2] for el in f1_scores ]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8,6))\n",
+    "plt.plot(thresholds, first_class, label = \"F1 Score - Correct class\")\n",
+    "plt.plot(thresholds, second_class, label = \"F1 Score - Incorrect class\")\n",
+    "plt.plot(thresholds, all_classes, label = \"F1 Score - All classes\", linewidth=2.0, color=\"blue\")\n",
+    "plt.legend(loc = 'lower left')\n",
+    "plt.ylim([0.8, 1])\n",
+    "plt.xlim([0.025, 1])\n",
+    "plt.xlabel(\"Threshold\", fontsize = 12)\n",
+    "plt.ylabel(\"Score\", fontsize = 12)\n",
+    "# plt.axvline(thresholds[np.argmin(abs(precision-recall))], color=\"k\", ls = \"--\")\n",
+    "# plt.title(label = F\"Threshold = {thresholds[np.argmin(abs(precision-recall))]:.3f}\", fontsize = 12)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. ROC curve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimal Threshold: 0.6\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# calculate the fpr and tpr for all thresholds of the classification\n",
+    "probs = best_model.predict_proba(test_x)\n",
+    "preds = probs[:,1]\n",
+    "fpr, tpr, threshold = roc_curve(test_y, preds)\n",
+    "roc_auc = auc(fpr, tpr)\n",
+    "\n",
+    "optimal_idx = np.argmax(tpr - fpr)\n",
+    "optimal_threshold = threshold[optimal_idx]\n",
+    "print(f\"Optimal Threshold: {optimal_threshold}\")\n",
+    "\n",
+    "# method I: plt\n",
+    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
+    "plt.plot([0, 1], [0, 1],'r--', label=\"Random Classifier\")\n",
+    "plt.legend(loc=4)\n",
+    "plt.ylabel('True Positive Rate')\n",
+    "plt.xlabel('False Positive Rate')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.13 (conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "9260f401923fb5c4108c543a7d176de9733d378b3752e49535ad7c43c2271b65"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}