Upload 167 files

.gitattributes

@@ -33,3 +33,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+core/bicep_model/train.csv filter=lfs diff=lfs merge=lfs -text
+core/lunge_model/err.train.csv filter=lfs diff=lfs merge=lfs -text
+core/lunge_model/stage.train.csv filter=lfs diff=lfs merge=lfs -text
+core/plank_model/train.csv filter=lfs diff=lfs merge=lfs -text
+demo/bc_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+demo/lunge_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+demo/plank_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+demo/squat_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+docs/B1809677-Ngô[[:space:]]Hồng[[:space:]]Quốc[[:space:]]Bảo-Wrong[[:space:]]Pose[[:space:]]Dectection[[:space:]]based[[:space:]]on[[:space:]]Machine[[:space:]]Learning.docx filter=lfs diff=lfs merge=lfs -text
+docs/B1809677-Ngô[[:space:]]Hồng[[:space:]]Quốc[[:space:]]Bảo-Wrong[[:space:]]Pose[[:space:]]Dectection[[:space:]]based[[:space:]]on[[:space:]]Machine[[:space:]]Learning.pdf filter=lfs diff=lfs merge=lfs -text
+images/bicep_curl.gif filter=lfs diff=lfs merge=lfs -text
+images/lunge.gif filter=lfs diff=lfs merge=lfs -text
+images/plank.gif filter=lfs diff=lfs merge=lfs -text
+images/squat.gif filter=lfs diff=lfs merge=lfs -text
+images/web_3.png filter=lfs diff=lfs merge=lfs -text
+images/web_4.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,52 @@
+# Files
+.DS_Store
+
+# Machine Learning Folders
+.ipynb_checkpoints/
+env/
+data/
+
+# Editor directories and files
+.vscode
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Vue clients
+package-lock.json
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Keras Tuner
+**/keras_tuner_dir
+
+# Django server
+__pycache__/
+db.sqlite3
+temp/
+
+# References
+github/
+web/*/static/media/
+web/*/static/images/
+web/*/static/assets/
+web/*/static/css/
+*.env

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.8
+
+# Install Node.js and npm
+RUN apt-get update && apt-get install -y curl && \
+    curl -sL https://deb.nodesource.com/setup_16.x | bash - && \
+    apt-get install -y nodejs \
+    npm
+
+RUN apt-get update && apt-get install -y rsync
+RUN apt-get update && apt-get install ffmpeg libsm6 libxext6  -y
+
+RUN export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# copy /web folder and install client's dependencies
+COPY ./web /app
+WORKDIR /app
+RUN npm run install:client
+RUN npm run build-deploy:client
+
+# Expose port 8000 for the Django server
+EXPOSE 8000
+
+# Start the server
+CMD ["python", "server/manage.py", "runserver", "0.0.0.0:8000"]
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ngô Hồng Quốc Bảo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,168 @@
----
-title: Yoga
-emoji: 📉
-colorFrom: yellow
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div id="top"></div>
+
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+    <a href="https://github.com/NgoQuocBao1010/Exercise-Correction">
+        <img src="./images/logo.png" alt="Logo" width="60%">
+    </a>
+
+  <h2 align="center">Exercise Pose Correction</h2>
+
+  <p align="center">
+    Make use of the power of Mediapipe’s pose detection, this project is built in order to analyze, detect and classifying the forms of fitness exercises.
+  </p>
+</div>
+
+<!-- ABOUT THE PROJECT -->
+
+## About The Project
+
+This project goal is to develop 4 machine learning models for 4 of the most home exercises **(Bicep Curl, Plank, Squat and Lunge)** which each model can detect any form of incorrect movement while a person is performing a correspond exercise. In addition, a web application that utilize the trained models, will be built in other to analyze and provide feedbacks on workout videos.
+
+Here are some detections of the exercises:
+
+-   Bicep Curl
+<p align="center"><img src="images/bicep_curl.gif" alt="Logo" width="70%"></p>
+
+-   Basic Plank
+<p align="center"><img src="images/plank.gif" alt="Logo" width="70%"></p>
+
+-   Basic Squat
+<p align="center"><img src="images/squat.gif" alt="Logo" width="70%"></p>
+
+-   Lunge
+<p align="center"><img src="images/lunge.gif" alt="Logo" width="70%"></p>
+
+-   Models' evaluation results and website screenshots [here](#usage)
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+### Built With
+
+1. For data processing and model training
+
+    - [Numpy](https://numpy.org/)
+    - [Pandas](https://pandas.pydata.org/)
+    - [Sklearn](https://scikit-learn.org/stable/)
+    - [Keras](https://keras.io/)
+
+1. For building website
+
+    - [Vue.js v3](https://vuejs.org/)
+    - [Django](https://www.djangoproject.com/)
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+## Dataset
+
+Due to the lack of videos or dataset online that recorded human doing exercises both in a proper or improper way, the majority of self-collected videos were either recorded by myself, my friends or my family. The majority of the collected videos were removed due to privacy purpose.
+
+With an exercise such as Plank, as there is not much movement during the exercise, I’m able to find a dataset from an open database from [Kaggle](https://www.kaggle.com/datasets/niharika41298/yoga-poses-dataset). The found dataset is about many yoga poses but the very well-known ones are the downward dog pose, goddess pose, tree pose, plank pose and the warrior pose. The dataset contains 5 folders for 5 poses, each folder contains images of people correctly doing the correspond pose.
+
+For the purpose of this thesis, only the folder contains the images of people properly doing plank is chosen. There are 266 image files in that folder, I handpicked all the images that represent a basic plank and discard the reset. In conclusion, there are 30 images which are arranged to the proper form class for basic plank.
+
+## Getting Started
+
+This is an example of how you may give instructions on setting up the project locally.
+
+#### Setting Up Environment
+
+```
+    Python 3.8.13
+    Node 17.8.0
+    NPM 8.5.5
+    OS: Linux or MacOS
+```
+
+```markdown
+    NOTES
+    ⚠️ Commands/Scripts for this project are wrote for Linux-based OS. They may not work on Windows machines.
+```
+
+### Installation
+
+_If you only want to try the website, look [here](./web/README.md)._
+
+1. Clone the repo and change directory to that folder
+
+    ```sh
+    git clone https://github.com/NgoQuocBao1010/Exercise-Correction.git
+    ```
+
+1. Install all project dependencies
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+1. Folder **_[core](./core/README.md)_** is the code for data processing and model training.
+1. Folder **_[web](./web/README.md)_** is the code for website.
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+<!-- USAGE EXAMPLES -->
+<div id="Usage"></div>
+<br/>
+
+## Usage
+
+As the introduction indicated, there are 2 purposes for this project.
+
+1. Model training **(describe in depth [here](core/README.md))**. Below are the evaluation results for each models.
+
+    - [Bicep Curl](core/bicep_model/README.md) - _lean back error_: Confusion Matrix - ROC curve
+      | <img align="center" alt="Bicep Curl evaluation" src="images/bicep_curl_eval.png" /> | <img align="center" alt="NgoQuocBao's Top Languages" src="images/bicep_curl_eval_2.png" /> |
+      | ------------- | ------------- |
+    - [Plank](core/plank_model/README.md) - _all errors_: Confusion Matrix - ROC curve
+      | <img align="center" alt="Plank evaluation" src="images/plank_eval.png" /> | <img align="center" alt="NgoQuocBao's Top Languages" src="images/plank_eval_2.png" /> |
+      | ------------- | ------------- |
+    - [Basic Squat](core/squat_model/README.md) - _stage_: Confusion Matrix - ROC curve
+      | <img align="center" alt="Squat evaluation" src="images/squat_eval.png" /> | <img align="center" alt="NgoQuocBao's Top Languages" src="images/squat_eval_2.png" /> |
+      | ------------- | ------------- |
+    - [Lunge](core/lunge_model/README.md) - _knee over toe error_: Confusion Matrix - ROC curve
+      | <img align="center" alt="Lunge evaluation" src="images/lunge_eval.png" /> | <img align="center" alt="NgoQuocBao's Top Languages" src="images/lunge_eval_2.png" /> |
+      | ------------- | ------------- |
+
+1. Website for exercise detection. This web is for demonstration purpose of all the trained models, therefore, at the moment there are only 1 main features: Analyzing and giving feedbacks on user's exercise video.
+ <p align="center"><img src="images/web_1.png" alt="Logo" width="70%"></p>
+ <p align="center"><img src="images/web_2.png" alt="Logo" width="70%"></p>
+ <p align="center"><img src="images/web_3.png" alt="Logo" width="70%"></p>
+ <p align="center"><img src="images/web_4.png" alt="Logo" width="70%"></p>
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+<!-- CONTRIBUTING -->
+
+## Contributing
+
+Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
+Don't forget to give the project a star! Thanks again!
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+<!-- LICENSE -->
+
+## License
+
+Distributed under the MIT License.
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+<!-- ACKNOWLEDGMENTS -->
+
+## Acknowledgments
+
+-   Here are some other projects which I get inspired from: [Pose Trainer](https://github.com/stevenzchen/pose-trainer), [Deep Learning Fitness Exercise Correction Keras](https://github.com/Vollkorn01/Deep-Learning-Fitness-Exercise-Correction-Keras) and [Posture](https://github.com/twixupmysleeve/Posture).
+-   [Logo marker](https://www4.flamingtext.com/) for this project.
+-   This awesome README template is from [Best README Template](https://github.com/othneildrew/Best-README-Template). ♥
+
+<p align="right">(<a href="#top">back to top</a>)</p>

core/README.md

@@ -0,0 +1,58 @@
+<h2 align="center">Build Machine Learning Model</h2>
+
+Brief overview about the methodology of building models for exercise pose detection.
+To go in depth on each exercise, click the link below:
+
+-   [Bicep Curl](./bicep_model/README.md)
+-   [Plank](./plank_model/README.md)
+-   [Basic Squat](./squat_model/README.md)
+-   [Lunge](./lunge_model/README.md)
+
+### 1. Simple error detection
+
+For some simple errors (for example, the feet placement error in squat), the detection method is either measuring the distance/angle between different joints during the exercise with the coordinate outputs from MediaPipe Pose.
+
+-   **_Distance Calculation_**
+    Assume there are 2 points with the following coordinates: Point 1 (x1,y1) and Point 2 (x2,y2), below is the formula to calculate the distance between 2 points.
+
+    ```
+    distance= √((x1-x2)^2 +(y1-y2) ^2 )
+    ```
+
+-   **_Angle Calculation_**
+    Assume there are 3 points with the following coordinates: Point 1 (x1,y1), Point 2 (x2,y2) and Point 3 (x3,y3), below is the formula to calculate the angle created by 3 points.
+    ```
+    angle_in_radian =arctan2⁡(y3-y2,x3-x2) -arctan2(y1-y2,x1-x2)
+    angle_in_degree=(angle_in_rad \* 180)/Π
+    ```
+
+### 2. Model Training for Error Detection
+
+#### 1. Pick important landmarks
+
+For each exercise, there will be different poses/body’s position, therefore it is essential to identify which parts (shoulder, hip, …) of a body are contribute to the exercise. The important landmarks identified for each exercise are utilized to extract body part’s position while exercising using MediaPipe.
+
+#### 2. Data Processing
+
+ <p align="center"><img src="../images/data_processing.png" alt="Logo" width="70%" style="background-color:#f5f5f5"></p>
+
+#### 3. Model training
+
+There are 2 methods used in this thesis for model training. For each exercise, the models trained for each method will be compared and the best model will be chosen.
+
+-   Classification with Scikit-learn. (Decision Tree/Random Forest (RF), K-Nearest Neighbors (KNN), C-Support Vector (SVC), Logistic Regression classifier (LR) and Stochastic Gradient Descent classifier (SGDC)).
+-   Building a Neural Network for classification with Keras.
+
+### 3. Evaluation results of all models
+
+1. Bicep Curl - _lean back error_
+ <p align="center"><img src="../images/bicep_curl_eval_3.png" alt="Logo" width="70%"></p>
+
+2. Plank - _all errors_
+ <p align="center"><img src="../images/plank_eval_3.png" alt="Logo" width="70%"></p>
+
+3. Basic Squat - _stage_
+ <p align="center"><img src="../images/squat_eval_3.png" alt="Logo" width="70%"></p>
+
+4. Lunge - _knee over toe error_
+ <p align="center"><img src="../images/lunge_eval_3.png" alt="Logo" width="70%"></p>

core/bicep_model/1.data.ipynb

@@ -0,0 +1,510 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[67754]: 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 (0x10a8c8860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x161476480). One of the two will be used. Which one is undefined.\n",
+      "objc[67754]: 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 (0x10567ca68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x1614764d0). One of the two will be used. Which one is undefined.\n",
+      "objc[67754]: 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 (0x10567ca90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x1614764f8). One of the two will be used. Which one is undefined.\n",
+      "objc[67754]: 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 (0x10567cab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x161476520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import os, csv\n",
+    "import seaborn as sns\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. Describe the data gathering process and build dataset from Video\n",
+    "\n",
+    "The purpose is to gather data to determine the correct standing posture for Bicep Curl exercise\n",
+    "There are 2 stages:\n",
+    "- Correct: \"C\"\n",
+    "- Lean-back-error: \"L\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for plank\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"RIGHT_ELBOW\",\n",
+    "    \"LEFT_ELBOW\",\n",
+    "    \"RIGHT_WRIST\",\n",
+    "    \"LEFT_WRIST\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.2. Set up important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "    \n",
+    "\n",
+    "def init_csv(dataset_path: str):\n",
+    "    '''\n",
+    "    Create a blank csv file with just columns\n",
+    "    '''\n",
+    "\n",
+    "    # Ignore if file is already exist\n",
+    "    if os.path.exists(dataset_path):\n",
+    "        return\n",
+    "\n",
+    "    # Write all the columns to a empty file\n",
+    "    with open(dataset_path, mode=\"w\", newline=\"\") as f:\n",
+    "        csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "        csv_writer.writerow(HEADERS)\n",
+    "\n",
+    "\n",
+    "def export_landmark_to_csv(dataset_path: str, results, action: str) -> None:\n",
+    "    '''\n",
+    "    Export Labeled Data from detected landmark to csv\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "    keypoints = []\n",
+    "\n",
+    "    try:\n",
+    "        # Extract coordinate of important landmarks\n",
+    "        for lm in IMPORTANT_LMS:\n",
+    "            keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "            keypoints.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "        \n",
+    "        keypoints = list(np.array(keypoints).flatten())\n",
+    "\n",
+    "        # Insert action as the label (first column)\n",
+    "        keypoints.insert(0, action)\n",
+    "\n",
+    "        # Append new row to .csv file\n",
+    "        with open(dataset_path, mode=\"a\", newline=\"\") as f:\n",
+    "            csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "            csv_writer.writerow(keypoints)\n",
+    "        \n",
+    "\n",
+    "    except Exception as e:\n",
+    "        print(e)\n",
+    "        pass\n",
+    "\n",
+    "\n",
+    "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 remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_train.csv\", sep=',', encoding='utf-8', index=False)\n",
+    "    \n",
+    "\n",
+    "def concat_csv_files_with_same_headers(file_paths: list, saved_path: str):\n",
+    "    '''\n",
+    "    Concat different csv files\n",
+    "    '''\n",
+    "    all_df = []\n",
+    "    for path in file_paths:\n",
+    "        df = pd.read_csv(path, index_col=None, header=0)\n",
+    "        all_df.append(df)\n",
+    "    \n",
+    "    results = pd.concat(all_df, axis=0, ignore_index=True)\n",
+    "    results.to_csv(saved_path, sep=',', encoding='utf-8', index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Extract data from video"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "DATASET_PATH = \"train.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/db_curl/stand_posture_11.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "# init_csv(DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"Cannot detect pose - No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(1) & 0xFF\n",
+    "\n",
+    "        # Press C to save as correct form\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as low back\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# csv_files = [os.path.join(\"./\", f) for f in os.listdir(\"./\") if \"csv\" in f]\n",
+    "\n",
+    "# concat_csv_files_with_same_headers(csv_files, \"train.csv\")\n",
+    "\n",
+    "df = describe_dataset(\"./train.csv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Clean Data and Visualize data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "remove_duplicate_rows(\"./train.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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: 15372 \n",
+      "Number of columns: 37\n",
+      "\n",
+      "Labels: \n",
+      "C    8238\n",
+      "L    7134\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='label', ylabel='count'>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df = describe_dataset(\"./train.csv\")\n",
+    "sns.countplot(x='label', data=df, palette=\"Set1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. Gather Test Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TEST_DATASET_PATH = \"test.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/db_curl/bc_test_2.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "init_csv(TEST_DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"Cannot detect pose - No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(10) & 0xFF\n",
+    "\n",
+    "        # Press C to save as correct form\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as low back\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='count', ylabel='label'>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(TEST_DATASET_PATH)\n",
+    "sns.countplot(y='label', data=test_df, palette=\"Set1\")"
+   ]
+  },
+  {
+   "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
+}

core/bicep_model/2.sklearn.ipynb

@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[49355]: 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 (0x108688860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x160ece480). One of the two will be used. Which one is undefined.\n",
+      "objc[49355]: 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 (0x103440a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x160ece4d0). One of the two will be used. Which one is undefined.\n",
+      "objc[49355]: 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 (0x103440a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x160ece4f8). One of the two will be used. Which one is undefined.\n",
+      "objc[49355]: 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 (0x103440ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x160ece520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score, confusion_matrix\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.calibration import CalibratedClassifierCV\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. Train model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.1. Describe data and split dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "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": "code",
+   "execution_count": 3,
+   "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: 15372 \n",
+      "Number of columns: 37\n",
+      "\n",
+      "Labels: \n",
+      "C    8238\n",
+      "L    7134\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "df = describe_dataset(\"./train.csv\")\n",
+    "\n",
+    "# Categorizing label\n",
+    "df.loc[df[\"label\"] == \"C\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"L\", \"label\"] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sc = StandardScaler()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    sc = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "x = df.drop(\"label\", axis = 1)\n",
+    "x = pd.DataFrame(sc.transform(x))\n",
+    "\n",
+    "y = df[\"label\"].astype('int')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9465     1\n",
+       "8833     0\n",
+       "6190     0\n",
+       "7645     0\n",
+       "13890    1\n",
+       "        ..\n",
+       "11468    1\n",
+       "7221     1\n",
+       "1318     1\n",
+       "8915     1\n",
+       "11055    1\n",
+       "Name: label, Length: 12297, dtype: int64"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n",
+    "y_train"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.2. Train model using Scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "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>Accuracy score</th>\n",
+       "      <th>Recall 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>RF</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>0.999024</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>[[1677, 2], [1, 1395]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>[0.997, 0.999]</td>\n",
+       "      <td>0.998049</td>\n",
+       "      <td>[0.999, 0.996]</td>\n",
+       "      <td>[0.998, 0.998]</td>\n",
+       "      <td>[[1678, 1], [5, 1391]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>[0.997, 0.995]</td>\n",
+       "      <td>0.996098</td>\n",
+       "      <td>[0.996, 0.996]</td>\n",
+       "      <td>[0.996, 0.996]</td>\n",
+       "      <td>[[1672, 7], [5, 1391]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>[0.997, 0.991]</td>\n",
+       "      <td>0.994146</td>\n",
+       "      <td>[0.992, 0.996]</td>\n",
+       "      <td>[0.995, 0.994]</td>\n",
+       "      <td>[[1666, 13], [5, 1391]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>[0.987, 0.974]</td>\n",
+       "      <td>0.981463</td>\n",
+       "      <td>[0.979, 0.985]</td>\n",
+       "      <td>[0.983, 0.98]</td>\n",
+       "      <td>[[1643, 36], [21, 1375]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>[0.986, 0.975]</td>\n",
+       "      <td>0.980813</td>\n",
+       "      <td>[0.979, 0.983]</td>\n",
+       "      <td>[0.982, 0.979]</td>\n",
+       "      <td>[[1644, 35], [24, 1372]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>[0.927, 0.842]</td>\n",
+       "      <td>0.884878</td>\n",
+       "      <td>[0.857, 0.918]</td>\n",
+       "      <td>[0.89, 0.879]</td>\n",
+       "      <td>[[1439, 240], [114, 1282]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model Precision Score  Accuracy score    Recall Score        F1 score  \\\n",
+       "0    RF  [0.999, 0.999]        0.999024  [0.999, 0.999]  [0.999, 0.999]   \n",
+       "1   KNN  [0.997, 0.999]        0.998049  [0.999, 0.996]  [0.998, 0.998]   \n",
+       "2   SVC  [0.997, 0.995]        0.996098  [0.996, 0.996]  [0.996, 0.996]   \n",
+       "3   DTC  [0.997, 0.991]        0.994146  [0.992, 0.996]  [0.995, 0.994]   \n",
+       "4  SGDC  [0.987, 0.974]        0.981463  [0.979, 0.985]   [0.983, 0.98]   \n",
+       "5    LR  [0.986, 0.975]        0.980813  [0.979, 0.983]  [0.982, 0.979]   \n",
+       "6    NB  [0.927, 0.842]        0.884878  [0.857, 0.918]   [0.89, 0.879]   \n",
+       "\n",
+       "             Confusion Matrix  \n",
+       "0      [[1677, 2], [1, 1395]]  \n",
+       "1      [[1678, 1], [5, 1391]]  \n",
+       "2      [[1672, 7], [5, 1391]]  \n",
+       "3     [[1666, 13], [5, 1391]]  \n",
+       "4    [[1643, 36], [21, 1375]]  \n",
+       "5    [[1644, 35], [24, 1372]]  \n",
+       "6  [[1439, 240], [114, 1282]]  "
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "algorithms =[(\"LR\", LogisticRegression()),\n",
+    "         (\"SVC\", SVC(probability=True)),\n",
+    "         ('KNN',KNeighborsClassifier()),\n",
+    "         (\"DTC\", DecisionTreeClassifier()),\n",
+    "         (\"SGDC\", CalibratedClassifierCV(SGDClassifier())),\n",
+    "         (\"NB\", GaussianNB()),\n",
+    "         ('RF', RandomForestClassifier()),]\n",
+    "\n",
+    "models = {}\n",
+    "final_results = []\n",
+    "\n",
+    "for name, model in algorithms:\n",
+    "    trained_model = model.fit(X_train, y_train)\n",
+    "    models[name] = trained_model\n",
+    "\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(X_test)\n",
+    "\n",
+    "    p_score = precision_score(y_test, model_results, average=None, labels=[0, 1])\n",
+    "    a_score = accuracy_score(y_test, model_results)\n",
+    "    r_score = recall_score(y_test, model_results, average=None, labels=[0, 1])\n",
+    "    f1_score_result = f1_score(y_test, model_results, average=None, labels=[0, 1])\n",
+    "    cm = confusion_matrix(y_test, model_results, labels=[0, 1])\n",
+    "    final_results.append(( name,  round_up_metric_results(p_score), a_score, round_up_metric_results(r_score), round_up_metric_results(f1_score_result), cm))\n",
+    "\n",
+    "# Sort results by F1 score\n",
+    "final_results.sort(key=lambda k: sum(k[4]), reverse=True)\n",
+    "pd.DataFrame(final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.3. Dump models pickle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/all_sklearn.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models, f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(sc, f)"
+   ]
+  }
+ ],
+ "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
+}

core/bicep_model/3.deep_learning.ipynb

@@ -0,0 +1,1312 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data visualization\n",
+    "import numpy as np\n",
+    "import pandas as pd \n",
+    "\n",
+    "# Keras\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense\n",
+    "from keras.layers import Dropout\n",
+    "from keras.optimizers import Adam\n",
+    "from keras.utils.np_utils import to_categorical\n",
+    "from keras.callbacks import EarlyStopping, TensorBoard\n",
+    "import keras_tuner as kt\n",
+    "\n",
+    "# Train-Test\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "# Classification Report\n",
+    "from sklearn.metrics import confusion_matrix, precision_recall_fscore_support\n",
+    "\n",
+    "import pickle\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Important Landmarks and Important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for plank\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"RIGHT_ELBOW\",\n",
+    "    \"LEFT_ELBOW\",\n",
+    "    \"RIGHT_WRIST\",\n",
+    "    \"LEFT_WRIST\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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",
+    "# Remove duplicate rows (optional)\n",
+    "def remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_train.csv\", sep=',', encoding='utf-8', index=False)\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. Describe Dataset & Split Data"
+   ]
+  },
+  {
+   "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: 15372 \n",
+      "Number of columns: 37\n",
+      "\n",
+      "Labels: \n",
+      "C    8238\n",
+      "L    7134\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "df = describe_dataset(\"./train.csv\")\n",
+    "\n",
+    "# Categorizing label\n",
+    "df.loc[df[\"label\"] == \"C\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"L\", \"label\"] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    sc = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "x = df.drop(\"label\", axis = 1)\n",
+    "x = pd.DataFrame(sc.transform(x))\n",
+    "\n",
+    "y = df[\"label\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "y_cat = to_categorical(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(x.values, y_cat, test_size=0.2, random_state=1234)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Build Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Set up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stop_early = EarlyStopping(monitor='val_loss', patience=3)\n",
+    "\n",
+    "# Final Results\n",
+    "final_models = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def describe_model(model):\n",
+    "    '''\n",
+    "    Describe Model architecture\n",
+    "    '''\n",
+    "    print(f\"Describe models architecture\")\n",
+    "    for i, layer in enumerate(model.layers):\n",
+    "        number_of_units = layer.units if hasattr(layer, 'units') else 0\n",
+    "\n",
+    "        if hasattr(layer, \"activation\"):\n",
+    "            print(f\"Layer-{i + 1}: {number_of_units} units, func: \", layer.activation)\n",
+    "        else:\n",
+    "            print(f\"Layer-{i + 1}: {number_of_units} units, func: None\")\n",
+    "\n",
+    "\n",
+    "def get_best_model(tuner):\n",
+    "    '''\n",
+    "    Describe and return the best model found from keras tuner\n",
+    "    '''\n",
+    "    best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
+    "    best_model = tuner.hypermodel.build(best_hps)\n",
+    "\n",
+    "    describe_model(best_model)\n",
+    "\n",
+    "    print(\"\\nOther params:\")\n",
+    "    ignore_params = [\"tuner\", \"activation\", \"layer\", \"epoch\"]\n",
+    "    for param, value in best_hps.values.items():\n",
+    "        if not any(word in param for word in ignore_params):\n",
+    "            print(f\"{param}: {value}\")\n",
+    "\n",
+    "    return best_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. Model with 3 layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_3l_builder(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(36, input_dim = 36, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation = \"softmax\"))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 46s]\n",
+      "val_accuracy: 0.9980487823486328\n",
+      "\n",
+      "Best val_accuracy So Far: 0.9980487823486328\n",
+      "Total elapsed time: 00h 08m 25s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner_3l = kt.Hyperband(\n",
+    "    model_3l_builder,\n",
+    "    objective='val_accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo',\n",
+    ")\n",
+    "tuner_3l.search(x_train, y_train, validation_data=(x_test, y_test), epochs=10, callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-2: 448 units, func:  <function tanh at 0x16bf85ee0>\n",
+      "Layer-3: 2 units, func:  <function softmax at 0x16bf85160>\n",
+      "\n",
+      "Other params:\n",
+      "learning_rate: 0.001\n",
+      "Epoch 1/100\n",
+      "   5/1230 [..............................] - ETA: 19s - loss: 0.6247 - accuracy: 0.6600 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 09:54:28.588878: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - ETA: 0s - loss: 0.0504 - accuracy: 0.9848"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 09:54:39.929268: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - 14s 11ms/step - loss: 0.0504 - accuracy: 0.9848 - val_loss: 0.0889 - val_accuracy: 0.9717\n",
+      "Epoch 2/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0241 - accuracy: 0.9940 - val_loss: 0.0188 - val_accuracy: 0.9948\n",
+      "Epoch 3/100\n",
+      "1230/1230 [==============================] - 13s 10ms/step - loss: 0.0187 - accuracy: 0.9946 - val_loss: 0.0127 - val_accuracy: 0.9964\n",
+      "Epoch 4/100\n",
+      "1230/1230 [==============================] - 13s 10ms/step - loss: 0.0179 - accuracy: 0.9950 - val_loss: 0.0140 - val_accuracy: 0.9958\n",
+      "Epoch 5/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0145 - accuracy: 0.9958 - val_loss: 0.0211 - val_accuracy: 0.9958\n",
+      "Epoch 6/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0143 - accuracy: 0.9958 - val_loss: 0.0093 - val_accuracy: 0.9984\n",
+      "Epoch 7/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0118 - accuracy: 0.9966 - val_loss: 0.0077 - val_accuracy: 0.9984\n",
+      "Epoch 8/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0120 - accuracy: 0.9961 - val_loss: 0.0112 - val_accuracy: 0.9977\n",
+      "Epoch 9/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0121 - accuracy: 0.9959 - val_loss: 0.0073 - val_accuracy: 0.9984\n",
+      "Epoch 10/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0110 - accuracy: 0.9963 - val_loss: 0.0108 - val_accuracy: 0.9971\n",
+      "Epoch 11/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0097 - accuracy: 0.9970 - val_loss: 0.0110 - val_accuracy: 0.9971\n",
+      "Epoch 12/100\n",
+      "1230/1230 [==============================] - 13s 11ms/step - loss: 0.0098 - accuracy: 0.9972 - val_loss: 0.0107 - val_accuracy: 0.9967\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x296950eb0>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_3l = get_best_model(tuner_3l)\n",
+    "model_3l.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"3_layers\"] = model_3l"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3. Model with 5 layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_5l_builder(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(36, input_dim = 36, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation = \"softmax\"))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 54s]\n",
+      "val_accuracy: 0.9973983764648438\n",
+      "\n",
+      "Best val_accuracy So Far: 0.9986991882324219\n",
+      "Total elapsed time: 00h 11m 12s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner_5l = kt.Hyperband(\n",
+    "    model_5l_builder,\n",
+    "    objective='val_accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_2'\n",
+    ")\n",
+    "tuner_5l.search(x_train, y_train, validation_data=(x_test, y_test), epochs=10, callbacks=[stop_early, TensorBoard(\"./keras_tuner_dir/logs\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-2: 160 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-3: 352 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-4: 64 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-5: 2 units, func:  <function softmax at 0x16bf85160>\n",
+      "\n",
+      "Other params:\n",
+      "learning_rate: 0.001\n",
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 10:15:07.538823: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - ETA: 0s - loss: 0.0494 - accuracy: 0.9848"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 10:15:21.397335: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0494 - accuracy: 0.9848 - val_loss: 0.0152 - val_accuracy: 0.9958\n",
+      "Epoch 2/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0238 - accuracy: 0.9932 - val_loss: 0.0145 - val_accuracy: 0.9954\n",
+      "Epoch 3/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0193 - accuracy: 0.9947 - val_loss: 0.0146 - val_accuracy: 0.9971\n",
+      "Epoch 4/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0169 - accuracy: 0.9950 - val_loss: 0.0140 - val_accuracy: 0.9964\n",
+      "Epoch 5/100\n",
+      "1230/1230 [==============================] - 15s 13ms/step - loss: 0.0160 - accuracy: 0.9960 - val_loss: 0.0154 - val_accuracy: 0.9964\n",
+      "Epoch 6/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0135 - accuracy: 0.9963 - val_loss: 0.0126 - val_accuracy: 0.9961\n",
+      "Epoch 7/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0126 - accuracy: 0.9960 - val_loss: 0.0098 - val_accuracy: 0.9971\n",
+      "Epoch 8/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0106 - accuracy: 0.9966 - val_loss: 0.0090 - val_accuracy: 0.9971\n",
+      "Epoch 9/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0110 - accuracy: 0.9966 - val_loss: 0.0146 - val_accuracy: 0.9974\n",
+      "Epoch 10/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0098 - accuracy: 0.9963 - val_loss: 0.0257 - val_accuracy: 0.9922\n",
+      "Epoch 11/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0106 - accuracy: 0.9968 - val_loss: 0.0138 - val_accuracy: 0.9961\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x28a166fa0>"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_5l = get_best_model(tuner_5l)\n",
+    "model_5l.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"5_layers\"] = model_5l"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4. Model with 7 layers include Dropout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_7lD_builder(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(36, input_dim = 36, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_dropout_1 = hp.Float('dropout_1', min_value=0.1, max_value=0.5, step=0.1)\n",
+    "    hp_dropout_2 = hp.Float('dropout_2', min_value=0.1, max_value=0.5, step=0.1)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dropout(rate=hp_dropout_1))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dropout(rate=hp_dropout_2))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation = \"softmax\"))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 01m 04s]\n",
+      "accuracy: 0.9945515394210815\n",
+      "\n",
+      "Best accuracy So Far: 0.9969098567962646\n",
+      "Total elapsed time: 00h 12m 19s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner_7lD = kt.Hyperband(\n",
+    "    model_7lD_builder,\n",
+    "    objective='accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_3'\n",
+    ")\n",
+    "tuner_7lD.search(x_train, y_train, validation_data=(x_test, y_test), epochs=10, callbacks=[stop_early, TensorBoard(\"./keras_tuner_dir/logs\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-2: 320 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-3: 0 units, func: None\n",
+      "Layer-4: 96 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-5: 0 units, func: None\n",
+      "Layer-6: 448 units, func:  <function relu at 0x16bf85b80>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x16bf85160>\n",
+      "\n",
+      "Other params:\n",
+      "dropout_1: 0.30000000000000004\n",
+      "dropout_2: 0.30000000000000004\n",
+      "learning_rate: 0.001\n",
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 10:37:14.947724: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - ETA: 0s - loss: 0.0592 - accuracy: 0.9811"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 10:37:31.869492: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - 20s 16ms/step - loss: 0.0592 - accuracy: 0.9811 - val_loss: 0.0177 - val_accuracy: 0.9961\n",
+      "Epoch 2/100\n",
+      "1230/1230 [==============================] - 19s 16ms/step - loss: 0.0235 - accuracy: 0.9934 - val_loss: 0.0164 - val_accuracy: 0.9951\n",
+      "Epoch 3/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0206 - accuracy: 0.9945 - val_loss: 0.0150 - val_accuracy: 0.9945\n",
+      "Epoch 4/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0175 - accuracy: 0.9951 - val_loss: 0.0160 - val_accuracy: 0.9961\n",
+      "Epoch 5/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0176 - accuracy: 0.9950 - val_loss: 0.0131 - val_accuracy: 0.9964\n",
+      "Epoch 6/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0137 - accuracy: 0.9960 - val_loss: 0.0091 - val_accuracy: 0.9984\n",
+      "Epoch 7/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0141 - accuracy: 0.9959 - val_loss: 0.0121 - val_accuracy: 0.9958\n",
+      "Epoch 8/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0118 - accuracy: 0.9964 - val_loss: 0.0089 - val_accuracy: 0.9967\n",
+      "Epoch 9/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0097 - accuracy: 0.9969 - val_loss: 0.0155 - val_accuracy: 0.9974\n",
+      "Epoch 10/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0154 - accuracy: 0.9964 - val_loss: 0.0093 - val_accuracy: 0.9974\n",
+      "Epoch 11/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0118 - accuracy: 0.9970 - val_loss: 0.0073 - val_accuracy: 0.9987\n",
+      "Epoch 12/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0103 - accuracy: 0.9971 - val_loss: 0.0185 - val_accuracy: 0.9980\n",
+      "Epoch 13/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0112 - accuracy: 0.9971 - val_loss: 0.0105 - val_accuracy: 0.9977\n",
+      "Epoch 14/100\n",
+      "1230/1230 [==============================] - 19s 15ms/step - loss: 0.0132 - accuracy: 0.9965 - val_loss: 0.0183 - val_accuracy: 0.9964\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x28fcad400>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_7lD = get_best_model(tuner_7lD)\n",
+    "model_7lD.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"7_layers_with_dropout\"] = model_7lD"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.5. Model with 7 layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_7l_builder(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(36, input_dim = 36, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_4 = hp.Int('layer_4', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_5 = hp.Int('layer_5', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_4, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_5, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation = \"softmax\"))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 51s]\n",
+      "val_accuracy: 0.9973983764648438\n",
+      "\n",
+      "Best val_accuracy So Far: 0.9977235794067383\n",
+      "Total elapsed time: 00h 02m 22s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner_7l = kt.Hyperband(\n",
+    "    model_7l_builder,\n",
+    "    objective='val_accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_6'\n",
+    ")\n",
+    "tuner_7l.search(x_train, y_train, validation_data=(x_test, y_test), epochs=10, callbacks=[stop_early, TensorBoard(\"./keras_tuner_dir/logs\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x13a058b80>\n",
+      "Layer-2: 192 units, func:  <function tanh at 0x13a058ee0>\n",
+      "Layer-3: 320 units, func:  <function tanh at 0x13a058ee0>\n",
+      "Layer-4: 448 units, func:  <function tanh at 0x13a058ee0>\n",
+      "Layer-5: 224 units, func:  <function tanh at 0x13a058ee0>\n",
+      "Layer-6: 448 units, func:  <function tanh at 0x13a058ee0>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x13a058160>\n",
+      "\n",
+      "Other params:\n",
+      "learning_rate: 0.0001\n",
+      "Epoch 1/100\n",
+      "   1/1230 [..............................] - ETA: 8:04 - loss: 0.6561 - accuracy: 0.6000"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 14:29:10.795739: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - ETA: 0s - loss: 0.0720 - accuracy: 0.9748"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-23 14:29:24.355056: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0720 - accuracy: 0.9748 - val_loss: 0.0219 - val_accuracy: 0.9941\n",
+      "Epoch 2/100\n",
+      "1230/1230 [==============================] - 15s 12ms/step - loss: 0.0319 - accuracy: 0.9910 - val_loss: 0.0353 - val_accuracy: 0.9893\n",
+      "Epoch 3/100\n",
+      "1230/1230 [==============================] - 15s 12ms/step - loss: 0.0262 - accuracy: 0.9927 - val_loss: 0.0149 - val_accuracy: 0.9958\n",
+      "Epoch 4/100\n",
+      "1230/1230 [==============================] - 15s 12ms/step - loss: 0.0221 - accuracy: 0.9936 - val_loss: 0.0125 - val_accuracy: 0.9964\n",
+      "Epoch 5/100\n",
+      "1230/1230 [==============================] - 15s 12ms/step - loss: 0.0195 - accuracy: 0.9943 - val_loss: 0.0171 - val_accuracy: 0.9951\n",
+      "Epoch 6/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0186 - accuracy: 0.9942 - val_loss: 0.0128 - val_accuracy: 0.9971\n",
+      "Epoch 7/100\n",
+      "1230/1230 [==============================] - 16s 13ms/step - loss: 0.0170 - accuracy: 0.9951 - val_loss: 0.0132 - val_accuracy: 0.9974\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x15a0f17c0>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_7l = get_best_model(tuner_7l)\n",
+    "model_7l.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"7_layers\"] = model_7l"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.6. Describe final models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3_layers: Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-2: 448 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-3: 2 units, func:  <function softmax at 0x17fe29160>\n",
+      "\n",
+      "5_layers: Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-2: 160 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-3: 352 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-4: 64 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-5: 2 units, func:  <function softmax at 0x17fe29160>\n",
+      "\n",
+      "7_layers_with_dropout: Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-2: 320 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-3: 0 units, func: None\n",
+      "Layer-4: 96 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-5: 0 units, func: None\n",
+      "Layer-6: 448 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x17fe29160>\n",
+      "\n",
+      "7_layers: Describe models architecture\n",
+      "Layer-1: 36 units, func:  <function relu at 0x17fe29b80>\n",
+      "Layer-2: 192 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-3: 320 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-4: 448 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-5: 224 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-6: 448 units, func:  <function tanh at 0x17fe29ee0>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x17fe29160>\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for name, model in final_models.items():\n",
+    "    print(f\"{name}: \", end=\"\")\n",
+    "    describe_model(model)\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Model Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1. Train set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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>F1 score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>[0.998, 0.997]</td>\n",
+       "      <td>[0.998, 0.997]</td>\n",
+       "      <td>[0.998, 0.997]</td>\n",
+       "      <td>[[1675, 4], [4, 1392]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>3_layers</td>\n",
+       "      <td>[0.997, 0.996]</td>\n",
+       "      <td>[0.997, 0.996]</td>\n",
+       "      <td>[0.997, 0.996]</td>\n",
+       "      <td>[[1674, 5], [5, 1391]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7_layers_with_dropout</td>\n",
+       "      <td>[0.998, 0.995]</td>\n",
+       "      <td>[0.996, 0.997]</td>\n",
+       "      <td>[0.997, 0.996]</td>\n",
+       "      <td>[[1672, 7], [4, 1392]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>[0.996, 0.996]</td>\n",
+       "      <td>[0.996, 0.996]</td>\n",
+       "      <td>[0.996, 0.996]</td>\n",
+       "      <td>[[1673, 6], [6, 1390]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Model Precision Score    Recall Score        F1 score  \\\n",
+       "0               7_layers  [0.998, 0.997]  [0.998, 0.997]  [0.998, 0.997]   \n",
+       "1               3_layers  [0.997, 0.996]  [0.997, 0.996]  [0.997, 0.996]   \n",
+       "2  7_layers_with_dropout  [0.998, 0.995]  [0.996, 0.997]  [0.997, 0.996]   \n",
+       "3               5_layers  [0.996, 0.996]  [0.996, 0.996]  [0.996, 0.996]   \n",
+       "\n",
+       "         Confusion Matrix  \n",
+       "0  [[1675, 4], [4, 1392]]  \n",
+       "1  [[1674, 5], [5, 1391]]  \n",
+       "2  [[1672, 7], [4, 1392]]  \n",
+       "3  [[1673, 6], [6, 1390]]  "
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_set_results = []\n",
+    "\n",
+    "for name, model in final_models.items():\n",
+    "    # Evaluate model\n",
+    "    predict_x = model.predict(x_test, verbose=False) \n",
+    "    y_pred_class = np.argmax(predict_x, axis=1)\n",
+    "    y_test_class = np.argmax(y_test, axis=1)\n",
+    "\n",
+    "    cm = confusion_matrix(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    (p_score, r_score, f_score, _) = precision_recall_fscore_support(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    \n",
+    "    train_set_results.append(( name, round_up_metric_results(p_score), round_up_metric_results(r_score), round_up_metric_results(f_score), cm ))\n",
+    "\n",
+    "train_set_results.sort(key=lambda k: sum(k[3]), reverse=True)\n",
+    "pd.DataFrame(train_set_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2. Test set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 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\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "test_y_cat = to_categorical(test_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-25 15:34:28.174069: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:34:28.287586: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:34:28.423087: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:34:28.546100: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "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>F1 score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>[0.944, 1.0]</td>\n",
+       "      <td>[1.0, 0.925]</td>\n",
+       "      <td>[0.971, 0.961]</td>\n",
+       "      <td>[[339, 0], [20, 245]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>[0.926, 1.0]</td>\n",
+       "      <td>[1.0, 0.898]</td>\n",
+       "      <td>[0.962, 0.946]</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.909, 0.963]</td>\n",
+       "      <td>[0.973, 0.875]</td>\n",
+       "      <td>[0.94, 0.917]</td>\n",
+       "      <td>[[330, 9], [33, 232]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3_layers</td>\n",
+       "      <td>[0.896, 0.983]</td>\n",
+       "      <td>[0.988, 0.853]</td>\n",
+       "      <td>[0.94, 0.913]</td>\n",
+       "      <td>[[335, 4], [39, 226]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Model Precision Score    Recall Score        F1 score  \\\n",
+       "0               7_layers    [0.944, 1.0]    [1.0, 0.925]  [0.971, 0.961]   \n",
+       "1               5_layers    [0.926, 1.0]    [1.0, 0.898]  [0.962, 0.946]   \n",
+       "2  7_layers_with_dropout  [0.909, 0.963]  [0.973, 0.875]   [0.94, 0.917]   \n",
+       "3               3_layers  [0.896, 0.983]  [0.988, 0.853]   [0.94, 0.913]   \n",
+       "\n",
+       "        Confusion Matrix  \n",
+       "0  [[339, 0], [20, 245]]  \n",
+       "1  [[339, 0], [27, 238]]  \n",
+       "2  [[330, 9], [33, 232]]  \n",
+       "3  [[335, 4], [39, 226]]  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_set_results = []\n",
+    "\n",
+    "for name, model in final_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, r_score, f_score, _) = precision_recall_fscore_support(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    \n",
+    "    test_set_results.append(( name, round_up_metric_results(p_score), round_up_metric_results(r_score), round_up_metric_results(f_score), cm ))\n",
+    "\n",
+    "test_set_results.sort(key=lambda k: k[1] + k[2] + k[3], reverse=True)\n",
+    "pd.DataFrame(test_set_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Dumped Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: ram://4145d713-d810-484c-b518-b4ae694e4919/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Dump the best model to a pickle file\n",
+    "with open(\"./model/bicep_dp.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(final_models[\"7_layers\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: ram://5ccb0e7f-b3f8-4602-9b3c-2ae89d1a2d69/assets\n",
+      "INFO:tensorflow:Assets written to: ram://5d2d95b4-ff82-487d-bd98-ba859e8eced0/assets\n",
+      "INFO:tensorflow:Assets written to: ram://557449b4-6368-4822-a75f-79675a055ab9/assets\n",
+      "INFO:tensorflow:Assets written to: ram://4857368e-b747-43dd-9b2d-6e986317f4b8/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Dump final results\n",
+    "with open(\"./model/all_models.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(final_models, f)"
+   ]
+  },
+  {
+   "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
+}

core/bicep_model/5.detection.ipynb

@@ -0,0 +1,619 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import datetime\n",
+    "\n",
+    "import pickle\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 up important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for plank\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"RIGHT_ELBOW\",\n",
+    "    \"LEFT_ELBOW\",\n",
+    "    \"RIGHT_WRIST\",\n",
+    "    \"LEFT_WRIST\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame from OpenCV to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation =cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "def save_frame_as_image(frame, message: str = None):\n",
+    "    '''\n",
+    "    Save a frame as image to display the error\n",
+    "    '''\n",
+    "    now = datetime.datetime.now()\n",
+    "\n",
+    "    if message:\n",
+    "        cv2.putText(frame, message, (50, 150), cv2.FONT_HERSHEY_COMPLEX, 0.4, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "        \n",
+    "    print(\"Saving ...\")\n",
+    "    cv2.imwrite(f\"../data/logs/bicep_{now}.jpg\", frame)\n",
+    "\n",
+    "\n",
+    "def calculate_angle(point1: list, point2: list, point3: list) -> float:\n",
+    "    '''\n",
+    "    Calculate the angle between 3 points\n",
+    "    Unit of the angle will be in Degree\n",
+    "    '''\n",
+    "    point1 = np.array(point1)\n",
+    "    point2 = np.array(point2)\n",
+    "    point3 = np.array(point3)\n",
+    "\n",
+    "    # Calculate algo\n",
+    "    angleInRad = np.arctan2(point3[1] - point2[1], point3[0] - point2[0]) - np.arctan2(point1[1] - point2[1], point1[0] - point2[0])\n",
+    "    angleInDeg = np.abs(angleInRad * 180.0 / np.pi)\n",
+    "\n",
+    "    angleInDeg = angleInDeg if angleInDeg <= 180 else 360 - angleInDeg\n",
+    "    return angleInDeg\n",
+    "\n",
+    "\n",
+    "def extract_important_keypoints(results, important_landmarks: list) -> list:\n",
+    "    '''\n",
+    "    Extract important keypoints from mediapipe pose detection\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "\n",
+    "    data = []\n",
+    "    for lm in important_landmarks:\n",
+    "        keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "        data.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "    \n",
+    "    return np.array(data).flatten().tolist()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. OOP method for Analyze Pose of each arm\n",
+    "\n",
+    "To be easier to detect both arm at the same time, I choose to do the calculation for bicep counter and error detection with OOP.\n",
+    "\n",
+    "*Note: Every If any joints from an arm is appeared to be in poor visibility according to mediapipe, that arm will be skip*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class BicepPoseAnalysis:\n",
+    "    def __init__(self, side: str, stage_down_threshold: float, stage_up_threshold: float, peak_contraction_threshold: float, loose_upper_arm_angle_threshold: float, visibility_threshold: float):\n",
+    "        # Initialize thresholds\n",
+    "        self.stage_down_threshold = stage_down_threshold\n",
+    "        self.stage_up_threshold = stage_up_threshold\n",
+    "        self.peak_contraction_threshold = peak_contraction_threshold\n",
+    "        self.loose_upper_arm_angle_threshold = loose_upper_arm_angle_threshold\n",
+    "        self.visibility_threshold = visibility_threshold\n",
+    "\n",
+    "        self.side = side\n",
+    "        self.counter = 0\n",
+    "        self.stage = \"down\"\n",
+    "        self.is_visible = True\n",
+    "        self.detected_errors = {\n",
+    "            \"LOOSE_UPPER_ARM\": 0,\n",
+    "            \"PEAK_CONTRACTION\": 0,\n",
+    "        }\n",
+    "\n",
+    "        # Params for loose upper arm error detection\n",
+    "        self.loose_upper_arm = False\n",
+    "\n",
+    "        # Params for peak contraction error detection\n",
+    "        self.peak_contraction_angle = 1000\n",
+    "        self.peak_contraction_frame = None\n",
+    "    \n",
+    "    def get_joints(self, landmarks) -> bool:\n",
+    "        '''\n",
+    "        Check for joints' visibility then get joints coordinate\n",
+    "        '''\n",
+    "        side = self.side.upper()\n",
+    "\n",
+    "        # Check visibility\n",
+    "        joints_visibility = [ landmarks[mp_pose.PoseLandmark[f\"{side}_SHOULDER\"].value].visibility, landmarks[mp_pose.PoseLandmark[f\"{side}_ELBOW\"].value].visibility, landmarks[mp_pose.PoseLandmark[f\"{side}_WRIST\"].value].visibility ]\n",
+    "\n",
+    "        is_visible = all([ vis > self.visibility_threshold for vis in joints_visibility ])\n",
+    "        self.is_visible = is_visible\n",
+    "\n",
+    "        if not is_visible:\n",
+    "            return self.is_visible\n",
+    "        \n",
+    "        # Get joints' coordinates\n",
+    "        self.shoulder = [ landmarks[mp_pose.PoseLandmark[f\"{side}_SHOULDER\"].value].x, landmarks[mp_pose.PoseLandmark[f\"{side}_SHOULDER\"].value].y ]\n",
+    "        self.elbow = [ landmarks[mp_pose.PoseLandmark[f\"{side}_ELBOW\"].value].x, landmarks[mp_pose.PoseLandmark[f\"{side}_ELBOW\"].value].y ]\n",
+    "        self.wrist = [ landmarks[mp_pose.PoseLandmark[f\"{side}_WRIST\"].value].x, landmarks[mp_pose.PoseLandmark[f\"{side}_WRIST\"].value].y ]\n",
+    "\n",
+    "        return self.is_visible\n",
+    "    \n",
+    "    def analyze_pose(self, landmarks, frame):\n",
+    "        '''\n",
+    "        - Bicep Counter\n",
+    "        - Errors Detection\n",
+    "        '''\n",
+    "        self.get_joints(landmarks)\n",
+    "\n",
+    "        # Cancel calculation if visibility is poor\n",
+    "        if not self.is_visible:\n",
+    "            return (None, None)\n",
+    "\n",
+    "        # * Calculate curl angle for counter\n",
+    "        bicep_curl_angle = int(calculate_angle(self.shoulder, self.elbow, self.wrist))\n",
+    "        if bicep_curl_angle > self.stage_down_threshold:\n",
+    "            self.stage = \"down\"\n",
+    "        elif bicep_curl_angle < self.stage_up_threshold and self.stage == \"down\":\n",
+    "            self.stage = \"up\"\n",
+    "            self.counter += 1\n",
+    "        \n",
+    "        # * Calculate the angle between the upper arm (shoulder & joint) and the Y axis\n",
+    "        shoulder_projection = [ self.shoulder[0], 1 ] # Represent the projection of the shoulder to the X axis\n",
+    "        ground_upper_arm_angle = int(calculate_angle(self.elbow, self.shoulder, shoulder_projection))\n",
+    "\n",
+    "        # * Evaluation for LOOSE UPPER ARM error\n",
+    "        if ground_upper_arm_angle > self.loose_upper_arm_angle_threshold:\n",
+    "            # Limit the saved frame\n",
+    "            if not self.loose_upper_arm:\n",
+    "                self.loose_upper_arm = True\n",
+    "                # save_frame_as_image(frame, f\"Loose upper arm: {ground_upper_arm_angle}\")\n",
+    "                self.detected_errors[\"LOOSE_UPPER_ARM\"] += 1\n",
+    "        else:\n",
+    "            self.loose_upper_arm = False\n",
+    "        \n",
+    "        # * Evaluate PEAK CONTRACTION error\n",
+    "        if self.stage == \"up\" and bicep_curl_angle < self.peak_contraction_angle:\n",
+    "            # Save peaked contraction every rep\n",
+    "            self.peak_contraction_angle = bicep_curl_angle\n",
+    "            self.peak_contraction_frame = frame\n",
+    "            \n",
+    "        elif self.stage == \"down\":\n",
+    "            # * Evaluate if the peak is higher than the threshold if True, marked as an error then saved that frame\n",
+    "            if self.peak_contraction_angle != 1000 and self.peak_contraction_angle >= self.peak_contraction_threshold:\n",
+    "                # save_frame_as_image(self.peak_contraction_frame, f\"{self.side} - Peak Contraction: {self.peak_contraction_angle}\")\n",
+    "                self.detected_errors[\"PEAK_CONTRACTION\"] += 1\n",
+    "            \n",
+    "            # Reset params\n",
+    "            self.peak_contraction_angle = 1000\n",
+    "            self.peak_contraction_frame = None\n",
+    "        \n",
+    "        return (bicep_curl_angle, ground_upper_arm_angle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Bicep Detection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "VIDEO_PATH1 = \"../data/db_curl/bc_test_1.mp4\"\n",
+    "VIDEO_PATH2 = \"../data/db_curl/bc_test_2.mp4\"\n",
+    "VIDEO_PATH3 = \"../data/db_curl/bc_test_3.mp4\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load input scaler\n",
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    input_scaler = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.1. Detection with SKLearn model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "with open(\"./model/KNN_model.pkl\", \"rb\") as f:\n",
+    "    sklearn_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH3)\n",
+    "\n",
+    "VISIBILITY_THRESHOLD = 0.65\n",
+    "\n",
+    "# Params for counter\n",
+    "STAGE_UP_THRESHOLD = 90\n",
+    "STAGE_DOWN_THRESHOLD = 120\n",
+    "\n",
+    "# Params to catch FULL RANGE OF MOTION error\n",
+    "PEAK_CONTRACTION_THRESHOLD = 60\n",
+    "\n",
+    "# LOOSE UPPER ARM error detection\n",
+    "LOOSE_UPPER_ARM = False\n",
+    "LOOSE_UPPER_ARM_ANGLE_THRESHOLD = 40\n",
+    "\n",
+    "# STANDING POSTURE error detection\n",
+    "POSTURE_ERROR_THRESHOLD = 0.7\n",
+    "posture = \"C\"\n",
+    "\n",
+    "# Init analysis class\n",
+    "left_arm_analysis = BicepPoseAnalysis(side=\"left\", stage_down_threshold=STAGE_DOWN_THRESHOLD, stage_up_threshold=STAGE_UP_THRESHOLD, peak_contraction_threshold=PEAK_CONTRACTION_THRESHOLD, loose_upper_arm_angle_threshold=LOOSE_UPPER_ARM_ANGLE_THRESHOLD, visibility_threshold=VISIBILITY_THRESHOLD)\n",
+    "\n",
+    "right_arm_analysis = BicepPoseAnalysis(side=\"right\", stage_down_threshold=STAGE_DOWN_THRESHOLD, stage_up_threshold=STAGE_UP_THRESHOLD, peak_contraction_threshold=PEAK_CONTRACTION_THRESHOLD, loose_upper_arm_angle_threshold=LOOSE_UPPER_ARM_ANGLE_THRESHOLD, visibility_threshold=VISIBILITY_THRESHOLD)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.8, min_tracking_confidence=0.8) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        # image = cv2.flip(image, 1)\n",
+    "        \n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            landmarks = results.pose_landmarks.landmark\n",
+    "            \n",
+    "            (left_bicep_curl_angle, left_ground_upper_arm_angle) = left_arm_analysis.analyze_pose(landmarks=landmarks, frame=image)\n",
+    "            (right_bicep_curl_angle, right_ground_upper_arm_angle) = right_arm_analysis.analyze_pose(landmarks=landmarks, frame=image)\n",
+    "\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results, IMPORTANT_LMS)\n",
+    "            X = pd.DataFrame([row], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "\n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            predicted_class = sklearn_model.predict(X)[0]\n",
+    "            prediction_probabilities = sklearn_model.predict_proba(X)[0]\n",
+    "            class_prediction_probability = round(prediction_probabilities[np.argmax(prediction_probabilities)], 2)\n",
+    "\n",
+    "            if class_prediction_probability >= POSTURE_ERROR_THRESHOLD:\n",
+    "                posture = predicted_class\n",
+    "\n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (500, 40), (245, 117, 16), -1)\n",
+    "\n",
+    "            # Display probability\n",
+    "            cv2.putText(image, \"RIGHT\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.counter) if right_arm_analysis.is_visible else \"UNK\", (10, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display Left Counter\n",
+    "            cv2.putText(image, \"LEFT\", (95, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.counter) if left_arm_analysis.is_visible else \"UNK\", (100, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # * Display error\n",
+    "            # Right arm error\n",
+    "            cv2.putText(image, \"R_PC\", (165, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.detected_errors[\"PEAK_CONTRACTION\"]), (160, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "            cv2.putText(image, \"R_LUA\", (225, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.detected_errors[\"LOOSE_UPPER_ARM\"]), (220, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Left arm error\n",
+    "            cv2.putText(image, \"L_PC\", (300, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.detected_errors[\"PEAK_CONTRACTION\"]), (295, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "            cv2.putText(image, \"L_LUA\", (380, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.detected_errors[\"LOOSE_UPPER_ARM\"]), (375, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Lean back error\n",
+    "            cv2.putText(image, \"LB\", (460, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(f\"{posture}, {predicted_class}, {class_prediction_probability}\"), (440, 30), cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "\n",
+    "            # * Visualize angles\n",
+    "            # Visualize LEFT arm calculated angles\n",
+    "            if left_arm_analysis.is_visible:\n",
+    "                cv2.putText(image, str(left_bicep_curl_angle), tuple(np.multiply(left_arm_analysis.elbow, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "                cv2.putText(image, str(left_ground_upper_arm_angle), tuple(np.multiply(left_arm_analysis.shoulder, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "\n",
+    "            # Visualize RIGHT arm calculated angles\n",
+    "            if right_arm_analysis.is_visible:\n",
+    "                cv2.putText(image, str(right_bicep_curl_angle), tuple(np.multiply(right_arm_analysis.elbow, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 0), 1, cv2.LINE_AA)\n",
+    "                cv2.putText(image, str(right_ground_upper_arm_angle), tuple(np.multiply(right_arm_analysis.shoulder, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 0), 1, cv2.LINE_AA)\n",
+    "        \n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # if left_arm_analysis.loose_upper_arm:\n",
+    "        #     save_frame_as_image(image, \"\")\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.2. Detection with Deep Learning model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "with open(\"./model/bicep_model_deep_learning.pkl\", \"rb\") as f:\n",
+    "    DL_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH3)\n",
+    "\n",
+    "VISIBILITY_THRESHOLD = 0.65\n",
+    "\n",
+    "# Params for counter\n",
+    "STAGE_UP_THRESHOLD = 90\n",
+    "STAGE_DOWN_THRESHOLD = 120\n",
+    "\n",
+    "# Params to catch FULL RANGE OF MOTION error\n",
+    "PEAK_CONTRACTION_THRESHOLD = 60\n",
+    "\n",
+    "# LOOSE UPPER ARM error detection\n",
+    "LOOSE_UPPER_ARM = False\n",
+    "LOOSE_UPPER_ARM_ANGLE_THRESHOLD = 40\n",
+    "\n",
+    "# STANDING POSTURE error detection\n",
+    "POSTURE_ERROR_THRESHOLD = 0.95\n",
+    "posture = 0\n",
+    "\n",
+    "# Init analysis class\n",
+    "left_arm_analysis = BicepPoseAnalysis(side=\"left\", stage_down_threshold=STAGE_DOWN_THRESHOLD, stage_up_threshold=STAGE_UP_THRESHOLD, peak_contraction_threshold=PEAK_CONTRACTION_THRESHOLD, loose_upper_arm_angle_threshold=LOOSE_UPPER_ARM_ANGLE_THRESHOLD, visibility_threshold=VISIBILITY_THRESHOLD)\n",
+    "\n",
+    "right_arm_analysis = BicepPoseAnalysis(side=\"right\", stage_down_threshold=STAGE_DOWN_THRESHOLD, stage_up_threshold=STAGE_UP_THRESHOLD, peak_contraction_threshold=PEAK_CONTRACTION_THRESHOLD, loose_upper_arm_angle_threshold=LOOSE_UPPER_ARM_ANGLE_THRESHOLD, visibility_threshold=VISIBILITY_THRESHOLD)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        # image = cv2.flip(image, 1)\n",
+    "        \n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            landmarks = results.pose_landmarks.landmark\n",
+    "            \n",
+    "            (left_bicep_curl_angle, left_ground_upper_arm_angle) = left_arm_analysis.analyze_pose(landmarks=landmarks, frame=image)\n",
+    "            (right_bicep_curl_angle, right_ground_upper_arm_angle) = right_arm_analysis.analyze_pose(landmarks=landmarks, frame=image)\n",
+    "\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results, IMPORTANT_LMS)\n",
+    "            X = pd.DataFrame([row, ], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            prediction = DL_model.predict(X)\n",
+    "            predicted_class = np.argmax(prediction, axis=1)[0]\n",
+    "            prediction_probability = round(max(prediction.tolist()[0]), 2)\n",
+    "\n",
+    "            if prediction_probability >= POSTURE_ERROR_THRESHOLD:\n",
+    "                posture = predicted_class\n",
+    "\n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (500, 40), (245, 117, 16), -1)\n",
+    "\n",
+    "            # Display probability\n",
+    "            cv2.putText(image, \"RIGHT\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.counter) if right_arm_analysis.is_visible else \"UNK\", (10, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display Left Counter\n",
+    "            cv2.putText(image, \"LEFT\", (95, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.counter) if left_arm_analysis.is_visible else \"UNK\", (100, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # * Display error\n",
+    "            # Right arm error\n",
+    "            cv2.putText(image, \"R_PC\", (165, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.detected_errors[\"PEAK_CONTRACTION\"]), (160, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "            cv2.putText(image, \"R_LUA\", (225, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(right_arm_analysis.detected_errors[\"LOOSE_UPPER_ARM\"]), (220, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Left arm error\n",
+    "            cv2.putText(image, \"L_PC\", (300, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.detected_errors[\"PEAK_CONTRACTION\"]), (295, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "            cv2.putText(image, \"L_LUA\", (380, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(left_arm_analysis.detected_errors[\"LOOSE_UPPER_ARM\"]), (375, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Lean back error\n",
+    "            cv2.putText(image, \"LB\", (460, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(\"C\" if posture == 0 else \"L\") + f\" ,{predicted_class}, {prediction_probability}\", (440, 30), cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "\n",
+    "            # * Visualize angles\n",
+    "            # Visualize LEFT arm calculated angles\n",
+    "            if left_arm_analysis.is_visible:\n",
+    "                cv2.putText(image, str(left_bicep_curl_angle), tuple(np.multiply(left_arm_analysis.elbow, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "                cv2.putText(image, str(left_ground_upper_arm_angle), tuple(np.multiply(left_arm_analysis.shoulder, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "\n",
+    "            # Visualize RIGHT arm calculated angles\n",
+    "            if right_arm_analysis.is_visible:\n",
+    "                cv2.putText(image, str(right_bicep_curl_angle), tuple(np.multiply(right_arm_analysis.elbow, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 0), 1, cv2.LINE_AA)\n",
+    "                cv2.putText(image, str(right_ground_upper_arm_angle), tuple(np.multiply(right_arm_analysis.shoulder, video_dimensions).astype(int)), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 0), 1, cv2.LINE_AA)\n",
+    "        \n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  \n"
+   ]
+  },
+  {
+   "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
+}

core/bicep_model/README.md

@@ -0,0 +1,36 @@
+<h2 align="center">BICEP CURL MODEL TRAINING PROCESS</h2>
+
+### 1. Folder structure
+
+```
+bicep_model
+│   1.data.ipynb - process collected videos
+|   2.sklearn.ipynb - train models using Sklearn ML algo
+│   3.deep_leaning.ipynb - train models using Deep Learning
+│   4.evaluation.ipynb - evaluate trained models
+│   5.detection.ipynb - detection on test videos
+|   train.csv - train dataset after converted from videos
+|   test.csv - test dataset after converted from videos
+|   evaluation.csv - models' evaluation results
+│
+└───model/ - folder contains best trained models and input scaler
+│   │
+```
+
+### 2. Important landmarks
+
+There are 3 popular errors of bicep curl that will be targeted in this thesis:
+
+-   Loose upper arm: when an arm moves upward during the exercise, the upper arm is moving instead of staying still.
+-   Weak peak contraction: when an arm moves upward, it does not go high enough therefore not put enough contraction to the bicep.
+-   Lean too far back: the performer’s torso leans back and fore during the exercise for momentum.
+
+In my research and exploration, **_the important MediaPipe Pose landmarks_** for this exercise are: nose, left shoulder, right shoulder, right elbow, left elbow, right wrist, left wrist, right hip and left hip.
+
+### 3. Error detection method
+
+1. **Loose upper arm**: Can be detected by calculating the angle between the elbow, shoulder and the shoulder’s projection on the ground. Through my research, if the angle is over 40 degrees, the movement will be classified as a “loose upper arm” error
+
+1. **Weak peak contraction**: Can be detected by calculating the angle between the wrist, elbow and shoulder when the performer’s arm is coming up. Through my research, if the angle is more than 60 degrees before the arm comes down, the movement will be classified as a “weak peak contraction” error.
+
+1. **Lean too far back**: Due to its complexity, machine learning will be used for this detection. See this [notebook](./4.evaluation.ipynb) for a evaluation process for this model.

core/bicep_model/evaluation.csv

@@ -0,0 +1,23 @@
+Model,Precision Score,Recall Score,Accuracy Score,F1 Score,Confusion Matrix
+KNN,0.9754011299435028,0.9683363945010297,0.9718543046357616,0.9712296333655557,"[[338   1]
+ [ 16 249]]"
+7_layers,0.9721448467966574,0.9622641509433962,0.9668874172185431,0.9660655092982752,"[[339   0]
+ [ 20 245]]"
+5_layers,0.9631147540983607,0.9490566037735849,0.9552980132450332,0.9540120976270039,"[[339   0]
+ [ 27 238]]"
+SVC,0.9299664562828265,0.9337618968108199,0.9321192052980133,0.9314197094947314,"[[312  27]
+ [ 14 251]]"
+RF,0.9472295514511873,0.9245283018867925,0.9337748344370861,0.9313285202660452,"[[339   0]
+ [ 40 225]]"
+7_layers_with_dropout,0.9358732553753301,0.9244615127734179,0.9304635761589404,0.9285834938008851,"[[330   9]
+ [ 33 232]]"
+3_layers,0.9391653103929318,0.9205153893248734,0.9288079470198676,0.9264113788657968,"[[335   4]
+ [ 39 226]]"
+LR,0.7926937886241248,0.737774809372739,0.7615894039735099,0.7405498281786941,"[[316  23]
+ [121 144]]"
+SGDC,0.7124566903151295,0.7150108532309234,0.7152317880794702,0.7129372754904669,"[[243  96]
+ [ 76 189]]"
+DTC,0.6842549139631369,0.6507819892024267,0.6754966887417219,0.6475785613069935,"[[289  50]
+ [146 119]]"
+NB,0.7973684210526315,0.5641509433962264,0.6175496688741722,0.48664966831131273,"[[339   0]
+ [231  34]]"

core/bicep_model/model/KNN_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6db6bcacdc92f1af9d455e86936ac0437f4b4c3c352c169e790e3d0bb66454e4
+size 3640626

core/bicep_model/model/RF_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4c5486bda6f57467de5c94810e30b0d4b0db109ac8eb80655be71c20d88d09a
+size 1745827

core/bicep_model/model/all_dp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a5b76624aa1b3be26205bbda66aa548cf426521a8897c383f9be4d330673cee
+size 6349244

core/bicep_model/model/all_sklearn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27a82547b1d960a4e19da93e25d2607f674d76c9be0a569e451cc97a18a67432
+size 5533459

core/bicep_model/model/bicep_dp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6eef302ce47e9595f503c94c2ea5d7b7b2c9c7366732236c0ccf5ed125f1281
+size 5202150

core/bicep_model/model/input_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c07942166c3fa393e9fee1fed9228a963fd8cb81111d25b2d6d77aa90d4a4e2
+size 1949

core/bicep_model/train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12d56e9215045a56103f80a83e1952d70320a25c4cf0a33a898b38aade151e5b
+size 10821608

core/lunge_model/2.stage.sklearn.ipynb

@@ -0,0 +1,753 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[21024]: 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 (0x105f48860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15aece480). One of the two will be used. Which one is undefined.\n",
+      "objc[21024]: 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 (0x104310a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15aece4d0). One of the two will be used. Which one is undefined.\n",
+      "objc[21024]: 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 (0x104310a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15aece4f8). One of the two will be used. Which one is undefined.\n",
+      "objc[21024]: 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 (0x104310ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x15aece520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\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. Train Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1. Describe data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "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"
+   ]
+  },
+  {
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 24244 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "D    8232\n",
+      "M    8148\n",
+      "I    7864\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 151\n"
+     ]
+    },
+    {
+     "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>label</th>\n",
+       "      <th>nose_x</th>\n",
+       "      <th>nose_y</th>\n",
+       "      <th>nose_z</th>\n",
+       "      <th>nose_v</th>\n",
+       "      <th>left_shoulder_x</th>\n",
+       "      <th>left_shoulder_y</th>\n",
+       "      <th>left_shoulder_z</th>\n",
+       "      <th>left_shoulder_v</th>\n",
+       "      <th>right_shoulder_x</th>\n",
+       "      <th>...</th>\n",
+       "      <th>right_heel_z</th>\n",
+       "      <th>right_heel_v</th>\n",
+       "      <th>left_foot_index_x</th>\n",
+       "      <th>left_foot_index_y</th>\n",
+       "      <th>left_foot_index_z</th>\n",
+       "      <th>left_foot_index_v</th>\n",
+       "      <th>right_foot_index_x</th>\n",
+       "      <th>right_foot_index_y</th>\n",
+       "      <th>right_foot_index_z</th>\n",
+       "      <th>right_foot_index_v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>M</td>\n",
+       "      <td>0.496085</td>\n",
+       "      <td>0.286904</td>\n",
+       "      <td>-0.219098</td>\n",
+       "      <td>0.999996</td>\n",
+       "      <td>0.500287</td>\n",
+       "      <td>0.360987</td>\n",
+       "      <td>0.019479</td>\n",
+       "      <td>0.999978</td>\n",
+       "      <td>0.436462</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.268695</td>\n",
+       "      <td>0.996758</td>\n",
+       "      <td>0.370391</td>\n",
+       "      <td>0.893386</td>\n",
+       "      <td>0.505172</td>\n",
+       "      <td>0.931761</td>\n",
+       "      <td>0.566927</td>\n",
+       "      <td>1.005949</td>\n",
+       "      <td>-0.382462</td>\n",
+       "      <td>0.998906</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>M</td>\n",
+       "      <td>0.496126</td>\n",
+       "      <td>0.286918</td>\n",
+       "      <td>-0.217849</td>\n",
+       "      <td>0.999996</td>\n",
+       "      <td>0.500281</td>\n",
+       "      <td>0.360954</td>\n",
+       "      <td>0.019995</td>\n",
+       "      <td>0.999977</td>\n",
+       "      <td>0.436466</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.271191</td>\n",
+       "      <td>0.996724</td>\n",
+       "      <td>0.370344</td>\n",
+       "      <td>0.893290</td>\n",
+       "      <td>0.505325</td>\n",
+       "      <td>0.931969</td>\n",
+       "      <td>0.567040</td>\n",
+       "      <td>1.005795</td>\n",
+       "      <td>-0.384848</td>\n",
+       "      <td>0.998902</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>M</td>\n",
+       "      <td>0.496144</td>\n",
+       "      <td>0.286921</td>\n",
+       "      <td>-0.217039</td>\n",
+       "      <td>0.999996</td>\n",
+       "      <td>0.500279</td>\n",
+       "      <td>0.360923</td>\n",
+       "      <td>0.020068</td>\n",
+       "      <td>0.999977</td>\n",
+       "      <td>0.436469</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.271365</td>\n",
+       "      <td>0.996699</td>\n",
+       "      <td>0.370316</td>\n",
+       "      <td>0.893275</td>\n",
+       "      <td>0.504931</td>\n",
+       "      <td>0.931633</td>\n",
+       "      <td>0.567040</td>\n",
+       "      <td>1.005774</td>\n",
+       "      <td>-0.384872</td>\n",
+       "      <td>0.998894</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3 rows × 53 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  label    nose_x    nose_y    nose_z    nose_v  left_shoulder_x  \\\n",
+       "0     M  0.496085  0.286904 -0.219098  0.999996         0.500287   \n",
+       "1     M  0.496126  0.286918 -0.217849  0.999996         0.500281   \n",
+       "2     M  0.496144  0.286921 -0.217039  0.999996         0.500279   \n",
+       "\n",
+       "   left_shoulder_y  left_shoulder_z  left_shoulder_v  right_shoulder_x  ...  \\\n",
+       "0         0.360987         0.019479         0.999978          0.436462  ...   \n",
+       "1         0.360954         0.019995         0.999977          0.436466  ...   \n",
+       "2         0.360923         0.020068         0.999977          0.436469  ...   \n",
+       "\n",
+       "   right_heel_z  right_heel_v  left_foot_index_x  left_foot_index_y  \\\n",
+       "0     -0.268695      0.996758           0.370391           0.893386   \n",
+       "1     -0.271191      0.996724           0.370344           0.893290   \n",
+       "2     -0.271365      0.996699           0.370316           0.893275   \n",
+       "\n",
+       "   left_foot_index_z  left_foot_index_v  right_foot_index_x  \\\n",
+       "0           0.505172           0.931761            0.566927   \n",
+       "1           0.505325           0.931969            0.567040   \n",
+       "2           0.504931           0.931633            0.567040   \n",
+       "\n",
+       "   right_foot_index_y  right_foot_index_z  right_foot_index_v  \n",
+       "0            1.005949           -0.382462            0.998906  \n",
+       "1            1.005795           -0.384848            0.998902  \n",
+       "2            1.005774           -0.384872            0.998894  \n",
+       "\n",
+       "[3 rows x 53 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = describe_dataset(\"./stage.train.csv\")\n",
+    "df.head(3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Train and evaluate model with train set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.linear_model import LogisticRegression, RidgeClassifier, SGDClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "\n",
+    "from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract features and class\n",
+    "X = df.drop(\"label\", axis=1) # features\n",
+    "y = df[\"label\"]\n",
+    "\n",
+    "# Standard Scaler\n",
+    "sc = StandardScaler()\n",
+    "X = pd.DataFrame(sc.fit_transform(X))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8474    M\n",
+       "4197    I\n",
+       "9705    I\n",
+       "Name: label, dtype: object"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)\n",
+    "\n",
+    "y_train.head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "algorithms =[(\"LR\", LogisticRegression()),\n",
+    "         (\"SVC\", SVC(probability=True)),\n",
+    "         ('KNN',KNeighborsClassifier()),\n",
+    "         (\"DTC\", DecisionTreeClassifier()),\n",
+    "         (\"SGDC\", SGDClassifier()),\n",
+    "         (\"Ridge\", RidgeClassifier()),\n",
+    "         ('RF', RandomForestClassifier()),]\n",
+    "\n",
+    "models = {}\n",
+    "final_results = []\n",
+    "\n",
+    "for name, model in algorithms:\n",
+    "    trained_model = model.fit(X_train, y_train)\n",
+    "    models[name] = trained_model\n",
+    "\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(X_test)\n",
+    "\n",
+    "    p_score = precision_score(y_test, model_results, average=\"macro\")\n",
+    "    a_score = accuracy_score(y_test, model_results)\n",
+    "    r_score = recall_score(y_test, model_results, average=\"macro\")\n",
+    "    f1_score_result = f1_score(y_test, model_results, average=None, labels=[\"I\", \"M\", \"D\"])\n",
+    "    final_results.append(( name, p_score, a_score, r_score, f1_score_result ))\n",
+    "\n",
+    "\n",
+    "final_results.sort(key=lambda k: k[4][0] + k[4][1], reverse=True)"
+   ]
+  },
+  {
+   "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>Accuracy score</th>\n",
+       "      <th>Recall Score</th>\n",
+       "      <th>F1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>0.995486</td>\n",
+       "      <td>0.995463</td>\n",
+       "      <td>0.995497</td>\n",
+       "      <td>[0.998108448928121, 0.9936189608021876, 0.9947...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>0.992812</td>\n",
+       "      <td>0.992782</td>\n",
+       "      <td>0.992862</td>\n",
+       "      <td>[0.9977952755905511, 0.9893390191897654, 0.991...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>0.993596</td>\n",
+       "      <td>0.993607</td>\n",
+       "      <td>0.993679</td>\n",
+       "      <td>[0.9949717159019483, 0.9905516610789394, 0.995...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>0.989931</td>\n",
+       "      <td>0.989895</td>\n",
+       "      <td>0.990009</td>\n",
+       "      <td>[0.9959080893925086, 0.9850381679389313, 0.988...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>0.990106</td>\n",
+       "      <td>0.990101</td>\n",
+       "      <td>0.990208</td>\n",
+       "      <td>[0.9943431803896919, 0.9856576136710405, 0.990...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>0.986400</td>\n",
+       "      <td>0.986389</td>\n",
+       "      <td>0.986541</td>\n",
+       "      <td>[0.990894819466248, 0.9797794117647058, 0.9886...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Ridge</td>\n",
+       "      <td>0.970926</td>\n",
+       "      <td>0.970097</td>\n",
+       "      <td>0.969980</td>\n",
+       "      <td>[0.9709677419354839, 0.9567827130852341, 0.982...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Model  Precision Score  Accuracy score  Recall Score  \\\n",
+       "0    KNN         0.995486        0.995463      0.995497   \n",
+       "1    SVC         0.992812        0.992782      0.992862   \n",
+       "2     RF         0.993596        0.993607      0.993679   \n",
+       "3     LR         0.989931        0.989895      0.990009   \n",
+       "4    DTC         0.990106        0.990101      0.990208   \n",
+       "5   SGDC         0.986400        0.986389      0.986541   \n",
+       "6  Ridge         0.970926        0.970097      0.969980   \n",
+       "\n",
+       "                                            F1 score  \n",
+       "0  [0.998108448928121, 0.9936189608021876, 0.9947...  \n",
+       "1  [0.9977952755905511, 0.9893390191897654, 0.991...  \n",
+       "2  [0.9949717159019483, 0.9905516610789394, 0.995...  \n",
+       "3  [0.9959080893925086, 0.9850381679389313, 0.988...  \n",
+       "4  [0.9943431803896919, 0.9856576136710405, 0.990...  \n",
+       "5  [0.990894819466248, 0.9797794117647058, 0.9886...  \n",
+       "6  [0.9709677419354839, 0.9567827130852341, 0.982...  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.DataFrame(final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.3. Evaluate models with test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 1205 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "D    416\n",
+      "I    402\n",
+      "M    387\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 20\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(\"./stage.test.csv\")\n",
+    "test_df = test_df.sample(frac=1).reset_index(drop=True)\n",
+    "\n",
+    "test_x = test_df.drop(\"label\", axis=1)\n",
+    "test_y = test_df[\"label\"]\n",
+    "\n",
+    "test_x = pd.DataFrame(sc.transform(test_x))"
+   ]
+  },
+  {
+   "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>Accuracy score</th>\n",
+       "      <th>Recall Score</th>\n",
+       "      <th>F1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Ridge</td>\n",
+       "      <td>0.953408</td>\n",
+       "      <td>0.951037</td>\n",
+       "      <td>0.949563</td>\n",
+       "      <td>[0.9763387297633873, 0.9199457259158751, 0.954...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>0.955640</td>\n",
+       "      <td>0.951867</td>\n",
+       "      <td>0.950163</td>\n",
+       "      <td>[0.9492325855962219, 0.9194444444444445, 0.982...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>0.952856</td>\n",
+       "      <td>0.948548</td>\n",
+       "      <td>0.946658</td>\n",
+       "      <td>[0.950354609929078, 0.9131652661064426, 0.9764...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>0.919799</td>\n",
+       "      <td>0.915353</td>\n",
+       "      <td>0.916588</td>\n",
+       "      <td>[0.9745454545454546, 0.875609756097561, 0.8941...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>0.928256</td>\n",
+       "      <td>0.912863</td>\n",
+       "      <td>0.909741</td>\n",
+       "      <td>[0.8903654485049834, 0.8444444444444444, 0.992...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>0.870546</td>\n",
+       "      <td>0.862241</td>\n",
+       "      <td>0.861943</td>\n",
+       "      <td>[0.90744920993228, 0.7849740932642487, 0.88829...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>0.859608</td>\n",
+       "      <td>0.857261</td>\n",
+       "      <td>0.855094</td>\n",
+       "      <td>[0.8983240223463688, 0.7577464788732395, 0.899...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Model  Precision Score  Accuracy score  Recall Score  \\\n",
+       "0  Ridge         0.953408        0.951037      0.949563   \n",
+       "1    SVC         0.955640        0.951867      0.950163   \n",
+       "2     LR         0.952856        0.948548      0.946658   \n",
+       "3    KNN         0.919799        0.915353      0.916588   \n",
+       "4   SGDC         0.928256        0.912863      0.909741   \n",
+       "5     RF         0.870546        0.862241      0.861943   \n",
+       "6    DTC         0.859608        0.857261      0.855094   \n",
+       "\n",
+       "                                            F1 score  \n",
+       "0  [0.9763387297633873, 0.9199457259158751, 0.954...  \n",
+       "1  [0.9492325855962219, 0.9194444444444445, 0.982...  \n",
+       "2  [0.950354609929078, 0.9131652661064426, 0.9764...  \n",
+       "3  [0.9745454545454546, 0.875609756097561, 0.8941...  \n",
+       "4  [0.8903654485049834, 0.8444444444444444, 0.992...  \n",
+       "5  [0.90744920993228, 0.7849740932642487, 0.88829...  \n",
+       "6  [0.8983240223463688, 0.7577464788732395, 0.899...  "
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "testset_final_results = []\n",
+    "\n",
+    "for name, model in 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=None, labels=[\"I\", \"M\", \"D\"])\n",
+    "    testset_final_results.append(( name, p_score, a_score, r_score, f1_score_result ))\n",
+    "\n",
+    "\n",
+    "testset_final_results.sort(key=lambda k: k[4][0] + k[4][1], reverse=True)\n",
+    "pd.DataFrame(testset_final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Dumped Model\n",
+    "\n",
+    "The best models are in order:\n",
+    "- Ridge\n",
+    "- SVC\n",
+    "- LR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/stage_LR_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"LR\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/stage_SVC_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"SVC\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/stage_Ridge_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"Ridge\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(sc, f)"
+   ]
+  },
+  {
+   "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
+}

core/lunge_model/3.stage.deep_learning.ipynb

@@ -0,0 +1,767 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data visualization\n",
+    "import numpy as np\n",
+    "import pandas as pd \n",
+    "# Keras\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense\n",
+    "from keras.layers import Dropout\n",
+    "from keras.optimizers import Adam\n",
+    "from keras.utils.np_utils import to_categorical\n",
+    "\n",
+    "# Train-Test\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "# Classification Report\n",
+    "from sklearn.metrics import classification_report, confusion_matrix\n",
+    "\n",
+    "import pickle\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Describe dataset and Train Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1. Describe dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for lunge\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 17040 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "M    6171\n",
+      "D    5735\n",
+      "I    5134\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "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",
+    "# Remove duplicate rows (optional)\n",
+    "def remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_dataset.csv\", sep=',', encoding='utf-8', index=False)\n",
+    "\n",
+    "\n",
+    "df = describe_dataset(\"./dataset.csv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Preprocess data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of rows: 17040 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "1    6171\n",
+      "2    5735\n",
+      "0    5134\n",
+      "Name: label, dtype: int64\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "df = pd.read_csv(\"./dataset.csv\")\n",
+    "\n",
+    "# Categorizing label\n",
+    "df.loc[df[\"label\"] == \"I\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"M\", \"label\"] = 1\n",
+    "df.loc[df[\"label\"] == \"D\", \"label\"] = 2\n",
+    "\n",
+    "print(f'Number of rows: {df.shape[0]} \\nNumber of columns: {df.shape[1]}\\n')\n",
+    "print(f\"Labels: \\n{df['label'].value_counts()}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f2:\n",
+    "    input_scaler = pickle.load(f2)\n",
+    "\n",
+    "x = df.drop(\"label\", axis = 1)\n",
+    "x = pd.DataFrame(input_scaler.transform(x))\n",
+    "\n",
+    "y = df[\"label\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "y_cat = to_categorical(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(x.values, y_cat, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.3. Train model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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",
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " dense (Dense)               (None, 52)                2756      \n",
+      "                                                                 \n",
+      " dropout (Dropout)           (None, 52)                0         \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (None, 52)                2756      \n",
+      "                                                                 \n",
+      " dropout_1 (Dropout)         (None, 52)                0         \n",
+      "                                                                 \n",
+      " dense_2 (Dense)             (None, 14)                742       \n",
+      "                                                                 \n",
+      " dense_3 (Dense)             (None, 3)                 45        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 6,299\n",
+      "Trainable params: 6,299\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-14 10:38:36.786157: 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-14 10:38:36.786920: 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": [
+    "model = Sequential()\n",
+    "model.add(Dense(52, input_dim = 52, activation = \"relu\"))\n",
+    "model.add(Dropout(0.5))\n",
+    "model.add(Dense(52, activation = \"relu\"))\n",
+    "model.add(Dropout(0.5))\n",
+    "model.add(Dense(14, activation = \"relu\"))\n",
+    "model.add(Dense(3, activation = \"softmax\"))\n",
+    "model.compile(Adam(lr = 0.01), \"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-14 10:38:48.571461: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n",
+      "2022-11-14 10:38:48.827690: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1364/1364 [==============================] - ETA: 0s - loss: 0.1082 - accuracy: 0.9696"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-14 10:39:02.176190: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.1082 - accuracy: 0.9696 - val_loss: 0.0339 - val_accuracy: 0.9947\n",
+      "Epoch 2/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0599 - accuracy: 0.9872 - val_loss: 0.0595 - val_accuracy: 0.9815\n",
+      "Epoch 3/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0527 - accuracy: 0.9885 - val_loss: 0.0530 - val_accuracy: 0.9944\n",
+      "Epoch 4/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0450 - accuracy: 0.9905 - val_loss: 0.0356 - val_accuracy: 0.9938\n",
+      "Epoch 5/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.1253 - accuracy: 0.9747 - val_loss: 0.0501 - val_accuracy: 0.9921\n",
+      "Epoch 6/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0682 - accuracy: 0.9884 - val_loss: 0.0445 - val_accuracy: 0.9865\n",
+      "Epoch 7/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0534 - accuracy: 0.9900 - val_loss: 0.0400 - val_accuracy: 0.9933\n",
+      "Epoch 8/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0627 - accuracy: 0.9913 - val_loss: 0.0396 - val_accuracy: 0.9950\n",
+      "Epoch 9/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0556 - accuracy: 0.9905 - val_loss: 0.0397 - val_accuracy: 0.9953\n",
+      "Epoch 10/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0656 - accuracy: 0.9900 - val_loss: 0.0657 - val_accuracy: 0.9795\n",
+      "Epoch 11/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0661 - accuracy: 0.9862 - val_loss: 0.0454 - val_accuracy: 0.9933\n",
+      "Epoch 12/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0638 - accuracy: 0.9894 - val_loss: 0.0404 - val_accuracy: 0.9930\n",
+      "Epoch 13/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0643 - accuracy: 0.9911 - val_loss: 0.1060 - val_accuracy: 0.9668\n",
+      "Epoch 14/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1065 - accuracy: 0.9883 - val_loss: 0.0645 - val_accuracy: 0.9844\n",
+      "Epoch 15/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0914 - accuracy: 0.9858 - val_loss: 0.0930 - val_accuracy: 0.9683\n",
+      "Epoch 16/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0463 - accuracy: 0.9916 - val_loss: 0.0557 - val_accuracy: 0.9886\n",
+      "Epoch 17/100\n",
+      "1364/1364 [==============================] - 14s 11ms/step - loss: 0.1247 - accuracy: 0.9880 - val_loss: 0.0620 - val_accuracy: 0.9886\n",
+      "Epoch 18/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1441 - accuracy: 0.9807 - val_loss: 0.0483 - val_accuracy: 0.9935\n",
+      "Epoch 19/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.1044 - accuracy: 0.9886 - val_loss: 0.0375 - val_accuracy: 0.9944\n",
+      "Epoch 20/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0604 - accuracy: 0.9900 - val_loss: 0.0382 - val_accuracy: 0.9933\n",
+      "Epoch 21/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0758 - accuracy: 0.9916 - val_loss: 0.0461 - val_accuracy: 0.9933\n",
+      "Epoch 22/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0413 - accuracy: 0.9916 - val_loss: 0.1001 - val_accuracy: 0.9704\n",
+      "Epoch 23/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0492 - accuracy: 0.9934 - val_loss: 0.0482 - val_accuracy: 0.9959\n",
+      "Epoch 24/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0689 - accuracy: 0.9897 - val_loss: 0.0374 - val_accuracy: 0.9950\n",
+      "Epoch 25/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0663 - accuracy: 0.9911 - val_loss: 0.0341 - val_accuracy: 0.9944\n",
+      "Epoch 26/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0983 - accuracy: 0.9904 - val_loss: 0.0470 - val_accuracy: 0.9933\n",
+      "Epoch 27/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0699 - accuracy: 0.9906 - val_loss: 0.0455 - val_accuracy: 0.9921\n",
+      "Epoch 28/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0521 - accuracy: 0.9908 - val_loss: 0.0438 - val_accuracy: 0.9915\n",
+      "Epoch 29/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0594 - accuracy: 0.9904 - val_loss: 0.0490 - val_accuracy: 0.9930\n",
+      "Epoch 30/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.1044 - accuracy: 0.9903 - val_loss: 0.0439 - val_accuracy: 0.9933\n",
+      "Epoch 31/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0414 - accuracy: 0.9930 - val_loss: 0.0664 - val_accuracy: 0.9806\n",
+      "Epoch 32/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0507 - accuracy: 0.9927 - val_loss: 0.1468 - val_accuracy: 0.9563\n",
+      "Epoch 33/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0745 - accuracy: 0.9907 - val_loss: 0.0730 - val_accuracy: 0.9742\n",
+      "Epoch 34/100\n",
+      "1364/1364 [==============================] - 14s 11ms/step - loss: 0.0595 - accuracy: 0.9896 - val_loss: 0.0525 - val_accuracy: 0.9933\n",
+      "Epoch 35/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0849 - accuracy: 0.9884 - val_loss: 0.0396 - val_accuracy: 0.9941\n",
+      "Epoch 36/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0738 - accuracy: 0.9882 - val_loss: 0.0384 - val_accuracy: 0.9950\n",
+      "Epoch 37/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1039 - accuracy: 0.9892 - val_loss: 0.0417 - val_accuracy: 0.9941\n",
+      "Epoch 38/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1345 - accuracy: 0.9883 - val_loss: 0.0380 - val_accuracy: 0.9921\n",
+      "Epoch 39/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0483 - accuracy: 0.9930 - val_loss: 0.0325 - val_accuracy: 0.9959\n",
+      "Epoch 40/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0427 - accuracy: 0.9931 - val_loss: 0.0399 - val_accuracy: 0.9947\n",
+      "Epoch 41/100\n",
+      "1364/1364 [==============================] - 14s 11ms/step - loss: 0.0430 - accuracy: 0.9924 - val_loss: 0.0555 - val_accuracy: 0.9950\n",
+      "Epoch 42/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0536 - accuracy: 0.9917 - val_loss: 0.0533 - val_accuracy: 0.9933\n",
+      "Epoch 43/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.1049 - accuracy: 0.9912 - val_loss: 0.0374 - val_accuracy: 0.9935\n",
+      "Epoch 44/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0831 - accuracy: 0.9930 - val_loss: 0.0339 - val_accuracy: 0.9950\n",
+      "Epoch 45/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0529 - accuracy: 0.9920 - val_loss: 0.0365 - val_accuracy: 0.9953\n",
+      "Epoch 46/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0634 - accuracy: 0.9909 - val_loss: 0.0412 - val_accuracy: 0.9947\n",
+      "Epoch 47/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0626 - accuracy: 0.9917 - val_loss: 0.0390 - val_accuracy: 0.9956\n",
+      "Epoch 48/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1139 - accuracy: 0.9907 - val_loss: 0.0426 - val_accuracy: 0.9944\n",
+      "Epoch 49/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0622 - accuracy: 0.9902 - val_loss: 0.0400 - val_accuracy: 0.9938\n",
+      "Epoch 50/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0857 - accuracy: 0.9900 - val_loss: 0.0980 - val_accuracy: 0.9862\n",
+      "Epoch 51/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1315 - accuracy: 0.9900 - val_loss: 0.0488 - val_accuracy: 0.9944\n",
+      "Epoch 52/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0508 - accuracy: 0.9925 - val_loss: 0.0433 - val_accuracy: 0.9944\n",
+      "Epoch 53/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0558 - accuracy: 0.9919 - val_loss: 0.0418 - val_accuracy: 0.9938\n",
+      "Epoch 54/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0391 - accuracy: 0.9937 - val_loss: 0.0398 - val_accuracy: 0.9947\n",
+      "Epoch 55/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0447 - accuracy: 0.9938 - val_loss: 0.0511 - val_accuracy: 0.9953\n",
+      "Epoch 56/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0377 - accuracy: 0.9937 - val_loss: 0.0454 - val_accuracy: 0.9933\n",
+      "Epoch 57/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0467 - accuracy: 0.9927 - val_loss: 0.0542 - val_accuracy: 0.9912\n",
+      "Epoch 58/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0450 - accuracy: 0.9925 - val_loss: 0.0441 - val_accuracy: 0.9938\n",
+      "Epoch 59/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0541 - accuracy: 0.9938 - val_loss: 0.0586 - val_accuracy: 0.9839\n",
+      "Epoch 60/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0363 - accuracy: 0.9936 - val_loss: 0.0418 - val_accuracy: 0.9944\n",
+      "Epoch 61/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0612 - accuracy: 0.9919 - val_loss: 0.0478 - val_accuracy: 0.9918\n",
+      "Epoch 62/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0545 - accuracy: 0.9922 - val_loss: 0.0776 - val_accuracy: 0.9850\n",
+      "Epoch 63/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0663 - accuracy: 0.9910 - val_loss: 0.0660 - val_accuracy: 0.9933\n",
+      "Epoch 64/100\n",
+      "1364/1364 [==============================] - 16s 11ms/step - loss: 0.0597 - accuracy: 0.9920 - val_loss: 0.0792 - val_accuracy: 0.9850\n",
+      "Epoch 65/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0395 - accuracy: 0.9927 - val_loss: 0.1932 - val_accuracy: 0.9935\n",
+      "Epoch 66/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1077 - accuracy: 0.9911 - val_loss: 0.0754 - val_accuracy: 0.9806\n",
+      "Epoch 67/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0505 - accuracy: 0.9917 - val_loss: 0.1537 - val_accuracy: 0.9824\n",
+      "Epoch 68/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1343 - accuracy: 0.9897 - val_loss: 0.0956 - val_accuracy: 0.9921\n",
+      "Epoch 69/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0766 - accuracy: 0.9871 - val_loss: 0.0841 - val_accuracy: 0.9880\n",
+      "Epoch 70/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.1537 - accuracy: 0.9734 - val_loss: 0.0734 - val_accuracy: 0.9933\n",
+      "Epoch 71/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0720 - accuracy: 0.9884 - val_loss: 0.0573 - val_accuracy: 0.9935\n",
+      "Epoch 72/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0545 - accuracy: 0.9928 - val_loss: 0.0505 - val_accuracy: 0.9927\n",
+      "Epoch 73/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0748 - accuracy: 0.9923 - val_loss: 0.0453 - val_accuracy: 0.9950\n",
+      "Epoch 74/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0661 - accuracy: 0.9891 - val_loss: 0.0652 - val_accuracy: 0.9941\n",
+      "Epoch 75/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0676 - accuracy: 0.9893 - val_loss: 0.0467 - val_accuracy: 0.9935\n",
+      "Epoch 76/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0601 - accuracy: 0.9891 - val_loss: 0.1189 - val_accuracy: 0.9944\n",
+      "Epoch 77/100\n",
+      "1364/1364 [==============================] - 14s 11ms/step - loss: 0.0404 - accuracy: 0.9940 - val_loss: 0.0557 - val_accuracy: 0.9935\n",
+      "Epoch 78/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0686 - accuracy: 0.9932 - val_loss: 0.0495 - val_accuracy: 0.9941\n",
+      "Epoch 79/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0409 - accuracy: 0.9943 - val_loss: 0.0618 - val_accuracy: 0.9950\n",
+      "Epoch 80/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0613 - accuracy: 0.9928 - val_loss: 0.0438 - val_accuracy: 0.9944\n",
+      "Epoch 81/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0818 - accuracy: 0.9893 - val_loss: 0.0639 - val_accuracy: 0.9935\n",
+      "Epoch 82/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0558 - accuracy: 0.9898 - val_loss: 0.0750 - val_accuracy: 0.9933\n",
+      "Epoch 83/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0568 - accuracy: 0.9919 - val_loss: 0.0522 - val_accuracy: 0.9950\n",
+      "Epoch 84/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0707 - accuracy: 0.9927 - val_loss: 0.0336 - val_accuracy: 0.9950\n",
+      "Epoch 85/100\n",
+      "1364/1364 [==============================] - 15s 11ms/step - loss: 0.0615 - accuracy: 0.9929 - val_loss: 0.0433 - val_accuracy: 0.9953\n",
+      "Epoch 86/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0375 - accuracy: 0.9943 - val_loss: 0.1049 - val_accuracy: 0.9947\n",
+      "Epoch 87/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0372 - accuracy: 0.9942 - val_loss: 0.0892 - val_accuracy: 0.9950\n",
+      "Epoch 88/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0641 - accuracy: 0.9927 - val_loss: 0.0985 - val_accuracy: 0.9935\n",
+      "Epoch 89/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0512 - accuracy: 0.9913 - val_loss: 0.0580 - val_accuracy: 0.9950\n",
+      "Epoch 90/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0864 - accuracy: 0.9921 - val_loss: 0.1047 - val_accuracy: 0.9950\n",
+      "Epoch 91/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0407 - accuracy: 0.9934 - val_loss: 0.0739 - val_accuracy: 0.9944\n",
+      "Epoch 92/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0419 - accuracy: 0.9930 - val_loss: 0.0651 - val_accuracy: 0.9853\n",
+      "Epoch 93/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0989 - accuracy: 0.9897 - val_loss: 0.0819 - val_accuracy: 0.9938\n",
+      "Epoch 94/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0427 - accuracy: 0.9927 - val_loss: 0.0784 - val_accuracy: 0.9947\n",
+      "Epoch 95/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0463 - accuracy: 0.9938 - val_loss: 0.0942 - val_accuracy: 0.9933\n",
+      "Epoch 96/100\n",
+      "1364/1364 [==============================] - 13s 10ms/step - loss: 0.0598 - accuracy: 0.9908 - val_loss: 0.1309 - val_accuracy: 0.9909\n",
+      "Epoch 97/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0717 - accuracy: 0.9916 - val_loss: 0.0960 - val_accuracy: 0.9944\n",
+      "Epoch 98/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0370 - accuracy: 0.9938 - val_loss: 0.1445 - val_accuracy: 0.9947\n",
+      "Epoch 99/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0679 - accuracy: 0.9929 - val_loss: 0.1177 - val_accuracy: 0.9938\n",
+      "Epoch 100/100\n",
+      "1364/1364 [==============================] - 14s 10ms/step - loss: 0.0516 - accuracy: 0.9915 - val_loss: 0.1030 - val_accuracy: 0.9950\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x15b5fc310>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Model Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1. Train set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  1/107 [..............................] - ETA: 30s"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-14 11:04:43.450300: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/107 [==============================] - 1s 3ms/step\n",
+      "107/107 [==============================] - 0s 2ms/step\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[1037,    7,    1],\n",
+       "       [   0, 1208,    3],\n",
+       "       [   0,    6, 1146]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "predict_x = model.predict(x_test) \n",
+    "y_pred_class = np.argmax(predict_x, axis=1)\n",
+    "\n",
+    "y_pred = model.predict(x_test)\n",
+    "y_test_class = np.argmax(y_test, axis=1)\n",
+    "\n",
+    "confusion_matrix(y_test_class, y_pred_class)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      0.99      1.00      1045\n",
+      "           1       0.99      1.00      0.99      1211\n",
+      "           2       1.00      0.99      1.00      1152\n",
+      "\n",
+      "    accuracy                           1.00      3408\n",
+      "   macro avg       1.00      0.99      1.00      3408\n",
+      "weighted avg       1.00      1.00      1.00      3408\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(classification_report(y_test_class, y_pred_class))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2. Test set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_df = pd.read_csv(\"./test.csv\")\n",
+    "\n",
+    "# Categorizing label\n",
+    "test_df.loc[test_df[\"label\"] == \"I\", \"label\"] = 0\n",
+    "test_df.loc[test_df[\"label\"] == \"M\", \"label\"] = 1\n",
+    "test_df.loc[test_df[\"label\"] == \"D\", \"label\"] = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "test_x = test_df.drop(\"label\", axis = 1)\n",
+    "test_x = pd.DataFrame(input_scaler.transform(test_x))\n",
+    "\n",
+    "test_y = test_df[\"label\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "test_y_cat = to_categorical(test_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "26/26 [==============================] - 0s 2ms/step\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[267,   0,   0],\n",
+       "       [  0, 263,   0],\n",
+       "       [  0,   0, 299]])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "predict_x = model.predict(test_x) \n",
+    "y_pred_class = np.argmax(predict_x, axis=1)\n",
+    "y_test_class = np.argmax(test_y_cat, axis=1)\n",
+    "\n",
+    "confusion_matrix(y_test_class, y_pred_class)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00       267\n",
+      "           1       1.00      1.00      1.00       263\n",
+      "           2       1.00      1.00      1.00       299\n",
+      "\n",
+      "    accuracy                           1.00       829\n",
+      "   macro avg       1.00      1.00      1.00       829\n",
+      "weighted avg       1.00      1.00      1.00       829\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(classification_report(y_test_class, y_pred_class))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Dump Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: ram://6d931dd9-8715-41d1-81d4-8f3b853c1109/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Dump the best model to a pickle file\n",
+    "with open(\"./model/lunge_model_deep_learning.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(model, f)"
+   ]
+  },
+  {
+   "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
+}

core/lunge_model/4.stage.detection.ipynb

@@ -0,0 +1,717 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[95030]: 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 (0x111288860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x167476480). One of the two will be used. Which one is undefined.\n",
+      "objc[95030]: 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 (0x110c50a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x1674764d0). One of the two will be used. Which one is undefined.\n",
+      "objc[95030]: 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 (0x110c50a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x1674764f8). One of the two will be used. Which one is undefined.\n",
+      "objc[95030]: 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 (0x110c50ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x167476520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "import pickle\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. Reconstruct input structure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for lunge\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Set up important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Ellipsis"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def extract_important_keypoints(results) -> list:\n",
+    "    '''\n",
+    "    Extract important keypoints from mediapipe pose detection\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "\n",
+    "    data = []\n",
+    "    for lm in IMPORTANT_LMS:\n",
+    "        keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "        data.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "    \n",
+    "    return np.array(data).flatten().tolist()\n",
+    "\n",
+    "\n",
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation =cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "def calculate_angle(point1: list, point2: list, point3: list) -> float:\n",
+    "    '''\n",
+    "    Calculate the angle between 3 points\n",
+    "    Unit of the angle will be in Degree\n",
+    "    '''\n",
+    "    point1 = np.array(point1)\n",
+    "    point2 = np.array(point2)\n",
+    "    point3 = np.array(point3)\n",
+    "\n",
+    "    # Calculate algo\n",
+    "    angleInRad = np.arctan2(point3[1] - point2[1], point3[0] - point2[0]) - np.arctan2(point1[1] - point2[1], point1[0] - point2[0])\n",
+    "    angleInDeg = np.abs(angleInRad * 180.0 / np.pi)\n",
+    "\n",
+    "    angleInDeg = angleInDeg if angleInDeg <= 180 else 360 - angleInDeg\n",
+    "    return angleInDeg\n",
+    "    \n",
+    "\n",
+    "def analyze_knee_angle(\n",
+    "    mp_results, stage: str, angle_thresholds: list, draw_to_image: tuple = None\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Calculate angle of each knee while performer at the DOWN position\n",
+    "\n",
+    "    Return result explanation:\n",
+    "        error: True if at least 1 error\n",
+    "        right\n",
+    "            error: True if an error is on the right knee\n",
+    "            angle: Right knee angle\n",
+    "        left\n",
+    "            error: True if an error is on the left knee\n",
+    "            angle: Left knee angle\n",
+    "    \"\"\"\n",
+    "    results = {\n",
+    "        \"error\": None,\n",
+    "        \"right\": {\"error\": None, \"angle\": None},\n",
+    "        \"left\": {\"error\": None, \"angle\": None},\n",
+    "    }\n",
+    "\n",
+    "    landmarks = mp_results.pose_landmarks.landmark\n",
+    "\n",
+    "    # Calculate right knee angle\n",
+    "    right_hip = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y,\n",
+    "    ]\n",
+    "    right_knee = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y,\n",
+    "    ]\n",
+    "    right_ankle = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y,\n",
+    "    ]\n",
+    "    results[\"right\"][\"angle\"] = calculate_angle(right_hip, right_knee, right_ankle)\n",
+    "\n",
+    "    # Calculate left knee angle\n",
+    "    left_hip = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y,\n",
+    "    ]\n",
+    "    left_knee = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y,\n",
+    "    ]\n",
+    "    left_ankle = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y,\n",
+    "    ]\n",
+    "    results[\"left\"][\"angle\"] = calculate_angle(left_hip, left_knee, left_ankle)\n",
+    "\n",
+    "    # Draw to image\n",
+    "    if draw_to_image is not None and stage != \"down\":\n",
+    "        (image, video_dimensions) = draw_to_image\n",
+    "\n",
+    "        # Visualize angles\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"right\"][\"angle\"])),\n",
+    "            tuple(np.multiply(right_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            0.5,\n",
+    "            (255, 255, 255),\n",
+    "            1,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"left\"][\"angle\"])),\n",
+    "            tuple(np.multiply(left_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            0.5,\n",
+    "            (255, 255, 255),\n",
+    "            1,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "\n",
+    "    if stage != \"down\":\n",
+    "        return results\n",
+    "\n",
+    "    # Evaluation\n",
+    "    results[\"error\"] = False\n",
+    "\n",
+    "    if angle_thresholds[0] <= results[\"right\"][\"angle\"] <= angle_thresholds[1]:\n",
+    "        results[\"right\"][\"error\"] = False\n",
+    "    else:\n",
+    "        results[\"right\"][\"error\"] = True\n",
+    "        results[\"error\"] = True\n",
+    "\n",
+    "    if angle_thresholds[0] <= results[\"left\"][\"angle\"] <= angle_thresholds[1]:\n",
+    "        results[\"left\"][\"error\"] = False\n",
+    "    else:\n",
+    "        results[\"left\"][\"error\"] = True\n",
+    "        results[\"error\"] = True\n",
+    "\n",
+    "    # Draw to image\n",
+    "    if draw_to_image is not None:\n",
+    "        (image, video_dimensions) = draw_to_image\n",
+    "\n",
+    "        right_color = (255, 255, 255) if not results[\"right\"][\"error\"] else (0, 0, 255)\n",
+    "        left_color = (255, 255, 255) if not results[\"left\"][\"error\"] else (0, 0, 255)\n",
+    "\n",
+    "        right_font_scale = 0.5 if not results[\"right\"][\"error\"] else 1\n",
+    "        left_font_scale = 0.5 if not results[\"left\"][\"error\"] else 1\n",
+    "\n",
+    "        right_thickness = 1 if not results[\"right\"][\"error\"] else 2\n",
+    "        left_thickness = 1 if not results[\"left\"][\"error\"] else 2\n",
+    "\n",
+    "        # Visualize angles\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"right\"][\"angle\"])),\n",
+    "            tuple(np.multiply(right_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            right_font_scale,\n",
+    "            right_color,\n",
+    "            right_thickness,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"left\"][\"angle\"])),\n",
+    "            tuple(np.multiply(left_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            left_font_scale,\n",
+    "            left_color,\n",
+    "            left_thickness,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "\n",
+    "    return results\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "VIDEO_PATH1 = \"../data/lunge/lunge_test.mp4\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    input_scaler = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Detection with Sklearn model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "with open(\"./model/KNN_model.pkl\", \"rb\") as f:\n",
+    "    sklearn_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH1)\n",
+    "current_stage = \"\"\n",
+    "counter = 0\n",
+    "prediction_probability_threshold = 0.8\n",
+    "ANGLE_THRESHOLDS = [60, 135]\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results)\n",
+    "            X = pd.DataFrame([row], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            predicted_class = sklearn_model.predict(X)[0]\n",
+    "            prediction_probabilities = sklearn_model.predict_proba(X)[0]\n",
+    "            prediction_probability = round(prediction_probabilities[prediction_probabilities.argmax()], 2)\n",
+    "\n",
+    "            # Evaluate model prediction\n",
+    "            if predicted_class == \"I\" and prediction_probability >= prediction_probability_threshold:\n",
+    "                current_stage = \"init\"\n",
+    "            elif predicted_class == \"M\" and prediction_probability >= prediction_probability_threshold: \n",
+    "                current_stage = \"mid\"\n",
+    "            elif predicted_class == \"D\" and prediction_probability >= prediction_probability_threshold:\n",
+    "                if current_stage == \"mid\":\n",
+    "                    counter += 1\n",
+    "                \n",
+    "                current_stage = \"down\"\n",
+    "            \n",
+    "            # Error detection\n",
+    "            analyze_knee_angle(mp_results=results, stage=current_stage, angle_thresholds=ANGLE_THRESHOLDS, draw_to_image=(image, video_dimensions))\n",
+    "            \n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (400, 60), (245, 117, 16), -1)\n",
+    "\n",
+    "             # Display probability\n",
+    "            cv2.putText(image, \"PROB\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(prediction_probability), (10, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display class\n",
+    "            cv2.putText(image, \"CLASS\", (95, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, current_stage, (90, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display probability\n",
+    "            cv2.putText(image, \"COUNTER\", (255, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(counter), (250, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "            traceback.print_exc()\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. Detection with Deep learning model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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-14 11:15:32.563689: 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-14 11:15:32.564066: 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 model\n",
+    "with open(\"./model/lunge_model_deep_learning.pkl\", \"rb\") as f:\n",
+    "    deep_learning_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 12ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 12ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 12ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 12ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 9ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 19ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 11ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n",
+      "1/1 [==============================] - 0s 10ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH1)\n",
+    "current_stage = \"\"\n",
+    "counter = 0\n",
+    "prediction_probability_threshold = 0.6\n",
+    "ANGLE_THRESHOLDS = [60, 135]\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results)\n",
+    "            X = pd.DataFrame([row, ], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "            \n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            prediction = deep_learning_model.predict(X)\n",
+    "            predicted_class = np.argmax(prediction, axis=1)[0]\n",
+    "            prediction_probability = max(prediction.tolist()[0])\n",
+    "\n",
+    "            # Evaluate model prediction\n",
+    "            if predicted_class == 0 and prediction_probability >= prediction_probability_threshold:\n",
+    "                current_stage = \"init\"\n",
+    "            elif predicted_class == 1 and prediction_probability >= prediction_probability_threshold: \n",
+    "                current_stage = \"mid\"\n",
+    "            elif predicted_class == 2 and prediction_probability >= prediction_probability_threshold:\n",
+    "                if current_stage == \"mid\":\n",
+    "                    counter += 1\n",
+    "\n",
+    "                current_stage = \"down\"\n",
+    "            \n",
+    "            analyze_knee_angle(mp_results=results, stage=current_stage, angle_thresholds=ANGLE_THRESHOLDS, draw_to_image=(image, video_dimensions))\n",
+    "\n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (550, 60), (245, 117, 16), -1)\n",
+    "\n",
+    "            # # Display class\n",
+    "            cv2.putText(image, \"DETECTION\", (95, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, current_stage, (90, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # # Display probability\n",
+    "            cv2.putText(image, \"PROB\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(round(prediction_probability, 2)), (10, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # # Display class\n",
+    "            cv2.putText(image, \"CLASS\", (225, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(predicted_class), (220, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "            # # Display class\n",
+    "            cv2.putText(image, \"COUNTER\", (350, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(counter), (345, 40), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  "
+   ]
+  }
+ ],
+ "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
+}

core/lunge_model/5.err.data.ipynb

@@ -0,0 +1,562 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[68038]: 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 (0x10c548860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da480). One of the two will be used. Which one is undefined.\n",
+      "objc[68038]: 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 (0x107304a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da4d0). One of the two will be used. Which one is undefined.\n",
+      "objc[68038]: 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 (0x107304a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da4f8). One of the two will be used. Which one is undefined.\n",
+      "objc[68038]: 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 (0x107304ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import csv\n",
+    "import os\n",
+    "import seaborn as sns\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. Build dataset from collected video"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1. Determine important landmarks and set up important functions\n",
+    "\n",
+    "The error that I try to tackle is **KNEE OVER TOE** error when lunge is at down stage.\n",
+    "- \"C\": Correct Form\n",
+    "- \"L\": Incorrect Form"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for lunge\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "    \n",
+    "\n",
+    "def init_csv(dataset_path: str):\n",
+    "    '''\n",
+    "    Create a blank csv file with just columns\n",
+    "    '''\n",
+    "\n",
+    "    # Ignore if file is already exist\n",
+    "    if os.path.exists(dataset_path):\n",
+    "        return\n",
+    "\n",
+    "    # Write all the columns to a empty file\n",
+    "    with open(dataset_path, mode=\"w\", newline=\"\") as f:\n",
+    "        csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "        csv_writer.writerow(HEADERS)\n",
+    "\n",
+    "\n",
+    "def export_landmark_to_csv(dataset_path: str, results, action: str) -> None:\n",
+    "    '''\n",
+    "    Export Labeled Data from detected landmark to csv\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "    keypoints = []\n",
+    "\n",
+    "    try:\n",
+    "        # Extract coordinate of important landmarks\n",
+    "        for lm in IMPORTANT_LMS:\n",
+    "            keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "            keypoints.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "        \n",
+    "        keypoints = list(np.array(keypoints).flatten())\n",
+    "\n",
+    "        # Insert action as the label (first column)\n",
+    "        keypoints.insert(0, action)\n",
+    "\n",
+    "        # Append new row to .csv file\n",
+    "        with open(dataset_path, mode=\"a\", newline=\"\") as f:\n",
+    "            csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "            csv_writer.writerow(keypoints)\n",
+    "        \n",
+    "\n",
+    "    except Exception as e:\n",
+    "        print(e)\n",
+    "        pass\n",
+    "\n",
+    "\n",
+    "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 remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_dataset.csv\", sep=',', encoding='utf-8', index=False)\n",
+    "    \n",
+    "\n",
+    "def concat_csv_files_with_same_headers(file_paths: list, saved_path: str):\n",
+    "    '''\n",
+    "    Concat different csv files\n",
+    "    '''\n",
+    "    all_df = []\n",
+    "    for path in file_paths:\n",
+    "        df = pd.read_csv(path, index_col=None, header=0)\n",
+    "        all_df.append(df)\n",
+    "    \n",
+    "    results = pd.concat(all_df, axis=0, ignore_index=True)\n",
+    "    results.to_csv(saved_path, sep=',', encoding='utf-8', index=False)\n",
+    "\n",
+    "\n",
+    "def calculate_angle(point1: list, point2: list, point3: list) -> float:\n",
+    "    '''\n",
+    "    Calculate the angle between 3 points\n",
+    "    Unit of the angle will be in Degree\n",
+    "    '''\n",
+    "    point1 = np.array(point1)\n",
+    "    point2 = np.array(point2)\n",
+    "    point3 = np.array(point3)\n",
+    "\n",
+    "    # Calculate algo\n",
+    "    angleInRad = np.arctan2(point3[1] - point2[1], point3[0] - point2[0]) - np.arctan2(point1[1] - point2[1], point1[0] - point2[0])\n",
+    "    angleInDeg = np.abs(angleInRad * 180.0 / np.pi)\n",
+    "\n",
+    "    angleInDeg = angleInDeg if angleInDeg <= 180 else 360 - angleInDeg\n",
+    "    return angleInDeg"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Extract data for train set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OpenCV: Couldn't read video stream from file \"../data/lunge/lunge_9.mp4\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATASET_PATH = \"err.train.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/lunge/lunge_9.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "init_csv(DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.8, min_tracking_confidence=0.9) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        # image = cv2.flip(image, 1)\n",
+    "\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "        \n",
+    "        if not results.pose_landmarks: continue\n",
+    "\n",
+    "        landmarks = results.pose_landmarks.landmark\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(1) & 0xFF\n",
+    "\n",
+    "        # * Press I to save as INIT stage\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # * Press M to save as MID stage\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 17907 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    9114\n",
+      "C    8793\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = describe_dataset(DATASET_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.3. Extract data for test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TEST_DATASET_PATH = \"err.test.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/lunge/lunge_test_5.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "init_csv(TEST_DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.8) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "        \n",
+    "        if not results.pose_landmarks: continue\n",
+    "\n",
+    "        landmarks = results.pose_landmarks.landmark\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(10) & 0xFF\n",
+    "\n",
+    "        # * Press C to save as Correct stage\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # * Press L to save as Incorrect stage\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 783 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    406\n",
+      "C    377\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(TEST_DATASET_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Data Visualization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Train set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 17907 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    9114\n",
+      "C    8793\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='label', ylabel='count'>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df = describe_dataset(\"./err.train.csv\")\n",
+    "sns.countplot(x='label', data=df, palette=\"Set1\") "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. Test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='count', ylabel='label'>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.countplot(y='label', data=test_df, palette=\"Set1\") "
+   ]
+  },
+  {
+   "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
+}

core/lunge_model/6.err.sklearn.ipynb

@@ -0,0 +1,777 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[58344]: 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 (0x10ae08860) 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[58344]: 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 (0x105baca68) 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[58344]: 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 (0x105baca90) 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[58344]: 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 (0x105bacab8) 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 cv2\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score, confusion_matrix\n",
+    "from sklearn.calibration import CalibratedClassifierCV\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 up important functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "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. Describe and process data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TRAIN_SET_PATH  = \"./err.train.csv\"\n",
+    "TEST_SET_PATH  = \"./err.test.csv\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 17907 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    9114\n",
+      "C    8793\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    },
+    {
+     "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>label</th>\n",
+       "      <th>nose_x</th>\n",
+       "      <th>nose_y</th>\n",
+       "      <th>nose_z</th>\n",
+       "      <th>nose_v</th>\n",
+       "      <th>left_shoulder_x</th>\n",
+       "      <th>left_shoulder_y</th>\n",
+       "      <th>left_shoulder_z</th>\n",
+       "      <th>left_shoulder_v</th>\n",
+       "      <th>right_shoulder_x</th>\n",
+       "      <th>...</th>\n",
+       "      <th>right_heel_z</th>\n",
+       "      <th>right_heel_v</th>\n",
+       "      <th>left_foot_index_x</th>\n",
+       "      <th>left_foot_index_y</th>\n",
+       "      <th>left_foot_index_z</th>\n",
+       "      <th>left_foot_index_v</th>\n",
+       "      <th>right_foot_index_x</th>\n",
+       "      <th>right_foot_index_y</th>\n",
+       "      <th>right_foot_index_z</th>\n",
+       "      <th>right_foot_index_v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>17904</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.647438</td>\n",
+       "      <td>0.442268</td>\n",
+       "      <td>0.004114</td>\n",
+       "      <td>0.999985</td>\n",
+       "      <td>0.615798</td>\n",
+       "      <td>0.517170</td>\n",
+       "      <td>0.151706</td>\n",
+       "      <td>0.999579</td>\n",
+       "      <td>0.631354</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.034228</td>\n",
+       "      <td>0.979719</td>\n",
+       "      <td>0.701826</td>\n",
+       "      <td>0.880516</td>\n",
+       "      <td>0.134222</td>\n",
+       "      <td>0.979319</td>\n",
+       "      <td>0.504880</td>\n",
+       "      <td>0.881748</td>\n",
+       "      <td>-0.027911</td>\n",
+       "      <td>0.986165</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17905</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.649652</td>\n",
+       "      <td>0.419057</td>\n",
+       "      <td>0.008783</td>\n",
+       "      <td>0.999983</td>\n",
+       "      <td>0.617577</td>\n",
+       "      <td>0.503514</td>\n",
+       "      <td>0.158545</td>\n",
+       "      <td>0.999529</td>\n",
+       "      <td>0.631972</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.061176</td>\n",
+       "      <td>0.980431</td>\n",
+       "      <td>0.704606</td>\n",
+       "      <td>0.880248</td>\n",
+       "      <td>0.071476</td>\n",
+       "      <td>0.979932</td>\n",
+       "      <td>0.504513</td>\n",
+       "      <td>0.881766</td>\n",
+       "      <td>-0.088832</td>\n",
+       "      <td>0.986975</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17906</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.653556</td>\n",
+       "      <td>0.400394</td>\n",
+       "      <td>0.014852</td>\n",
+       "      <td>0.999980</td>\n",
+       "      <td>0.620734</td>\n",
+       "      <td>0.486522</td>\n",
+       "      <td>0.169807</td>\n",
+       "      <td>0.999556</td>\n",
+       "      <td>0.631171</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.138678</td>\n",
+       "      <td>0.979078</td>\n",
+       "      <td>0.705475</td>\n",
+       "      <td>0.878981</td>\n",
+       "      <td>0.003690</td>\n",
+       "      <td>0.979199</td>\n",
+       "      <td>0.504067</td>\n",
+       "      <td>0.882642</td>\n",
+       "      <td>-0.183304</td>\n",
+       "      <td>0.986824</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3 rows × 53 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      label    nose_x    nose_y    nose_z    nose_v  left_shoulder_x  \\\n",
+       "17904     1  0.647438  0.442268  0.004114  0.999985         0.615798   \n",
+       "17905     1  0.649652  0.419057  0.008783  0.999983         0.617577   \n",
+       "17906     1  0.653556  0.400394  0.014852  0.999980         0.620734   \n",
+       "\n",
+       "       left_shoulder_y  left_shoulder_z  left_shoulder_v  right_shoulder_x  \\\n",
+       "17904         0.517170         0.151706         0.999579          0.631354   \n",
+       "17905         0.503514         0.158545         0.999529          0.631972   \n",
+       "17906         0.486522         0.169807         0.999556          0.631171   \n",
+       "\n",
+       "       ...  right_heel_z  right_heel_v  left_foot_index_x  left_foot_index_y  \\\n",
+       "17904  ...     -0.034228      0.979719           0.701826           0.880516   \n",
+       "17905  ...     -0.061176      0.980431           0.704606           0.880248   \n",
+       "17906  ...     -0.138678      0.979078           0.705475           0.878981   \n",
+       "\n",
+       "       left_foot_index_z  left_foot_index_v  right_foot_index_x  \\\n",
+       "17904           0.134222           0.979319            0.504880   \n",
+       "17905           0.071476           0.979932            0.504513   \n",
+       "17906           0.003690           0.979199            0.504067   \n",
+       "\n",
+       "       right_foot_index_y  right_foot_index_z  right_foot_index_v  \n",
+       "17904            0.881748           -0.027911            0.986165  \n",
+       "17905            0.881766           -0.088832            0.986975  \n",
+       "17906            0.882642           -0.183304            0.986824  \n",
+       "\n",
+       "[3 rows x 53 columns]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = describe_dataset(TRAIN_SET_PATH)\n",
+    "# Categorizing label\n",
+    "df.loc[df[\"label\"] == \"L\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"C\", \"label\"] = 1\n",
+    "\n",
+    "df.tail(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    sc = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract features and class\n",
+    "X = df.drop(\"label\", axis=1)\n",
+    "y = df[\"label\"].astype(\"int\")\n",
+    "\n",
+    "X = pd.DataFrame(sc.transform(X))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10827    0\n",
+       "11395    0\n",
+       "3742     1\n",
+       "Name: label, dtype: int64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)\n",
+    "y_test.head(3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Train & Evaluate Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Train and evaluate model with train set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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>Accuracy score</th>\n",
+       "      <th>Recall 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>SVC</td>\n",
+       "      <td>[1.0, 0.999]</td>\n",
+       "      <td>0.999721</td>\n",
+       "      <td>[0.999, 1.0]</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[[1713, 1], [0, 1868]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>[1.0, 0.998]</td>\n",
+       "      <td>0.999162</td>\n",
+       "      <td>[0.998, 1.0]</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>[[1711, 3], [0, 1868]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>0.999162</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>[0.999, 0.999]</td>\n",
+       "      <td>[[1712, 2], [1, 1867]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>[0.997, 0.997]</td>\n",
+       "      <td>0.997208</td>\n",
+       "      <td>[0.997, 0.997]</td>\n",
+       "      <td>[0.997, 0.997]</td>\n",
+       "      <td>[[1709, 5], [5, 1863]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>[0.992, 0.987]</td>\n",
+       "      <td>0.989391</td>\n",
+       "      <td>[0.986, 0.993]</td>\n",
+       "      <td>[0.989, 0.99]</td>\n",
+       "      <td>[[1690, 24], [14, 1854]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>[0.992, 0.988]</td>\n",
+       "      <td>0.989950</td>\n",
+       "      <td>[0.987, 0.993]</td>\n",
+       "      <td>[0.989, 0.99]</td>\n",
+       "      <td>[[1692, 22], [14, 1854]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>[0.963, 0.952]</td>\n",
+       "      <td>0.957286</td>\n",
+       "      <td>[0.947, 0.967]</td>\n",
+       "      <td>[0.955, 0.959]</td>\n",
+       "      <td>[[1623, 91], [62, 1806]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model Precision Score  Accuracy score    Recall Score        F1 score  \\\n",
+       "0   SVC    [1.0, 0.999]        0.999721    [0.999, 1.0]      [1.0, 1.0]   \n",
+       "1   KNN    [1.0, 0.998]        0.999162    [0.998, 1.0]  [0.999, 0.999]   \n",
+       "2    RF  [0.999, 0.999]        0.999162  [0.999, 0.999]  [0.999, 0.999]   \n",
+       "3   DTC  [0.997, 0.997]        0.997208  [0.997, 0.997]  [0.997, 0.997]   \n",
+       "4    LR  [0.992, 0.987]        0.989391  [0.986, 0.993]   [0.989, 0.99]   \n",
+       "5  SGDC  [0.992, 0.988]        0.989950  [0.987, 0.993]   [0.989, 0.99]   \n",
+       "6    NB  [0.963, 0.952]        0.957286  [0.947, 0.967]  [0.955, 0.959]   \n",
+       "\n",
+       "           Confusion Matrix  \n",
+       "0    [[1713, 1], [0, 1868]]  \n",
+       "1    [[1711, 3], [0, 1868]]  \n",
+       "2    [[1712, 2], [1, 1867]]  \n",
+       "3    [[1709, 5], [5, 1863]]  \n",
+       "4  [[1690, 24], [14, 1854]]  \n",
+       "5  [[1692, 22], [14, 1854]]  \n",
+       "6  [[1623, 91], [62, 1806]]  "
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "algorithms =[(\"LR\", LogisticRegression()),\n",
+    "         (\"SVC\", SVC(probability=True)),\n",
+    "         ('KNN',KNeighborsClassifier()),\n",
+    "         (\"DTC\", DecisionTreeClassifier()),\n",
+    "         (\"SGDC\", CalibratedClassifierCV(SGDClassifier())),\n",
+    "         (\"NB\", GaussianNB()),\n",
+    "         ('RF', RandomForestClassifier()),]\n",
+    "\n",
+    "models = {}\n",
+    "final_results = []\n",
+    "\n",
+    "for name, model in algorithms:\n",
+    "    trained_model = model.fit(X_train, y_train)\n",
+    "    models[name] = trained_model\n",
+    "\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(X_test)\n",
+    "\n",
+    "    p_score = precision_score(y_test, model_results, average=None, labels=[1, 0])\n",
+    "    a_score = accuracy_score(y_test, model_results)\n",
+    "    r_score = recall_score(y_test, model_results, average=None, labels=[1, 0])\n",
+    "    f1_score_result = f1_score(y_test, model_results, average=None, labels=[1, 0])\n",
+    "    cm = confusion_matrix(y_test, model_results, labels=[1, 0])\n",
+    "    final_results.append(( name,  round_up_metric_results(p_score), a_score, round_up_metric_results(r_score), round_up_metric_results(f1_score_result), cm))\n",
+    "\n",
+    "# Sort results by F1 score\n",
+    "final_results.sort(key=lambda k: sum(k[4]), reverse=True)\n",
+    "pd.DataFrame(final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. Test set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 1107 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    561\n",
+      "C    546\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(TEST_SET_PATH)\n",
+    "test_df = test_df.sample(frac=1).reset_index(drop=True)\n",
+    "\n",
+    "# Categorizing label\n",
+    "test_df.loc[test_df[\"label\"] == \"L\", \"label\"] = 0\n",
+    "test_df.loc[test_df[\"label\"] == \"C\", \"label\"] = 1\n",
+    "\n",
+    "test_x = test_df.drop(\"label\", axis=1)\n",
+    "test_y = test_df[\"label\"].astype(\"int\")\n",
+    "\n",
+    "test_x = pd.DataFrame(sc.transform(test_x))"
+   ]
+  },
+  {
+   "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>Accuracy score</th>\n",
+       "      <th>Recall 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.948, 0.998]</td>\n",
+       "      <td>0.971996</td>\n",
+       "      <td>[0.998, 0.947]</td>\n",
+       "      <td>[0.972, 0.972]</td>\n",
+       "      <td>[[545, 1], [30, 531]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>[0.922, 0.998]</td>\n",
+       "      <td>0.957543</td>\n",
+       "      <td>[0.998, 0.918]</td>\n",
+       "      <td>[0.959, 0.956]</td>\n",
+       "      <td>[[545, 1], [46, 515]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>[0.95, 0.889]</td>\n",
+       "      <td>0.916893</td>\n",
+       "      <td>[0.877, 0.955]</td>\n",
+       "      <td>[0.912, 0.921]</td>\n",
+       "      <td>[[479, 67], [25, 536]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>[0.786, 0.921]</td>\n",
+       "      <td>0.841915</td>\n",
+       "      <td>[0.934, 0.752]</td>\n",
+       "      <td>[0.854, 0.828]</td>\n",
+       "      <td>[[510, 36], [139, 422]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>[0.79, 0.751]</td>\n",
+       "      <td>0.768744</td>\n",
+       "      <td>[0.723, 0.813]</td>\n",
+       "      <td>[0.755, 0.781]</td>\n",
+       "      <td>[[395, 151], [105, 456]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>[0.737, 0.799]</td>\n",
+       "      <td>0.765131</td>\n",
+       "      <td>[0.815, 0.717]</td>\n",
+       "      <td>[0.774, 0.756]</td>\n",
+       "      <td>[[445, 101], [159, 402]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>[0.659, 0.842]</td>\n",
+       "      <td>0.719964</td>\n",
+       "      <td>[0.894, 0.551]</td>\n",
+       "      <td>[0.759, 0.666]</td>\n",
+       "      <td>[[488, 58], [252, 309]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model Precision Score  Accuracy score    Recall Score        F1 score  \\\n",
+       "0    LR  [0.948, 0.998]        0.971996  [0.998, 0.947]  [0.972, 0.972]   \n",
+       "1  SGDC  [0.922, 0.998]        0.957543  [0.998, 0.918]  [0.959, 0.956]   \n",
+       "2   DTC   [0.95, 0.889]        0.916893  [0.877, 0.955]  [0.912, 0.921]   \n",
+       "3    RF  [0.786, 0.921]        0.841915  [0.934, 0.752]  [0.854, 0.828]   \n",
+       "4    NB   [0.79, 0.751]        0.768744  [0.723, 0.813]  [0.755, 0.781]   \n",
+       "5   KNN  [0.737, 0.799]        0.765131  [0.815, 0.717]  [0.774, 0.756]   \n",
+       "6   SVC  [0.659, 0.842]        0.719964  [0.894, 0.551]  [0.759, 0.666]   \n",
+       "\n",
+       "           Confusion Matrix  \n",
+       "0     [[545, 1], [30, 531]]  \n",
+       "1     [[545, 1], [46, 515]]  \n",
+       "2    [[479, 67], [25, 536]]  \n",
+       "3   [[510, 36], [139, 422]]  \n",
+       "4  [[395, 151], [105, 456]]  \n",
+       "5  [[445, 101], [159, 402]]  \n",
+       "6   [[488, 58], [252, 309]]  "
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "testset_final_results = []\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(test_x)\n",
+    "\n",
+    "    p_score = precision_score(test_y, model_results, average=None, labels=[1, 0])\n",
+    "    a_score = accuracy_score(test_y, model_results)\n",
+    "    r_score = recall_score(test_y, model_results, average=None, labels=[1, 0])\n",
+    "    f1_score_result = f1_score(test_y, model_results, average=None, labels=[1, 0])\n",
+    "    cm = confusion_matrix(test_y, model_results, labels=[1, 0])\n",
+    "    testset_final_results.append(( name,  round_up_metric_results(p_score), a_score, round_up_metric_results(r_score), round_up_metric_results(f1_score_result), cm ))\n",
+    "\n",
+    "\n",
+    "testset_final_results.sort(key=lambda k: sum(k[4]), reverse=True)\n",
+    "pd.DataFrame(testset_final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Dump Models \n",
+    "\n",
+    "According to the evaluation above, LR and KNN SGDC would be chosen for more eval."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/err_all_sklearn.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models, f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/err_SGDC_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"SGDC\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/sklearn/err_LR_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"LR\"], f)"
+   ]
+  },
+  {
+   "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
+}

core/lunge_model/7.err.deep_learning.ipynb

@@ -0,0 +1,1366 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data visualization\n",
+    "import numpy as np\n",
+    "import pandas as pd \n",
+    "\n",
+    "# Keras\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense\n",
+    "from keras.layers import Dropout\n",
+    "from keras.optimizers import Adam\n",
+    "from keras.utils.np_utils import to_categorical\n",
+    "from keras.callbacks import EarlyStopping\n",
+    "import keras_tuner as kt\n",
+    "\n",
+    "# Train-Test\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "# Classification Report\n",
+    "from sklearn.metrics import confusion_matrix, precision_recall_fscore_support\n",
+    "\n",
+    "import pickle\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Set up important landmarks and functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for lunge\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]\n",
+    "\n",
+    "TRAIN_SET_PATH  = \"./err.train.csv\"\n",
+    "TEST_SET_PATH  = \"./err.test.csv\""
+   ]
+  },
+  {
+   "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",
+    "# Remove duplicate rows (optional)\n",
+    "def remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_dataset.csv\", sep=',', encoding='utf-8', index=False)\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. Describe and process data"
+   ]
+  },
+  {
+   "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', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 17907 \n",
+      "Number of columns: 53\n",
+      "\n",
+      "Labels: \n",
+      "L    9114\n",
+      "C    8793\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "df = describe_dataset(TRAIN_SET_PATH)\n",
+    "\n",
+    "# Categorizing label\n",
+    "df.loc[df[\"label\"] == \"L\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"C\", \"label\"] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f2:\n",
+    "    input_scaler = pickle.load(f2)\n",
+    "\n",
+    "x = df.drop(\"label\", axis = 1)\n",
+    "x = pd.DataFrame(input_scaler.transform(x))\n",
+    "\n",
+    "y = df[\"label\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "y_cat = to_categorical(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(x.values, y_cat, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Train model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Set up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stop_early = EarlyStopping(monitor='loss', patience=3)\n",
+    "\n",
+    "# Final Results\n",
+    "final_models = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def describe_model(model):\n",
+    "    '''\n",
+    "    Describe Model architecture\n",
+    "    '''\n",
+    "    print(f\"Describe models architecture\")\n",
+    "    for i, layer in enumerate(model.layers):\n",
+    "        number_of_units = layer.units if hasattr(layer, 'units') else 0\n",
+    "\n",
+    "        if hasattr(layer, \"activation\"):\n",
+    "            print(f\"Layer-{i + 1}: {number_of_units} units, func: \", layer.activation)\n",
+    "        else:\n",
+    "            print(f\"Layer-{i + 1}: {number_of_units} units, func: None\")\n",
+    "            \n",
+    "\n",
+    "def get_best_model(tuner):\n",
+    "    '''\n",
+    "    Describe and return the best model found from keras tuner\n",
+    "    '''\n",
+    "    best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
+    "    best_model = tuner.hypermodel.build(best_hps)\n",
+    "\n",
+    "    describe_model(best_model)\n",
+    "\n",
+    "    for h_param in [\"learning_rate\"]:\n",
+    "        print(f\"{h_param}: {tuner.get_best_hyperparameters()[0].get(h_param)}\")\n",
+    "    \n",
+    "    return best_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. Model with 3 layers "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_builder(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(52, input_dim = 52, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation='softmax'))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Reloading Oracle from existing project keras_tuner_dir/keras_tuner_demo/oracle.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner = kt.Hyperband(\n",
+    "    model_builder,\n",
+    "    objective='accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 38s]\n",
+      "accuracy: 0.9995812177658081\n",
+      "\n",
+      "Best accuracy So Far: 1.0000001192092896\n",
+      "Total elapsed time: 00h 08m 17s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner.search(x_train, y_train, epochs=10, callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-2: 192 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-3: 2 units, func:  <function softmax at 0x155f86040>\n",
+      "learning_rate: 0.001\n",
+      "Epoch 1/100\n",
+      "  12/1433 [..............................] - ETA: 13s - loss: 0.5386 - accuracy: 0.7000"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 10:49:54.623575: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1429/1433 [============================>.] - ETA: 0s - loss: 0.0323 - accuracy: 0.9883"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 10:50:06.095468: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - 14s 9ms/step - loss: 0.0322 - accuracy: 0.9883 - val_loss: 0.0022 - val_accuracy: 0.9992\n",
+      "Epoch 2/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 0.0048 - accuracy: 0.9984 - val_loss: 0.0103 - val_accuracy: 0.9964\n",
+      "Epoch 3/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 0.0044 - accuracy: 0.9986 - val_loss: 0.0018 - val_accuracy: 0.9994\n",
+      "Epoch 4/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0024 - accuracy: 0.9992 - val_loss: 8.9034e-04 - val_accuracy: 0.9997\n",
+      "Epoch 5/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0026 - accuracy: 0.9991 - val_loss: 6.6072e-04 - val_accuracy: 0.9997\n",
+      "Epoch 6/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0016 - accuracy: 0.9995 - val_loss: 0.0011 - val_accuracy: 0.9997\n",
+      "Epoch 7/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0029 - accuracy: 0.9994 - val_loss: 0.0013 - val_accuracy: 0.9997\n",
+      "Epoch 8/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0012 - accuracy: 0.9996 - val_loss: 6.2126e-04 - val_accuracy: 0.9997\n",
+      "Epoch 9/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0014 - accuracy: 0.9995 - val_loss: 3.3005e-04 - val_accuracy: 0.9997\n",
+      "Epoch 10/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0020 - accuracy: 0.9993 - val_loss: 3.4855e-04 - val_accuracy: 0.9997\n",
+      "Epoch 11/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 4.9058e-04 - accuracy: 0.9999 - val_loss: 7.0838e-04 - val_accuracy: 0.9997\n",
+      "Epoch 12/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 3.1028e-05 - accuracy: 1.0000 - val_loss: 9.7843e-05 - val_accuracy: 1.0000\n",
+      "Epoch 13/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 0.0023 - accuracy: 0.9994 - val_loss: 0.0037 - val_accuracy: 0.9986\n",
+      "Epoch 14/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 6.7057e-04 - accuracy: 0.9998 - val_loss: 4.5239e-04 - val_accuracy: 0.9997\n",
+      "Epoch 15/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 3.3223e-05 - accuracy: 1.0000 - val_loss: 3.2696e-04 - val_accuracy: 0.9997\n",
+      "Epoch 16/100\n",
+      "1433/1433 [==============================] - 13s 9ms/step - loss: 0.0035 - accuracy: 0.9992 - val_loss: 1.6425e-04 - val_accuracy: 1.0000\n",
+      "Epoch 17/100\n",
+      "1433/1433 [==============================] - 14s 10ms/step - loss: 0.0015 - accuracy: 0.9995 - val_loss: 0.0011 - val_accuracy: 0.9997\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x159960100>"
+      ]
+     },
+     "execution_count": 102,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = get_best_model(tuner)\n",
+    "model.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"3_layers\"] = model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3. Model with 5 layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_builder_5(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(52, input_dim = 52, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation='softmax'))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 44s]\n",
+      "accuracy: 0.9998604655265808\n",
+      "\n",
+      "Best accuracy So Far: 1.0000001192092896\n",
+      "Total elapsed time: 00h 08m 57s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner = kt.Hyperband(\n",
+    "    model_builder_5,\n",
+    "    objective='accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_2'\n",
+    ")\n",
+    "tuner.search(x_train, y_train, epochs=10, callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-2: 480 units, func:  <function tanh at 0x155f86dc0>\n",
+      "Layer-3: 480 units, func:  <function tanh at 0x155f86dc0>\n",
+      "Layer-4: 192 units, func:  <function tanh at 0x155f86dc0>\n",
+      "Layer-5: 2 units, func:  <function softmax at 0x155f86040>\n",
+      "learning_rate: 0.0001\n",
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 11:11:48.332514: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - ETA: 0s - loss: 0.0428 - accuracy: 0.9872"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 11:12:02.217934: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0428 - accuracy: 0.9872 - val_loss: 0.0248 - val_accuracy: 0.9913\n",
+      "Epoch 2/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0055 - accuracy: 0.9986 - val_loss: 0.0016 - val_accuracy: 0.9992\n",
+      "Epoch 3/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0052 - accuracy: 0.9988 - val_loss: 0.0036 - val_accuracy: 0.9992\n",
+      "Epoch 4/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0024 - accuracy: 0.9994 - val_loss: 0.0017 - val_accuracy: 0.9997\n",
+      "Epoch 5/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0048 - accuracy: 0.9982 - val_loss: 0.0019 - val_accuracy: 0.9994\n",
+      "Epoch 6/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0018 - accuracy: 0.9994 - val_loss: 8.5989e-04 - val_accuracy: 0.9997\n",
+      "Epoch 7/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0023 - accuracy: 0.9994 - val_loss: 4.7530e-04 - val_accuracy: 0.9997\n",
+      "Epoch 8/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0022 - accuracy: 0.9991 - val_loss: 3.3401e-04 - val_accuracy: 0.9997\n",
+      "Epoch 9/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0018 - accuracy: 0.9993 - val_loss: 3.5316e-04 - val_accuracy: 0.9997\n",
+      "Epoch 10/100\n",
+      "1433/1433 [==============================] - 18s 13ms/step - loss: 0.0010 - accuracy: 0.9997 - val_loss: 5.9313e-04 - val_accuracy: 0.9997\n",
+      "Epoch 11/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 0.0017 - accuracy: 0.9995 - val_loss: 5.0026e-04 - val_accuracy: 0.9997\n",
+      "Epoch 12/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0016 - accuracy: 0.9994 - val_loss: 2.7773e-04 - val_accuracy: 0.9997\n",
+      "Epoch 13/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 3.9777e-04 - accuracy: 0.9999 - val_loss: 2.6341e-04 - val_accuracy: 0.9997\n",
+      "Epoch 14/100\n",
+      "1433/1433 [==============================] - 18s 12ms/step - loss: 0.0021 - accuracy: 0.9997 - val_loss: 3.1135e-04 - val_accuracy: 1.0000\n",
+      "Epoch 15/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 2.4923e-04 - accuracy: 0.9999 - val_loss: 3.7806e-04 - val_accuracy: 0.9997\n",
+      "Epoch 16/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 4.5137e-04 - accuracy: 0.9999 - val_loss: 1.0070e-04 - val_accuracy: 1.0000\n",
+      "Epoch 17/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 8.3379e-06 - accuracy: 1.0000 - val_loss: 6.9653e-04 - val_accuracy: 0.9997\n",
+      "Epoch 18/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0018 - accuracy: 0.9994 - val_loss: 1.4246e-04 - val_accuracy: 1.0000\n",
+      "Epoch 19/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 2.8542e-05 - accuracy: 1.0000 - val_loss: 1.0260e-04 - val_accuracy: 1.0000\n",
+      "Epoch 20/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0016 - accuracy: 0.9994 - val_loss: 2.7252e-04 - val_accuracy: 1.0000\n",
+      "Epoch 21/100\n",
+      "1433/1433 [==============================] - 16s 11ms/step - loss: 3.2176e-05 - accuracy: 1.0000 - val_loss: 1.3285e-04 - val_accuracy: 1.0000\n",
+      "Epoch 22/100\n",
+      "1433/1433 [==============================] - 18s 12ms/step - loss: 1.2290e-05 - accuracy: 1.0000 - val_loss: 1.1766e-04 - val_accuracy: 1.0000\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x2f26db9d0>"
+      ]
+     },
+     "execution_count": 111,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_5 = get_best_model(tuner)\n",
+    "model_5.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"5_layers\"] = model_5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4. Model with 7 layers along with Dropout layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_builder_dropout_5(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(52, input_dim = 52, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dropout(0.5))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dropout(0.5))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation='softmax'))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 53s]\n",
+      "accuracy: 0.9993019700050354\n",
+      "\n",
+      "Best accuracy So Far: 0.9997208118438721\n",
+      "Total elapsed time: 00h 11m 19s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner = kt.Hyperband(\n",
+    "    model_builder_dropout_5,\n",
+    "    objective='accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_3'\n",
+    ")\n",
+    "tuner.search(x_train, y_train, epochs=10, callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-2: 288 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-3: 0 units, func: None\n",
+      "Layer-4: 224 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-5: 0 units, func: None\n",
+      "Layer-6: 320 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x155f86040>\n",
+      "learning_rate: 0.001\n",
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 11:34:38.687622: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - ETA: 0s - loss: 0.0443 - accuracy: 0.9823"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 11:34:54.587049: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - 19s 13ms/step - loss: 0.0443 - accuracy: 0.9823 - val_loss: 0.0023 - val_accuracy: 0.9994\n",
+      "Epoch 2/100\n",
+      "1433/1433 [==============================] - 18s 12ms/step - loss: 0.0090 - accuracy: 0.9976 - val_loss: 0.0046 - val_accuracy: 0.9975\n",
+      "Epoch 3/100\n",
+      "1433/1433 [==============================] - 18s 13ms/step - loss: 0.0048 - accuracy: 0.9988 - val_loss: 0.0011 - val_accuracy: 0.9994\n",
+      "Epoch 4/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0073 - accuracy: 0.9983 - val_loss: 0.0015 - val_accuracy: 0.9994\n",
+      "Epoch 5/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0041 - accuracy: 0.9987 - val_loss: 8.3813e-04 - val_accuracy: 0.9997\n",
+      "Epoch 6/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0053 - accuracy: 0.9987 - val_loss: 0.0047 - val_accuracy: 0.9986\n",
+      "Epoch 7/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0044 - accuracy: 0.9984 - val_loss: 9.9630e-04 - val_accuracy: 0.9997\n",
+      "Epoch 8/100\n",
+      "1433/1433 [==============================] - 18s 13ms/step - loss: 0.0025 - accuracy: 0.9994 - val_loss: 0.0013 - val_accuracy: 0.9994\n",
+      "Epoch 9/100\n",
+      "1433/1433 [==============================] - 18s 13ms/step - loss: 0.0025 - accuracy: 0.9993 - val_loss: 0.0074 - val_accuracy: 0.9989\n",
+      "Epoch 10/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0019 - accuracy: 0.9998 - val_loss: 0.0018 - val_accuracy: 0.9997\n",
+      "Epoch 11/100\n",
+      "1433/1433 [==============================] - 18s 12ms/step - loss: 0.0038 - accuracy: 0.9994 - val_loss: 3.8607e-04 - val_accuracy: 0.9997\n",
+      "Epoch 12/100\n",
+      "1433/1433 [==============================] - 17s 12ms/step - loss: 0.0031 - accuracy: 0.9992 - val_loss: 0.0011 - val_accuracy: 0.9994\n",
+      "Epoch 13/100\n",
+      "1433/1433 [==============================] - 18s 12ms/step - loss: 0.0048 - accuracy: 0.9990 - val_loss: 1.1490e-04 - val_accuracy: 1.0000\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x2f45e9280>"
+      ]
+     },
+     "execution_count": 117,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_5_with_dropout = get_best_model(tuner)\n",
+    "model_5_with_dropout.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['7_layers_with_dropout', '5_layers', '3_layers'])"
+      ]
+     },
+     "execution_count": 126,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "final_models[\"7_layers_with_dropout\"] = model_5_with_dropout"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.5. Model with 7 layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model_builder_7(hp):\n",
+    "    model = Sequential()\n",
+    "    model.add(Dense(52, input_dim = 52, activation = \"relu\"))\n",
+    "\n",
+    "    hp_activation = hp.Choice('activation', values=['relu', 'tanh'])\n",
+    "    hp_layer_1 = hp.Int('layer_1', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_2 = hp.Int('layer_2', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_3 = hp.Int('layer_3', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_4 = hp.Int('layer_4', min_value=32, max_value=512, step=32)\n",
+    "    hp_layer_5 = hp.Int('layer_5', min_value=32, max_value=512, step=32)\n",
+    "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
+    "\n",
+    "    model.add(Dense(units=hp_layer_1, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_2, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_3, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_4, activation=hp_activation))\n",
+    "    model.add(Dense(units=hp_layer_5, activation=hp_activation))\n",
+    "    model.add(Dense(2, activation='softmax'))\n",
+    "\n",
+    "    model.compile(optimizer=Adam(learning_rate=hp_learning_rate), loss=\"categorical_crossentropy\", metrics = [\"accuracy\"])\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trial 30 Complete [00h 00m 52s]\n",
+      "accuracy: 0.9996510148048401\n",
+      "\n",
+      "Best accuracy So Far: 1.0000001192092896\n",
+      "Total elapsed time: 00h 12m 14s\n",
+      "INFO:tensorflow:Oracle triggered exit\n"
+     ]
+    }
+   ],
+   "source": [
+    "tuner = kt.Hyperband(\n",
+    "    model_builder_7,\n",
+    "    objective='accuracy',\n",
+    "    max_epochs=10,\n",
+    "    directory='keras_tuner_dir',\n",
+    "    project_name='keras_tuner_demo_4'\n",
+    ")\n",
+    "tuner.search(x_train, y_train, epochs=10, callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-2: 32 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-3: 416 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-4: 192 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-5: 224 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-6: 416 units, func:  <function relu at 0x155f86a60>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x155f86040>\n",
+      "learning_rate: 0.0001\n",
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 13:44:16.853169: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - ETA: 0s - loss: 0.0618 - accuracy: 0.9774"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 13:44:35.283222: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1433/1433 [==============================] - 22s 15ms/step - loss: 0.0618 - accuracy: 0.9774 - val_loss: 0.0034 - val_accuracy: 0.9986\n",
+      "Epoch 2/100\n",
+      "1433/1433 [==============================] - 22s 15ms/step - loss: 0.0059 - accuracy: 0.9985 - val_loss: 0.0092 - val_accuracy: 0.9969\n",
+      "Epoch 3/100\n",
+      "1433/1433 [==============================] - 22s 15ms/step - loss: 0.0052 - accuracy: 0.9984 - val_loss: 0.0018 - val_accuracy: 0.9997\n",
+      "Epoch 4/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0028 - accuracy: 0.9993 - val_loss: 0.0017 - val_accuracy: 0.9992\n",
+      "Epoch 5/100\n",
+      "1433/1433 [==============================] - 21s 14ms/step - loss: 0.0031 - accuracy: 0.9992 - val_loss: 3.8267e-04 - val_accuracy: 1.0000\n",
+      "Epoch 6/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0030 - accuracy: 0.9994 - val_loss: 2.8054e-04 - val_accuracy: 1.0000\n",
+      "Epoch 7/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0022 - accuracy: 0.9995 - val_loss: 0.0038 - val_accuracy: 0.9983\n",
+      "Epoch 8/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0013 - accuracy: 0.9995 - val_loss: 1.5269e-04 - val_accuracy: 1.0000\n",
+      "Epoch 9/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0014 - accuracy: 0.9998 - val_loss: 4.1306e-04 - val_accuracy: 0.9997\n",
+      "Epoch 10/100\n",
+      "1433/1433 [==============================] - 21s 14ms/step - loss: 2.9369e-04 - accuracy: 0.9999 - val_loss: 1.3631e-05 - val_accuracy: 1.0000\n",
+      "Epoch 11/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 1.4331e-05 - accuracy: 1.0000 - val_loss: 6.5710e-06 - val_accuracy: 1.0000\n",
+      "Epoch 12/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0015 - accuracy: 0.9995 - val_loss: 1.8750e-04 - val_accuracy: 1.0000\n",
+      "Epoch 13/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 3.1710e-04 - accuracy: 0.9998 - val_loss: 4.7737e-05 - val_accuracy: 1.0000\n",
+      "Epoch 14/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 1.3424e-05 - accuracy: 1.0000 - val_loss: 1.4000e-05 - val_accuracy: 1.0000\n",
+      "Epoch 15/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 3.3917e-06 - accuracy: 1.0000 - val_loss: 1.4799e-05 - val_accuracy: 1.0000\n",
+      "Epoch 16/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 1.1946e-06 - accuracy: 1.0000 - val_loss: 7.0157e-06 - val_accuracy: 1.0000\n",
+      "Epoch 17/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 6.1554e-07 - accuracy: 1.0000 - val_loss: 2.0066e-05 - val_accuracy: 1.0000\n",
+      "Epoch 18/100\n",
+      "1433/1433 [==============================] - 21s 14ms/step - loss: 2.6470e-07 - accuracy: 1.0000 - val_loss: 5.7550e-05 - val_accuracy: 1.0000\n",
+      "Epoch 19/100\n",
+      "1433/1433 [==============================] - 21s 14ms/step - loss: 1.2669e-07 - accuracy: 1.0000 - val_loss: 4.0596e-06 - val_accuracy: 1.0000\n",
+      "Epoch 20/100\n",
+      "1433/1433 [==============================] - 22s 16ms/step - loss: 6.8169e-08 - accuracy: 1.0000 - val_loss: 1.9726e-05 - val_accuracy: 1.0000\n",
+      "Epoch 21/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 4.3585e-08 - accuracy: 1.0000 - val_loss: 9.4645e-05 - val_accuracy: 1.0000\n",
+      "Epoch 22/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 0.0042 - accuracy: 0.9994 - val_loss: 0.0031 - val_accuracy: 0.9992\n",
+      "Epoch 23/100\n",
+      "1433/1433 [==============================] - 21s 14ms/step - loss: 0.0024 - accuracy: 0.9994 - val_loss: 2.0752e-05 - val_accuracy: 1.0000\n",
+      "Epoch 24/100\n",
+      "1433/1433 [==============================] - 21s 15ms/step - loss: 1.0676e-04 - accuracy: 0.9999 - val_loss: 1.2278e-05 - val_accuracy: 1.0000\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.callbacks.History at 0x326e838b0>"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_7 = get_best_model(tuner)\n",
+    "model_7.fit(x_train, y_train, epochs=100, batch_size=10, validation_data=(x_test, y_test), callbacks=[stop_early])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "final_models[\"7_layers\"] = model_7"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.6. Final Models Description"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7_layers_with_dropout: Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-2: 288 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-3: 0 units, func: None\n",
+      "Layer-4: 224 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-5: 0 units, func: None\n",
+      "Layer-6: 320 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x15db71160>\n",
+      "\n",
+      "5_layers: Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-2: 480 units, func:  <function tanh at 0x15db71ee0>\n",
+      "Layer-3: 480 units, func:  <function tanh at 0x15db71ee0>\n",
+      "Layer-4: 192 units, func:  <function tanh at 0x15db71ee0>\n",
+      "Layer-5: 2 units, func:  <function softmax at 0x15db71160>\n",
+      "\n",
+      "3_layers: Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-2: 192 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-3: 2 units, func:  <function softmax at 0x15db71160>\n",
+      "\n",
+      "7_layers: Describe models architecture\n",
+      "Layer-1: 52 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-2: 32 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-3: 416 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-4: 192 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-5: 224 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-6: 416 units, func:  <function relu at 0x15db71b80>\n",
+      "Layer-7: 2 units, func:  <function softmax at 0x15db71160>\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for name, model in final_models.items():\n",
+    "    print(f\"{name}: \", end=\"\")\n",
+    "    describe_model(model)\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Model Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1. Train set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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>F1 score</th>\n",
+       "      <th>Confusion Matrix</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>7_layers_with_dropout</td>\n",
+       "      <td>[1.0, 0.999]</td>\n",
+       "      <td>[0.999, 1.0]</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[[1805, 1], [0, 1776]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>3_layers</td>\n",
+       "      <td>[1.0, 0.999]</td>\n",
+       "      <td>[0.999, 1.0]</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[[1805, 1], [0, 1776]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[1.0, 1.0]</td>\n",
+       "      <td>[[1806, 0], [0, 1776]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>[1.0, 0.994]</td>\n",
+       "      <td>[0.994, 1.0]</td>\n",
+       "      <td>[0.997, 0.997]</td>\n",
+       "      <td>[[1795, 11], [0, 1776]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Model Precision Score  Recall Score        F1 score  \\\n",
+       "0  7_layers_with_dropout    [1.0, 0.999]  [0.999, 1.0]      [1.0, 1.0]   \n",
+       "1               3_layers    [1.0, 0.999]  [0.999, 1.0]      [1.0, 1.0]   \n",
+       "2               7_layers      [1.0, 1.0]    [1.0, 1.0]      [1.0, 1.0]   \n",
+       "3               5_layers    [1.0, 0.994]  [0.994, 1.0]  [0.997, 0.997]   \n",
+       "\n",
+       "          Confusion Matrix  \n",
+       "0   [[1805, 1], [0, 1776]]  \n",
+       "1   [[1805, 1], [0, 1776]]  \n",
+       "2   [[1806, 0], [0, 1776]]  \n",
+       "3  [[1795, 11], [0, 1776]]  "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_set_results = []\n",
+    "\n",
+    "for name, model in final_models.items():\n",
+    "    # Evaluate model\n",
+    "    predict_x = model.predict(x_test, verbose=False) \n",
+    "    y_pred_class = np.argmax(predict_x, axis=1)\n",
+    "    y_test_class = np.argmax(y_test, axis=1)\n",
+    "\n",
+    "    cm = confusion_matrix(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    (p_score, r_score, f_score, _) = precision_recall_fscore_support(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    \n",
+    "    train_set_results.append(( name, round_up_metric_results(p_score), round_up_metric_results(r_score), round_up_metric_results(f_score), cm ))\n",
+    "\n",
+    "train_set_results.sort(key=lambda k: sum(k[3]), reverse=True)\n",
+    "pd.DataFrame(train_set_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2. Test set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_df = pd.read_csv(TEST_SET_PATH)\n",
+    "\n",
+    "# Categorizing label\n",
+    "test_df.loc[test_df[\"label\"] == \"L\", \"label\"] = 0\n",
+    "test_df.loc[test_df[\"label\"] == \"C\", \"label\"] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Standard Scaling of features\n",
+    "test_x = test_df.drop(\"label\", axis = 1)\n",
+    "test_x = pd.DataFrame(input_scaler.transform(test_x))\n",
+    "\n",
+    "test_y = test_df[\"label\"]\n",
+    "\n",
+    "# # Converting prediction to categorical\n",
+    "test_y_cat = to_categorical(test_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-25 15:46:42.537983: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:46:42.694947: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:46:42.853052: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
+      "2022-11-25 15:46:42.974234: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "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>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.998, 0.873]</td>\n",
+       "      <td>[0.859, 0.998]</td>\n",
+       "      <td>[0.923, 0.932]</td>\n",
+       "      <td>[[482, 79], [1, 545]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>7_layers_with_dropout</td>\n",
+       "      <td>[0.995, 0.786]</td>\n",
+       "      <td>[0.736, 0.996]</td>\n",
+       "      <td>[0.846, 0.879]</td>\n",
+       "      <td>[[413, 148], [2, 544]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>5_layers</td>\n",
+       "      <td>[0.963, 0.755]</td>\n",
+       "      <td>[0.693, 0.973]</td>\n",
+       "      <td>[0.806, 0.85]</td>\n",
+       "      <td>[[389, 172], [15, 531]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>7_layers</td>\n",
+       "      <td>[0.984, 0.687]</td>\n",
+       "      <td>[0.561, 0.991]</td>\n",
+       "      <td>[0.715, 0.812]</td>\n",
+       "      <td>[[315, 246], [5, 541]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Model Precision Score    Recall Score        F1 score  \\\n",
+       "0               3_layers  [0.998, 0.873]  [0.859, 0.998]  [0.923, 0.932]   \n",
+       "1  7_layers_with_dropout  [0.995, 0.786]  [0.736, 0.996]  [0.846, 0.879]   \n",
+       "2               5_layers  [0.963, 0.755]  [0.693, 0.973]   [0.806, 0.85]   \n",
+       "3               7_layers  [0.984, 0.687]  [0.561, 0.991]  [0.715, 0.812]   \n",
+       "\n",
+       "          Confusion Matrix  \n",
+       "0    [[482, 79], [1, 545]]  \n",
+       "1   [[413, 148], [2, 544]]  \n",
+       "2  [[389, 172], [15, 531]]  \n",
+       "3   [[315, 246], [5, 541]]  "
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_set_results = []\n",
+    "\n",
+    "for name, model in final_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, r_score, f_score, _) = precision_recall_fscore_support(y_test_class, y_pred_class, labels=[0, 1])\n",
+    "    \n",
+    "    test_set_results.append(( name, round_up_metric_results(p_score), round_up_metric_results(r_score), round_up_metric_results(f_score), cm ))\n",
+    "\n",
+    "test_set_results.sort(key=lambda k: sum(k[3]), reverse=True)\n",
+    "pd.DataFrame(test_set_results, columns=[\"Model\", \"Precision Score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Dump Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 173,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: ram://4444bb6e-de2c-4bed-806c-db9d955522ad/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Dump the best model to a pickle file\n",
+    "with open(\"./model/dp/err_lunge_dp.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(final_models[\"3_layers\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 174,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: ram://0f5761b9-5d62-4bf6-8de5-34355293f17a/assets\n",
+      "INFO:tensorflow:Assets written to: ram://ac2add31-fb1f-4baa-b925-718896fea315/assets\n",
+      "INFO:tensorflow:Assets written to: ram://20b6d7c9-7ddf-42a1-aaba-c31e12762a10/assets\n",
+      "INFO:tensorflow:Assets written to: ram://ee8c66ec-0ee3-4a5c-bc03-f12225018c47/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(\"./model/dp/all_models.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(final_models, f)"
+   ]
+  },
+  {
+   "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
+}

core/lunge_model/9.err.detection.ipynb

@@ -0,0 +1,714 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[21249]: 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 (0x111188860) 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[21249]: 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 (0x107550a68) 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[21249]: 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 (0x107550a90) 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[21249]: 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 (0x107550ab8) 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 cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "import pickle\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. Setup important landmarks and functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for lunge\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_important_keypoints(results) -> list:\n",
+    "    '''\n",
+    "    Extract important keypoints from mediapipe pose detection\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "\n",
+    "    data = []\n",
+    "    for lm in IMPORTANT_LMS:\n",
+    "        keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "        data.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "    \n",
+    "    return np.array(data).flatten().tolist()\n",
+    "\n",
+    "\n",
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation =cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "def calculate_angle(point1: list, point2: list, point3: list) -> float:\n",
+    "    '''\n",
+    "    Calculate the angle between 3 points\n",
+    "    Unit of the angle will be in Degree\n",
+    "    '''\n",
+    "    point1 = np.array(point1)\n",
+    "    point2 = np.array(point2)\n",
+    "    point3 = np.array(point3)\n",
+    "\n",
+    "    # Calculate algo\n",
+    "    angleInRad = np.arctan2(point3[1] - point2[1], point3[0] - point2[0]) - np.arctan2(point1[1] - point2[1], point1[0] - point2[0])\n",
+    "    angleInDeg = np.abs(angleInRad * 180.0 / np.pi)\n",
+    "\n",
+    "    angleInDeg = angleInDeg if angleInDeg <= 180 else 360 - angleInDeg\n",
+    "    return angleInDeg\n",
+    "    \n",
+    "\n",
+    "def analyze_knee_angle(\n",
+    "    mp_results, stage: str, angle_thresholds: list, draw_to_image: tuple = None\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Calculate angle of each knee while performer at the DOWN position\n",
+    "\n",
+    "    Return result explanation:\n",
+    "        error: True if at least 1 error\n",
+    "        right\n",
+    "            error: True if an error is on the right knee\n",
+    "            angle: Right knee angle\n",
+    "        left\n",
+    "            error: True if an error is on the left knee\n",
+    "            angle: Left knee angle\n",
+    "    \"\"\"\n",
+    "    results = {\n",
+    "        \"error\": None,\n",
+    "        \"right\": {\"error\": None, \"angle\": None},\n",
+    "        \"left\": {\"error\": None, \"angle\": None},\n",
+    "    }\n",
+    "\n",
+    "    landmarks = mp_results.pose_landmarks.landmark\n",
+    "\n",
+    "    # Calculate right knee angle\n",
+    "    right_hip = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y,\n",
+    "    ]\n",
+    "    right_knee = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y,\n",
+    "    ]\n",
+    "    right_ankle = [\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y,\n",
+    "    ]\n",
+    "    results[\"right\"][\"angle\"] = calculate_angle(right_hip, right_knee, right_ankle)\n",
+    "\n",
+    "    # Calculate left knee angle\n",
+    "    left_hip = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y,\n",
+    "    ]\n",
+    "    left_knee = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y,\n",
+    "    ]\n",
+    "    left_ankle = [\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x,\n",
+    "        landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y,\n",
+    "    ]\n",
+    "    results[\"left\"][\"angle\"] = calculate_angle(left_hip, left_knee, left_ankle)\n",
+    "\n",
+    "    # Draw to image\n",
+    "    if draw_to_image is not None and stage != \"down\":\n",
+    "        (image, video_dimensions) = draw_to_image\n",
+    "\n",
+    "        # Visualize angles\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"right\"][\"angle\"])),\n",
+    "            tuple(np.multiply(right_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            0.5,\n",
+    "            (255, 255, 255),\n",
+    "            1,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"left\"][\"angle\"])),\n",
+    "            tuple(np.multiply(left_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            0.5,\n",
+    "            (255, 255, 255),\n",
+    "            1,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "\n",
+    "    if stage != \"down\":\n",
+    "        return results\n",
+    "\n",
+    "    # Evaluation\n",
+    "    results[\"error\"] = False\n",
+    "\n",
+    "    if angle_thresholds[0] <= results[\"right\"][\"angle\"] <= angle_thresholds[1]:\n",
+    "        results[\"right\"][\"error\"] = False\n",
+    "    else:\n",
+    "        results[\"right\"][\"error\"] = True\n",
+    "        results[\"error\"] = True\n",
+    "\n",
+    "    if angle_thresholds[0] <= results[\"left\"][\"angle\"] <= angle_thresholds[1]:\n",
+    "        results[\"left\"][\"error\"] = False\n",
+    "    else:\n",
+    "        results[\"left\"][\"error\"] = True\n",
+    "        results[\"error\"] = True\n",
+    "\n",
+    "    # Draw to image\n",
+    "    if draw_to_image is not None:\n",
+    "        (image, video_dimensions) = draw_to_image\n",
+    "\n",
+    "        right_color = (255, 255, 255) if not results[\"right\"][\"error\"] else (0, 0, 255)\n",
+    "        left_color = (255, 255, 255) if not results[\"left\"][\"error\"] else (0, 0, 255)\n",
+    "\n",
+    "        right_font_scale = 0.5 if not results[\"right\"][\"error\"] else 1\n",
+    "        left_font_scale = 0.5 if not results[\"left\"][\"error\"] else 1\n",
+    "\n",
+    "        right_thickness = 1 if not results[\"right\"][\"error\"] else 2\n",
+    "        left_thickness = 1 if not results[\"left\"][\"error\"] else 2\n",
+    "\n",
+    "        # Visualize angles\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"right\"][\"angle\"])),\n",
+    "            tuple(np.multiply(right_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            right_font_scale,\n",
+    "            right_color,\n",
+    "            right_thickness,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "        cv2.putText(\n",
+    "            image,\n",
+    "            str(int(results[\"left\"][\"angle\"])),\n",
+    "            tuple(np.multiply(left_knee, video_dimensions).astype(int)),\n",
+    "            cv2.FONT_HERSHEY_COMPLEX,\n",
+    "            left_font_scale,\n",
+    "            left_color,\n",
+    "            left_thickness,\n",
+    "            cv2.LINE_AA,\n",
+    "        )\n",
+    "\n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "VIDEO_PATH1 = \"../data/lunge/lunge_test_3.mp4\"\n",
+    "VIDEO_PATH2 = \"../data/lunge/lunge_test_5.mp4\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/input_scaler.pkl\", \"rb\") as f:\n",
+    "    input_scaler = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Detection with Sklearn Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "with open(\"./model/sklearn/stage_SVC_model.pkl\", \"rb\") as f:\n",
+    "    stage_sklearn_model = pickle.load(f)\n",
+    "\n",
+    "with open(\"./model/sklearn/err_LR_model.pkl\", \"rb\") as f:\n",
+    "    err_sklearn_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n"
+     ]
+    }
+   ],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH1)\n",
+    "current_stage = \"\"\n",
+    "counter = 0\n",
+    "\n",
+    "prediction_probability_threshold = 0.8\n",
+    "ANGLE_THRESHOLDS = [60, 135]\n",
+    "\n",
+    "knee_over_toe = False\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results)\n",
+    "            X = pd.DataFrame([row], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            stage_predicted_class = stage_sklearn_model.predict(X)[0]\n",
+    "            stage_prediction_probabilities = stage_sklearn_model.predict_proba(X)[0]\n",
+    "            stage_prediction_probability = round(stage_prediction_probabilities[stage_prediction_probabilities.argmax()], 2)\n",
+    "\n",
+    "            # Evaluate model prediction\n",
+    "            if stage_predicted_class == \"I\" and stage_prediction_probability >= prediction_probability_threshold:\n",
+    "                current_stage = \"init\"\n",
+    "            elif stage_predicted_class == \"M\" and stage_prediction_probability >= prediction_probability_threshold: \n",
+    "                current_stage = \"mid\"\n",
+    "            elif stage_predicted_class == \"D\" and stage_prediction_probability >= prediction_probability_threshold:\n",
+    "                if current_stage in [\"mid\", \"init\"]:\n",
+    "                    counter += 1\n",
+    "                \n",
+    "                current_stage = \"down\"\n",
+    "            \n",
+    "            # Error detection\n",
+    "            # Knee angle\n",
+    "            analyze_knee_angle(mp_results=results, stage=current_stage, angle_thresholds=ANGLE_THRESHOLDS, draw_to_image=(image, video_dimensions))\n",
+    "\n",
+    "            # Knee over toe\n",
+    "            err_predicted_class = err_prediction_probabilities = err_prediction_probability = None\n",
+    "            if current_stage == \"down\":\n",
+    "                err_predicted_class = err_sklearn_model.predict(X)[0]\n",
+    "                err_prediction_probabilities = err_sklearn_model.predict_proba(X)[0]\n",
+    "                err_prediction_probability = round(err_prediction_probabilities[err_prediction_probabilities.argmax()], 2)\n",
+    "                \n",
+    "            \n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (800, 45), (245, 117, 16), -1)\n",
+    "\n",
+    "            # Display stage prediction\n",
+    "            cv2.putText(image, \"STAGE\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(stage_prediction_probability), (10, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, current_stage, (50, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display error prediction\n",
+    "            cv2.putText(image, \"K_O_T\", (200, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(err_prediction_probability), (195, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(err_predicted_class), (245, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display Counter\n",
+    "            cv2.putText(image, \"COUNTER\", (110, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(counter), (110, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "            traceback.print_exc()\n",
+    "            break\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Detection with deep learning model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "with open(\"./model/dp/err_lunge_dp.pkl\", \"rb\") as f:\n",
+    "    err_deep_learning_model = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n",
+      "No human found\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-11-22 15:17:20.031325: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
+     ]
+    },
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "cap = cv2.VideoCapture(VIDEO_PATH1)\n",
+    "current_stage = \"\"\n",
+    "counter = 0\n",
+    "\n",
+    "prediction_probability_threshold = 0.8\n",
+    "ANGLE_THRESHOLDS = [60, 135]\n",
+    "\n",
+    "knee_over_toe = False\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 50)\n",
+    "        video_dimensions = [image.shape[1], image.shape[0]]\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks:\n",
+    "            print(\"No human found\")\n",
+    "            continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=2), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=1))\n",
+    "\n",
+    "        # Make detection\n",
+    "        try:\n",
+    "            # Extract keypoints from frame for the input\n",
+    "            row = extract_important_keypoints(results)\n",
+    "            X = pd.DataFrame([row], columns=HEADERS[1:])\n",
+    "            X = pd.DataFrame(input_scaler.transform(X))\n",
+    "\n",
+    "            # Make prediction and its probability\n",
+    "            stage_predicted_class = stage_sklearn_model.predict(X)[0]\n",
+    "            stage_prediction_probabilities = stage_sklearn_model.predict_proba(X)[0]\n",
+    "            stage_prediction_probability = round(stage_prediction_probabilities[stage_prediction_probabilities.argmax()], 2)\n",
+    "\n",
+    "            # Evaluate model prediction\n",
+    "            if stage_predicted_class == \"I\" and stage_prediction_probability >= prediction_probability_threshold:\n",
+    "                current_stage = \"init\"\n",
+    "            elif stage_predicted_class == \"M\" and stage_prediction_probability >= prediction_probability_threshold: \n",
+    "                current_stage = \"mid\"\n",
+    "            elif stage_predicted_class == \"D\" and stage_prediction_probability >= prediction_probability_threshold:\n",
+    "                if current_stage == \"mid\":\n",
+    "                    counter += 1\n",
+    "                \n",
+    "                current_stage = \"down\"\n",
+    "            \n",
+    "            # Error detection\n",
+    "            # Knee angle\n",
+    "            analyze_knee_angle(mp_results=results, stage=current_stage, angle_thresholds=ANGLE_THRESHOLDS, draw_to_image=(image, video_dimensions))\n",
+    "\n",
+    "            # Knee over toe\n",
+    "            err_predicted_class = err_prediction_probabilities = err_prediction_probability = None\n",
+    "            if current_stage == \"down\":\n",
+    "                err_prediction = err_deep_learning_model.predict(X, verbose=False)\n",
+    "                err_predicted_class = np.argmax(err_prediction, axis=1)[0]\n",
+    "                err_prediction_probability = round(max(err_prediction.tolist()[0]), 2)\n",
+    "\n",
+    "                err_predicted_class = \"C\" if err_predicted_class == 1 else \"L\"\n",
+    "                \n",
+    "            \n",
+    "            # Visualization\n",
+    "            # Status box\n",
+    "            cv2.rectangle(image, (0, 0), (800, 45), (245, 117, 16), -1)\n",
+    "\n",
+    "            # Display stage prediction\n",
+    "            cv2.putText(image, \"STAGE\", (15, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(stage_prediction_probability), (10, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, current_stage, (50, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display error prediction\n",
+    "            cv2.putText(image, \"K_O_T\", (200, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(err_prediction_probability), (195, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(err_predicted_class), (245, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "            # Display Counter\n",
+    "            cv2.putText(image, \"COUNTER\", (110, 12), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)\n",
+    "            cv2.putText(image, str(counter), (110, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error: {e}\")\n",
+    "            traceback.print_exc()\n",
+    "            break\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "        \n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Conclusion\n",
+    "\n",
+    "- For stage detection:\n",
+    "    - Best Sklearn model: KNN\n",
+    "- For error detection:\n",
+    "    - Best Sklearn model: LR\n",
+    "    - Both models are correct most of the time"
+   ]
+  }
+ ],
+ "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
+}

core/lunge_model/README.md

@@ -0,0 +1,43 @@
+<h2 align="center">BICEP CURL MODEL TRAINING PROCESS</h2>
+
+### 1. Folder structure
+
+```
+bicep_model
+│   1.stage.data.ipynb - process collected videos for lunge stage
+|   2.stage.sklearn.ipynb - train models using Sklearn ML algo for lunge stage
+│   3.stage.deep_leaning.ipynb - train models using Deep Learning for lunge stage
+│   4.stage.detection.ipynb - detection on test videos for lunge stage
+│   5.stage.data.ipynb - process collected videos for lunge stage
+|   6.err.sklearn.ipynb - train models using Sklearn ML algo for lunge error
+│   7.err.deep_leaning.ipynb - train models using Deep Learning for lunge error
+│   8.err.evaluation.ipynb - evaluate trained models for lunge error
+│   9.err.detection.ipynb - detection on test videos for lunge error
+|   stage.train.csv - train dataset for lunge stage after converted from videos
+|   stage.test.csv - test dataset for lunge stage after converted from videos
+|   err.train.csv - train dataset for lunge error after converted from videos
+|   err.test.csv - test dataset after for lunge error converted from videos
+|   evaluation.csv - models' evaluation results
+│
+└───model/ - folder contains best trained models and input scaler
+│   │
+```
+
+### 2. Important landmarks
+
+There are 3 popular errors of bicep curl that will be targeted in this thesis:
+
+-   Loose upper arm: when an arm moves upward during the exercise, the upper arm is moving instead of staying still.
+-   Weak peak contraction: when an arm moves upward, it does not go high enough therefore not put enough contraction to the bicep.
+-   Lean too far back: the performer’s torso leans back and fore during the exercise for momentum.
+
+In my research and exploration, **_the important MediaPipe Pose landmarks_** for this exercise are: nose, left shoulder, right shoulder, right elbow, left elbow, right wrist, left wrist, right hip and left hip.
+
+### 3. Error detection method
+
+1. **Knee angle**: Can be detected by calculating the angle of the left and right knee. To precisely choose the correct lower and upper thresholds for this error, videos of contributors perform correct form of the exercise are analyzed. In conclusion from the graph, the angle of left/right knee during the low position of a lunge should be in between 60 and 135 degrees.
+
+    - Analyzed result:
+      <p align="center"><img src="../../images/lunge_eval_4.png" alt="Logo" width="70%"></p>
+
+1. **Knee over toe**: Due to its complexity, machine learning will be used for this detection. See this [notebook](./8.err.evaluation.ipynb) for a evaluation process for this models.

core/lunge_model/err.evaluation.csv

@@ -0,0 +1,23 @@
+Model,Precision Score,Accuracy Score,Recall Score,F1 Score,Confusion Matrix
+LR,0.9733139405601312,0.971996386630533,0.971996386630533,0.9719871073494147,"[[545   1]
+ [ 30 531]]"
+SGDC,0.9606281199356282,0.957542908762421,0.957542908762421,0.9574961020824345,"[[545   1]
+ [ 46 515]]"
+3_layers,0.9365072351551672,0.9277326106594399,0.9277326106594399,0.9274418797827825,"[[545   1]
+ [ 79 482]]"
+DTC,0.9192261367058114,0.916892502258356,0.916892502258356,0.9167297143761817,"[[479  67]
+ [ 25 536]]"
+7_layers_with_dropout,0.8920702972612289,0.8644986449864499,0.8644986449864499,0.8623537930008395,"[[544   2]
+ [148 413]]"
+RF,0.854529379025228,0.8419150858175248,0.8419150858175248,0.8407383790928666,"[[510  36]
+ [139 422]]"
+5_layers,0.8605088616622826,0.8310749774164409,0.8310749774164409,0.8279503932280722,"[[531  15]
+ [172 389]]"
+NB,0.7703551608827456,0.7687443541102078,0.7687443541102078,0.7682132184217674,"[[395 151]
+ [105 456]]"
+KNN,0.7684029707859914,0.7651309846431797,0.7651309846431797,0.7646522633908915,"[[445 101]
+ [159 402]]"
+7_layers,0.8379096785329353,0.7732610659439928,0.7732610659439928,0.7627451882949882,"[[541   5]
+ [246 315]]"
+SVC,0.751947122240204,0.7199638663053297,0.7199638663053297,0.7118153246676994,"[[488  58]
+ [252 309]]"

core/lunge_model/err.train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c151b009fb505fc6125f95477225c66ad1456f9af92d7b28c3397ca47e0aea57
+size 17699600

core/lunge_model/model/dp/all_models.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:555a7759e72bbdbf2aa7d57c937a92e71dd680bb464b5b4a0a253a57da96d3f6
+size 9759164

core/lunge_model/model/dp/err_lunge_dp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd70744c9ae0f6079733d7a10cfd0b3b675d5390f5ac0a3d3a4ffca321957062
+size 276710

core/lunge_model/model/dp/stage_lunge_dp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa609cba78e381e49124c7d7894e584685c24f62c1922516793313b8c3615321
+size 245990

core/lunge_model/model/input_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d457c53018c4dc91702e4da9b5dcb5d9a06100e2a631666645c356b7efaf87f3
+size 2605

core/lunge_model/model/sklearn/err_LR_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dc70bcce708f2e8473b6a5c5162653ab0253a8634632055637c70d03dd5174e
+size 1127

core/lunge_model/model/sklearn/err_SGDC_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84f0449a5091092bdfa88d6df74090e9ee4bb1d9239ed25a829e2f5ac27d250f
+size 5317

core/lunge_model/model/sklearn/err_all_sklearn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37806a8a7d8cb0c0b006839668f749ab026c631fd305424c538f7a168b709ebb
+size 6937168

core/lunge_model/model/sklearn/stage_LR_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13ed109d45934b90013cf4843508e2551797794089b6b5eb70d1efaf3f0e0836
+size 1974

core/lunge_model/model/sklearn/stage_Ridge_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c0a230eaeb9cbfdd296b27ec3e188a9c1d94dbd0f5e941c396a118aa15ad378
+size 2010

core/lunge_model/model/sklearn/stage_SVC_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d81a1fb1d60f1f6a2ffb855861e2864e3cb38450c5dc84a7198e68bbabcdf71e
+size 370598

core/lunge_model/stage.train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe9c1a432b8ca18f116d4d76785c95976fe783ec164c67c7d7fb14477a0c3752
+size 24142502

core/plank_model/1.data.ipynb

@@ -0,0 +1,706 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "objc[67861]: 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 (0x104544860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x289c9e480). One of the two will be used. Which one is undefined.\n",
+      "objc[67861]: 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 (0x103324a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x289c9e4d0). One of the two will be used. Which one is undefined.\n",
+      "objc[67861]: 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 (0x103324a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x289c9e4f8). One of the two will be used. Which one is undefined.\n",
+      "objc[67861]: 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 (0x103324ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x289c9e520). One of the two will be used. Which one is undefined.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\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. Make some pose detections (Test if Everything works correctly)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cap = cv2.VideoCapture(\"../data/plank/20221011_202153.mp4\")\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Press Q to close cv2 window\n",
+    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "            break\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Build dataset from collected videos and picture from Kaggle to .csv file for dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import csv\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.1 Determine important keypoints and set up important functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "There are 3 stages that I try to classify for Plank Exercise Correction:\n",
+    "\n",
+    "- Correct: \"C\"\n",
+    "- Back is too low: \"L\"\n",
+    "- Back is too high: \"H\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine important landmarks for plank\n",
+    "IMPORTANT_LMS = [\n",
+    "    \"NOSE\",\n",
+    "    \"LEFT_SHOULDER\",\n",
+    "    \"RIGHT_SHOULDER\",\n",
+    "    \"LEFT_ELBOW\",\n",
+    "    \"RIGHT_ELBOW\",\n",
+    "    \"LEFT_WRIST\",\n",
+    "    \"RIGHT_WRIST\",\n",
+    "    \"LEFT_HIP\",\n",
+    "    \"RIGHT_HIP\",\n",
+    "    \"LEFT_KNEE\",\n",
+    "    \"RIGHT_KNEE\",\n",
+    "    \"LEFT_ANKLE\",\n",
+    "    \"RIGHT_ANKLE\",\n",
+    "    \"LEFT_HEEL\",\n",
+    "    \"RIGHT_HEEL\",\n",
+    "    \"LEFT_FOOT_INDEX\",\n",
+    "    \"RIGHT_FOOT_INDEX\",\n",
+    "]\n",
+    "\n",
+    "# Generate all columns of the data frame\n",
+    "\n",
+    "HEADERS = [\"label\"] # Label column\n",
+    "\n",
+    "for lm in IMPORTANT_LMS:\n",
+    "    HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Set up important functions*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "    \n",
+    "\n",
+    "def init_csv(dataset_path: str):\n",
+    "    '''\n",
+    "    Create a blank csv file with just columns\n",
+    "    '''\n",
+    "\n",
+    "    # Ignore if file is already exist\n",
+    "    if os.path.exists(dataset_path):\n",
+    "        return\n",
+    "\n",
+    "    # Write all the columns to a empaty file\n",
+    "    with open(dataset_path, mode=\"w\", newline=\"\") as f:\n",
+    "        csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "        csv_writer.writerow(HEADERS)\n",
+    "\n",
+    "\n",
+    "def export_landmark_to_csv(dataset_path: str, results, action: str) -> None:\n",
+    "    '''\n",
+    "    Export Labeled Data from detected landmark to csv\n",
+    "    '''\n",
+    "    landmarks = results.pose_landmarks.landmark\n",
+    "    keypoints = []\n",
+    "\n",
+    "    try:\n",
+    "        # Extract coordinate of important landmarks\n",
+    "        for lm in IMPORTANT_LMS:\n",
+    "            keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n",
+    "            keypoints.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n",
+    "        \n",
+    "        keypoints = list(np.array(keypoints).flatten())\n",
+    "\n",
+    "        # Insert action as the label (first column)\n",
+    "        keypoints.insert(0, action)\n",
+    "\n",
+    "        # Append new row to .csv file\n",
+    "        with open(dataset_path, mode=\"a\", newline=\"\") as f:\n",
+    "            csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
+    "            csv_writer.writerow(keypoints)\n",
+    "        \n",
+    "\n",
+    "    except Exception as e:\n",
+    "        print(e)\n",
+    "        pass\n",
+    "\n",
+    "\n",
+    "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 remove_duplicate_rows(dataset_path: str):\n",
+    "    '''\n",
+    "    Remove duplicated data from the dataset then save it to another files\n",
+    "    '''\n",
+    "    \n",
+    "    df = pd.read_csv(dataset_path)\n",
+    "    df.drop_duplicates(keep=\"first\", inplace=True)\n",
+    "    df.to_csv(f\"cleaned_train.csv\", sep=',', encoding='utf-8', index=False)\n",
+    "    \n",
+    "\n",
+    "def concat_csv_files_with_same_headers(file_paths: list, saved_path: str):\n",
+    "    '''\n",
+    "    Concat different csv files\n",
+    "    '''\n",
+    "    all_df = []\n",
+    "    for path in file_paths:\n",
+    "        df = pd.read_csv(path, index_col=None, header=0)\n",
+    "        all_df.append(df)\n",
+    "    \n",
+    "    results = pd.concat(all_df, axis=0, ignore_index=True)\n",
+    "    results.to_csv(saved_path, sep=',', encoding='utf-8', index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.2 Extract from video\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATASET_PATH = \"train.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/plank/bad/plank_bad_high_4.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "# init_csv(DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks: continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(1) & 0xFF\n",
+    "\n",
+    "        # Press C to save as correct form\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as low back\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as high back\n",
+    "        elif k == ord(\"h\"):\n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"H\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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', 'left_elbow_x', 'left_elbow_y', 'left_elbow_z', 'left_elbow_v', 'right_elbow_x', 'right_elbow_y', 'right_elbow_z', 'right_elbow_v', 'left_wrist_x', 'left_wrist_y', 'left_wrist_z', 'left_wrist_v', 'right_wrist_x', 'right_wrist_y', 'right_wrist_z', 'right_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', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 28520 \n",
+      "Number of columns: 69\n",
+      "\n",
+      "Labels: \n",
+      "C    9904\n",
+      "L    9546\n",
+      "H    9070\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# csv_files = [os.path.join(\"./\", f) for f in os.listdir(\"./\") if \"csv\" in f]\n",
+    "\n",
+    "# concat_csv_files_with_same_headers(csv_files, \"train.csv\")\n",
+    "\n",
+    "# remove_duplicate_rows(DATASET_PATH)\n",
+    "\n",
+    "df = describe_dataset(DATASET_PATH)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.3. Extract from Kaggle dataset ([download here](https://www.kaggle.com/datasets/niharika41298/yoga-poses-dataset))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "FOLDER_PATH = \"../data/kaggle/TRAIN/plank\"\n",
+    "picture_files = [os.path.join(FOLDER_PATH, f) for f in os.listdir(FOLDER_PATH) if os.path.isfile(os.path.join(FOLDER_PATH, f))]\n",
+    "print(f\"Total pictures: {len(picture_files)}\")\n",
+    "\n",
+    "DATASET_PATH = \"./kaggle.csv\"\n",
+    "saved_counts = 0\n",
+    "\n",
+    "init_csv(DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.7, min_tracking_confidence=0.5) as pose:\n",
+    "    index = 0\n",
+    "    \n",
+    "    while True:\n",
+    "        if index == len(picture_files):\n",
+    "            break\n",
+    "        \n",
+    "        file_path = picture_files[index]\n",
+    "\n",
+    "        image = cv2.imread(file_path)\n",
+    "\n",
+    "        # Flip image horizontally for more data\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        # get dimensions of image\n",
+    "        dimensions = image.shape\n",
+    "        \n",
+    "        # height, width, number of channels in image\n",
+    "        height = image.shape[0]\n",
+    "        width = image.shape[1]\n",
+    "        channels = image.shape[2]\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        if width > 1000:\n",
+    "            image = rescale_frame(image, 60)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {saved_counts}\", (20, 20), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "        \n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        k = cv2.waitKey(1) & 0xFF\n",
+    "\n",
+    "        if k == ord('d'): \n",
+    "            index += 1\n",
+    "\n",
+    "        elif k == ord(\"s\"):\n",
+    "            export_landmark_to_csv(DATASET_PATH, results, \"C\")\n",
+    "            saved_counts += 1\n",
+    "\n",
+    "        elif k == ord(\"f\"):\n",
+    "            index += 1\n",
+    "            os.remove(file_path)\n",
+    "\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "\n",
+    "        else:\n",
+    "            continue\n",
+    "\n",
+    "        # # Press Q to close cv2 window\n",
+    "        # if cv2.waitKey(1) & 0xFF == ord('d'):\n",
+    "        #     index += 1\n",
+    "\n",
+    "        # # Press Q to close cv2 window\n",
+    "        # if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+    "        #     break\n",
+    "\n",
+    "    # Close cv2 window\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Refine Data & Data Visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='label', ylabel='count'>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAGwCAYAAAC0HlECAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnDklEQVR4nO3df3DU9Z3H8ddCyBIgfCWEZMkZNIw5RIOWCxKCVahAoDWmDjOiF7uHAwV6QdIUKJThqIhHoqjAaK4InBWOH4a5tmm5trcleiVX5EcgNVUwor3mBGxC6LnZAMYkhu/90fKdLkH4GGL2G/J8zGTG/e57k/eXyZjnfHc38di2bQsAAABX1CvSCwAAAHQHRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAxERXqB68mFCxf0xz/+UbGxsfJ4PJFeBwAAGLBtW2fPnlVSUpJ69frs60lEUyf64x//qOTk5EivAQAAOuDkyZO68cYbP/N+oqkTxcbGSvrzP/rAgQMjvA0AADDR2Nio5ORk5+f4ZyGaOtHFp+QGDhxINAEA0M1c7aU1vBAcAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAICBiEbTf//3f+uBBx5QUlKSPB6PfvrTn4bdb9u2Vq5cqaSkJMXExGjixIk6duxY2Exzc7MWLFig+Ph49e/fXzk5OTp16lTYTDAYlN/vl2VZsixLfr9fDQ0NYTMnTpzQAw88oP79+ys+Pl75+flqaWn5Ik4bAAB0QxGNpvPnz+vOO+9UcXHxZe9fs2aN1q5dq+LiYh0+fFg+n09TpkzR2bNnnZmCggKVlpaqpKRE+/bt07lz55Sdna22tjZnJjc3V1VVVQoEAgoEAqqqqpLf73fub2tr0/3336/z589r3759Kikp0Y9//GMtWrToizt5AADQvdguIckuLS11bl+4cMH2+Xz2008/7Rz75JNPbMuy7Jdeesm2bdtuaGiw+/TpY5eUlDgzH374od2rVy87EAjYtm3b77zzji3JPnjwoDNz4MABW5L97rvv2rZt27/85S/tXr162R9++KEz8+qrr9per9cOhUKfufMnn3xih0Ih5+PkyZO2pCs+BgAAuEsoFDL6+e3a1zTV1NSorq5OWVlZzjGv16sJEyZo//79kqTKykq1traGzSQlJSktLc2ZOXDggCzLUkZGhjMzbtw4WZYVNpOWlqakpCRnZurUqWpublZlZeVn7lhUVOQ85WdZlpKTkzvn5AEAgOu4Nprq6uokSYmJiWHHExMTnfvq6uoUHR2tQYMGXXEmISGh3edPSEgIm7n06wwaNEjR0dHOzOUsW7ZMoVDI+Th58uTnPEsAANBdREV6gau59C8O27Z91b9CfOnM5eY7MnMpr9crr9d7xV0AAMD1wbVXmnw+nyS1u9JTX1/vXBXy+XxqaWlRMBi84szp06fbff4zZ86EzVz6dYLBoFpbW9tdgQIAAD2Ta680paSkyOfzqaysTKNHj5YktbS0qLy8XM8884wkKT09XX369FFZWZlmzJghSaqtrdXRo0e1Zs0aSVJmZqZCoZAqKio0duxYSdKhQ4cUCoU0fvx4Z2b16tWqra3V0KFDJUl79uyR1+tVenp6l573kTFju/Trwd3GHKmI9AoAgL+IaDSdO3dOv//9753bNTU1qqqqUlxcnIYNG6aCggIVFhYqNTVVqampKiwsVL9+/ZSbmytJsixLs2fP1qJFizR48GDFxcVp8eLFGjVqlCZPnixJGjlypKZNm6Y5c+Zo48aNkqS5c+cqOztbI0aMkCRlZWXptttuk9/v17PPPquPPvpIixcv1pw5czRw4MAu/lcBAABuFNFoOnLkiL7yla84txcuXChJmjlzprZs2aIlS5aoqalJeXl5CgaDysjI0J49exQbG+s8Zt26dYqKitKMGTPU1NSkSZMmacuWLerdu7czs2PHDuXn5zvvssvJyQn73VC9e/fWL37xC+Xl5enuu+9WTEyMcnNz9dxzz33R/wQAAKCb8Ni2bUd6ietFY2OjLMtSKBTq8BUqnp7DX+PpOQD44pn+/HbtC8EBAADchGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMCAa//2HAD3mLZiV6RXgIsEnno40isAEcGVJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGoiK9AAAAn1futkcivQJcZKe/pEu+DleaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGXB1Nn376qf7pn/5JKSkpiomJ0fDhw7Vq1SpduHDBmbFtWytXrlRSUpJiYmI0ceJEHTt2LOzzNDc3a8GCBYqPj1f//v2Vk5OjU6dOhc0Eg0H5/X5ZliXLsuT3+9XQ0NAVpwkAALoBV0fTM888o5deeknFxcWqrq7WmjVr9Oyzz+rFF190ZtasWaO1a9equLhYhw8fls/n05QpU3T27FlnpqCgQKWlpSopKdG+fft07tw5ZWdnq62tzZnJzc1VVVWVAoGAAoGAqqqq5Pf7u/R8AQCAe0VFeoErOXDggL7+9a/r/vvvlyTdfPPNevXVV3XkyBFJf77KtH79ei1fvlzTp0+XJG3dulWJiYnauXOn5s2bp1AopJdfflnbtm3T5MmTJUnbt29XcnKyXnvtNU2dOlXV1dUKBAI6ePCgMjIyJEmbN29WZmamjh8/rhEjRlx2v+bmZjU3Nzu3Gxsbv7B/CwAAEFmuvtL05S9/Wa+//rree+89SdLvfvc77du3T1/72tckSTU1Naqrq1NWVpbzGK/XqwkTJmj//v2SpMrKSrW2tobNJCUlKS0tzZk5cOCALMtygkmSxo0bJ8uynJnLKSoqcp7OsyxLycnJnXfyAADAVVx9pWnp0qUKhUK69dZb1bt3b7W1tWn16tX6+7//e0lSXV2dJCkxMTHscYmJifrggw+cmejoaA0aNKjdzMXH19XVKSEhod3XT0hIcGYuZ9myZVq4cKFzu7GxkXACAOA65epo2rVrl7Zv366dO3fq9ttvV1VVlQoKCpSUlKSZM2c6cx6PJ+xxtm23O3apS2cuN3+1z+P1euX1ek1PBwAAdGOujqbvfve7+t73vqdHHnlEkjRq1Ch98MEHKioq0syZM+Xz+ST9+UrR0KFDncfV19c7V598Pp9aWloUDAbDrjbV19dr/Pjxzszp06fbff0zZ860u4oFAAB6Jle/punjjz9Wr17hK/bu3dv5lQMpKSny+XwqKytz7m9paVF5ebkTROnp6erTp0/YTG1trY4ePerMZGZmKhQKqaKiwpk5dOiQQqGQMwMAAHo2V19peuCBB7R69WoNGzZMt99+u958802tXbtWs2bNkvTnp9QKCgpUWFio1NRUpaamqrCwUP369VNubq4kybIszZ49W4sWLdLgwYMVFxenxYsXa9SoUc676UaOHKlp06Zpzpw52rhxoyRp7ty5ys7O/sx3zgEAgJ7F1dH04osvasWKFcrLy1N9fb2SkpI0b948ff/733dmlixZoqamJuXl5SkYDCojI0N79uxRbGysM7Nu3TpFRUVpxowZampq0qRJk7Rlyxb17t3bmdmxY4fy8/Odd9nl5OSouLi4604WAAC4mse2bTvSS1wvGhsbZVmWQqGQBg4c2KHPcWTM2E7eCt3ZmCMVVx/qAtNW7Ir0CnCRwFMPR3oF5W57JNIrwEV2+kuu6fGmP79d/ZomAAAAtyCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADro+mDz/8UN/4xjc0ePBg9evXT1/60pdUWVnp3G/btlauXKmkpCTFxMRo4sSJOnbsWNjnaG5u1oIFCxQfH6/+/fsrJydHp06dCpsJBoPy+/2yLEuWZcnv96uhoaErThEAAHQDro6mYDCou+++W3369NF//ud/6p133tHzzz+vG264wZlZs2aN1q5dq+LiYh0+fFg+n09TpkzR2bNnnZmCggKVlpaqpKRE+/bt07lz55Sdna22tjZnJjc3V1VVVQoEAgoEAqqqqpLf7+/K0wUAAC4WFekFruSZZ55RcnKyXnnlFefYzTff7Py3bdtav369li9frunTp0uStm7dqsTERO3cuVPz5s1TKBTSyy+/rG3btmny5MmSpO3btys5OVmvvfaapk6dqurqagUCAR08eFAZGRmSpM2bNyszM1PHjx/XiBEjLrtfc3OzmpubnduNjY2d/U8AAABcwtVXmnbv3q0xY8booYceUkJCgkaPHq3Nmzc799fU1Kiurk5ZWVnOMa/XqwkTJmj//v2SpMrKSrW2tobNJCUlKS0tzZk5cOCALMtygkmSxo0bJ8uynJnLKSoqcp7OsyxLycnJnXbuAADAXVwdTX/4wx+0YcMGpaam6le/+pW+9a1vKT8/X//2b/8mSaqrq5MkJSYmhj0uMTHRua+urk7R0dEaNGjQFWcSEhLaff2EhARn5nKWLVumUCjkfJw8ebLjJwsAAFzN1U/PXbhwQWPGjFFhYaEkafTo0Tp27Jg2bNigf/iHf3DmPB5P2ONs22537FKXzlxu/mqfx+v1yuv1Gp0LAADo3lx9pWno0KG67bbbwo6NHDlSJ06ckCT5fD5Janc1qL6+3rn65PP51NLSomAweMWZ06dPt/v6Z86caXcVCwAA9Eyujqa7775bx48fDzv23nvv6aabbpIkpaSkyOfzqayszLm/paVF5eXlGj9+vCQpPT1dffr0CZupra3V0aNHnZnMzEyFQiFVVFQ4M4cOHVIoFHJmAABAz+bqp+e+853vaPz48SosLNSMGTNUUVGhTZs2adOmTZL+/JRaQUGBCgsLlZqaqtTUVBUWFqpfv37Kzc2VJFmWpdmzZ2vRokUaPHiw4uLitHjxYo0aNcp5N93IkSM1bdo0zZkzRxs3bpQkzZ07V9nZ2Z/5zjkAANCzuDqa7rrrLpWWlmrZsmVatWqVUlJStH79ej366KPOzJIlS9TU1KS8vDwFg0FlZGRoz549io2NdWbWrVunqKgozZgxQ01NTZo0aZK2bNmi3r17OzM7duxQfn6+8y67nJwcFRcXd93JAgAAV/PYtm1HeonrRWNjoyzLUigU0sCBAzv0OY6MGdvJW6E7G3Ok4upDXWDail2RXgEuEnjq4UivoNxtj0R6BbjITn/JNT3e9Oe3q1/TBAAA4BZEEwAAgAGiCQAAwADRBAAAYKBD0XTfffepoaGh3fHGxkbdd99917oTAACA63Qomvbu3auWlpZ2xz/55BP95je/uealAAAA3OZz/Z6mt956y/nvd955J+zPl7S1tSkQCOhv/uZvOm87AAAAl/hc0fSlL31JHo9HHo/nsk/DxcTE6MUXX+y05QAAANzic0VTTU2NbNvW8OHDVVFRoSFDhjj3RUdHKyEhIey3bAMAAFwvPlc0XfxDuRcuXPhClgEAAHCrDv/tuffee0979+5VfX19u4j6/ve/f82LAQAAuEmHomnz5s36x3/8R8XHx8vn88nj8Tj3eTweogkAAFx3OhRN//zP/6zVq1dr6dKlnb0PAACAK3Xo9zQFg0E99NBDnb0LAACAa3Uomh566CHt2bOns3cBAABwrQ49PXfLLbdoxYoVOnjwoEaNGqU+ffqE3Z+fn98pywEAALhFh6Jp06ZNGjBggMrLy1VeXh52n8fjIZoAAMB1p0PRVFNT09l7AAAAuFqHXtMEAADQ03ToStOsWbOueP8Pf/jDDi0DAADgVh2KpmAwGHa7tbVVR48eVUNDw2X/kC8AAEB316FoKi0tbXfswoULysvL0/Dhw695KQAAALfptNc09erVS9/5zne0bt26zvqUAAAArtGpLwT/n//5H3366aed+SkBAABcoUNPzy1cuDDstm3bqq2t1S9+8QvNnDmzUxYDAABwkw5F05tvvhl2u1evXhoyZIief/75q76zDgAAoDvqUDT9+te/7uw9AAAAXK1D0XTRmTNndPz4cXk8Hv3t3/6thgwZ0ll7AQAAuEqHXgh+/vx5zZo1S0OHDtW9996re+65R0lJSZo9e7Y+/vjjzt4RAAAg4joUTQsXLlR5ebn+4z/+Qw0NDWpoaNDPfvYzlZeXa9GiRZ29IwAAQMR16Om5H//4x/rRj36kiRMnOse+9rWvKSYmRjNmzNCGDRs6az8AAABX6NCVpo8//liJiYntjickJPD0HAAAuC51KJoyMzP1xBNP6JNPPnGONTU16cknn1RmZmanLQcAAOAWHXp6bv369frqV7+qG2+8UXfeeac8Ho+qqqrk9Xq1Z8+ezt4RAAAg4joUTaNGjdL777+v7du3691335Vt23rkkUf06KOPKiYmprN3BAAAiLgORVNRUZESExM1Z86csOM//OEPdebMGS1durRTlgMAAHCLDr2maePGjbr11lvbHb/99tv10ksvXfNSAAAAbtOhaKqrq9PQoUPbHR8yZIhqa2uveSkAAAC36VA0JScn64033mh3/I033lBSUtI1LwUAAOA2HXpN0ze/+U0VFBSotbVV9913nyTp9ddf15IlS/iN4AAA4LrUoWhasmSJPvroI+Xl5amlpUWS1LdvXy1dulTLli3r1AUBAADcoEPR5PF49Mwzz2jFihWqrq5WTEyMUlNT5fV6O3s/AAAAV+hQNF00YMAA3XXXXZ21CwAAgGt16IXgAAAAPQ3RBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMBAt4qmoqIieTweFRQUOMds29bKlSuVlJSkmJgYTZw4UceOHQt7XHNzsxYsWKD4+Hj1799fOTk5OnXqVNhMMBiU3++XZVmyLEt+v18NDQ1dcFYAAKA76DbRdPjwYW3atEl33HFH2PE1a9Zo7dq1Ki4u1uHDh+Xz+TRlyhSdPXvWmSkoKFBpaalKSkq0b98+nTt3TtnZ2Wpra3NmcnNzVVVVpUAgoEAgoKqqKvn9/i47PwAA4G7dIprOnTunRx99VJs3b9agQYOc47Zta/369Vq+fLmmT5+utLQ0bd26VR9//LF27twpSQqFQnr55Zf1/PPPa/LkyRo9erS2b9+ut99+W6+99pokqbq6WoFAQP/6r/+qzMxMZWZmavPmzfr5z3+u48ePR+ScAQCAu3SLaJo/f77uv/9+TZ48Oex4TU2N6urqlJWV5Rzzer2aMGGC9u/fL0mqrKxUa2tr2ExSUpLS0tKcmQMHDsiyLGVkZDgz48aNk2VZzszlNDc3q7GxMewDAABcn6IivcDVlJSU6Le//a0OHz7c7r66ujpJUmJiYtjxxMREffDBB85MdHR02BWqizMXH19XV6eEhIR2nz8hIcGZuZyioiI9+eSTn++EAABAt+TqK00nT57Ut7/9bW3fvl19+/b9zDmPxxN227btdscudenM5eav9nmWLVumUCjkfJw8efKKXxMAAHRfro6myspK1dfXKz09XVFRUYqKilJ5ebleeOEFRUVFOVeYLr0aVF9f79zn8/nU0tKiYDB4xZnTp0+3+/pnzpxpdxXrr3m9Xg0cODDsAwAAXJ9cHU2TJk3S22+/raqqKudjzJgxevTRR1VVVaXhw4fL5/OprKzMeUxLS4vKy8s1fvx4SVJ6err69OkTNlNbW6ujR486M5mZmQqFQqqoqHBmDh06pFAo5MwAAICezdWvaYqNjVVaWlrYsf79+2vw4MHO8YKCAhUWFio1NVWpqakqLCxUv379lJubK0myLEuzZ8/WokWLNHjwYMXFxWnx4sUaNWqU88LykSNHatq0aZozZ442btwoSZo7d66ys7M1YsSILjxjAADgVq6OJhNLlixRU1OT8vLyFAwGlZGRoT179ig2NtaZWbdunaKiojRjxgw1NTVp0qRJ2rJli3r37u3M7NixQ/n5+c677HJyclRcXNzl5wMAANzJY9u2HeklrheNjY2yLEuhUKjDr286MmZsJ2+F7mzMkYqrD3WBaSt2RXoFuEjgqYcjvYJytz0S6RXgIjv9Jdf0eNOf365+TRMAAIBbEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAFXR1NRUZHuuusuxcbGKiEhQQ8++KCOHz8eNmPbtlauXKmkpCTFxMRo4sSJOnbsWNhMc3OzFixYoPj4ePXv3185OTk6depU2EwwGJTf75dlWbIsS36/Xw0NDV/0KQIAgG7C1dFUXl6u+fPn6+DBgyorK9Onn36qrKwsnT9/3plZs2aN1q5dq+LiYh0+fFg+n09TpkzR2bNnnZmCggKVlpaqpKRE+/bt07lz55Sdna22tjZnJjc3V1VVVQoEAgoEAqqqqpLf7+/S8wUAAO4VFekFriQQCITdfuWVV5SQkKDKykrde++9sm1b69ev1/LlyzV9+nRJ0tatW5WYmKidO3dq3rx5CoVCevnll7Vt2zZNnjxZkrR9+3YlJyfrtdde09SpU1VdXa1AIKCDBw8qIyNDkrR582ZlZmbq+PHjGjFiRNeeOAAAcB1XX2m6VCgUkiTFxcVJkmpqalRXV6esrCxnxuv1asKECdq/f78kqbKyUq2trWEzSUlJSktLc2YOHDggy7KcYJKkcePGybIsZ+Zympub1djYGPYBAACuT90mmmzb1sKFC/XlL39ZaWlpkqS6ujpJUmJiYthsYmKic19dXZ2io6M1aNCgK84kJCS0+5oJCQnOzOUUFRU5r4GyLEvJyckdP0EAAOBq3SaaHn/8cb311lt69dVX293n8XjCbtu23e7YpS6dudz81T7PsmXLFAqFnI+TJ09e7TQAAEA31S2iacGCBdq9e7d+/etf68Ybb3SO+3w+SWp3Nai+vt65+uTz+dTS0qJgMHjFmdOnT7f7umfOnGl3Feuveb1eDRw4MOwDAABcn1wdTbZt6/HHH9dPfvIT/dd//ZdSUlLC7k9JSZHP51NZWZlzrKWlReXl5Ro/frwkKT09XX369Ambqa2t1dGjR52ZzMxMhUIhVVRUODOHDh1SKBRyZgAAQM/m6nfPzZ8/Xzt37tTPfvYzxcbGOleULMtSTEyMPB6PCgoKVFhYqNTUVKWmpqqwsFD9+vVTbm6uMzt79mwtWrRIgwcPVlxcnBYvXqxRo0Y576YbOXKkpk2bpjlz5mjjxo2SpLlz5yo7O5t3zgEAAEkuj6YNGzZIkiZOnBh2/JVXXtFjjz0mSVqyZImampqUl5enYDCojIwM7dmzR7Gxsc78unXrFBUVpRkzZqipqUmTJk3Sli1b1Lt3b2dmx44dys/Pd95ll5OTo+Li4i/2BAEAQLfhsW3bjvQS14vGxkZZlqVQKNTh1zcdGTO2k7dCdzbmSMXVh7rAtBW7Ir0CXCTw1MORXkG52x6J9ApwkZ3+kmt6vOnPb1e/pgkAAMAtiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRdIkf/OAHSklJUd++fZWenq7f/OY3kV4JAAC4ANH0V3bt2qWCggItX75cb775pu655x599atf1YkTJyK9GgAAiDCi6a+sXbtWs2fP1je/+U2NHDlS69evV3JysjZs2BDp1QAAQIRFRXoBt2hpaVFlZaW+973vhR3PysrS/v37L/uY5uZmNTc3O7dDoZAkqbGxscN7nGtr6/Bjcf25lu+lzvRp88eRXgEu4obvy9am1kivABe51u/Ji4+3bfuKc0TTX/zpT39SW1ubEhMTw44nJiaqrq7uso8pKirSk08+2e54cnLyF7IjeiDLivQGQDvWs7MivQIQ5kfzftIpn+fs2bOyrvD/XaLpEh6PJ+y2bdvtjl20bNkyLVy40Ll94cIFffTRRxo8ePBnPgZX19jYqOTkZJ08eVIDBw6M9DqAJL4v4T58T3Ye27Z19uxZJSUlXXGOaPqL+Ph49e7du91Vpfr6+nZXny7yer3yer1hx2644YYvasUeZ+DAgfyPAK7D9yXchu/JznGlK0wX8ULwv4iOjlZ6errKysrCjpeVlWn8+PER2goAALgFV5r+ysKFC+X3+zVmzBhlZmZq06ZNOnHihL71rW9FejUAABBhRNNfefjhh/V///d/WrVqlWpra5WWlqZf/vKXuummmyK9Wo/i9Xr1xBNPtHvqE4gkvi/hNnxPdj2PfbX31wEAAIDXNAEAAJggmgAAAAwQTQAAAAaIJgAAAANEE1ylrq5OCxYs0PDhw+X1epWcnKwHHnhAr7/+eqRXQw/12GOP6cEHH4z0GoCkz/5+3Lt3rzwejxoaGrp8p56EXzkA1/jf//1f3X333brhhhu0Zs0a3XHHHWptbdWvfvUrzZ8/X++++26kVwQA9GBEE1wjLy9PHo9HFRUV6t+/v3P89ttv16xZ/IFQAEBk8fQcXOGjjz5SIBDQ/Pnzw4LpIv6mHwAg0rjSBFf4/e9/L9u2deutt0Z6FQBwtZ///OcaMGBA2LG2trYIbdOzEE1whYu/mN7j8UR4EwBwt6985SvasGFD2LFDhw7pG9/4RoQ26jmIJrhCamqqPB6PqqureacSAFxB//79dcstt4QdO3XqVIS26Vl4TRNcIS4uTlOnTtW//Mu/6Pz58+3u5220AIBI40oTXOMHP/iBxo8fr7Fjx2rVqlW644479Omnn6qsrEwbNmxQdXV1pFdEDxUKhVRVVRV2LC4uTsOGDYvMQgAigmiCa6SkpOi3v/2tVq9erUWLFqm2tlZDhgxRenp6u+fvga60d+9ejR49OuzYzJkztWXLlsgsBCAiPPbFV+ACAADgM/GaJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAD3GxIkTVVBQYDS7d+9eeTyea/67hzfffLPWr19/TZ8DgDsQTQAAAAaIJgAAAANEE4Aeafv27RozZoxiY2Pl8/mUm5ur+vr6dnNvvPGG7rzzTvXt21cZGRl6++23w+7fv3+/7r33XsXExCg5OVn5+fk6f/58V50GgC5ENAHokVpaWvTUU0/pd7/7nX7605+qpqZGjz32WLu57373u3ruued0+PBhJSQkKCcnR62trZKkt99+W1OnTtX06dP11ltvadeuXdq3b58ef/zxLj4bAF0hKtILAEAkzJo1y/nv4cOH64UXXtDYsWN17tw5DRgwwLnviSee0JQpUyRJW7du1Y033qjS0lLNmDFDzz77rHJzc50Xl6empuqFF17QhAkTtGHDBvXt27dLzwnAF4srTQB6pDfffFNf//rXddNNNyk2NlYTJ06UJJ04cSJsLjMz0/nvuLg4jRgxQtXV1ZKkyspKbdmyRQMGDHA+pk6dqgsXLqimpqbLzgVA1+BKE4Ae5/z588rKylJWVpa2b9+uIUOG6MSJE5o6dapaWlqu+niPxyNJunDhgubNm6f8/Px2M8OGDev0vQFEFtEEoMd599139ac//UlPP/20kpOTJUlHjhy57OzBgwedAAoGg3rvvfd06623SpL+7u/+TseOHdMtt9zSNYsDiCiengPQ4wwbNkzR0dF68cUX9Yc//EG7d+/WU089ddnZVatW6fXXX9fRo0f12GOPKT4+Xg8++KAkaenSpTpw4IDmz5+vqqoqvf/++9q9e7cWLFjQhWcDoKsQTQB6nCFDhmjLli3693//d9122216+umn9dxzz1129umnn9a3v/1tpaenq7a2Vrt371Z0dLQk6Y477lB5ebnef/993XPPPRo9erRWrFihoUOHduXpAOgiHtu27UgvAQAA4HZcaQIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADPw/jUJkVPp5SykAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.countplot(x='label', data=df, palette=\"Set1\") "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5. Extract data for test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n"
+     ]
+    }
+   ],
+   "source": [
+    "TEST_DATASET_PATH = \"test.csv\"\n",
+    "\n",
+    "cap = cv2.VideoCapture(\"../data/plank/plank_test_4.mp4\")\n",
+    "save_counts = 0\n",
+    "\n",
+    "# init_csv(TEST_DATASET_PATH)\n",
+    "\n",
+    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:\n",
+    "    while cap.isOpened():\n",
+    "        ret, image = cap.read()\n",
+    "\n",
+    "        if not ret:\n",
+    "            break\n",
+    "\n",
+    "        # Reduce size of a frame\n",
+    "        image = rescale_frame(image, 60)\n",
+    "        image = cv2.flip(image, 1)\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        image.flags.writeable = False\n",
+    "\n",
+    "        results = pose.process(image)\n",
+    "\n",
+    "        if not results.pose_landmarks: continue\n",
+    "\n",
+    "        # Recolor image from BGR to RGB for mediapipe\n",
+    "        image.flags.writeable = True\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "\n",
+    "        # Draw landmarks and connections\n",
+    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n",
+    "\n",
+    "        # Display the saved count\n",
+    "        cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n",
+    "\n",
+    "        cv2.imshow(\"CV2\", image)\n",
+    "\n",
+    "        # Pressed key for action\n",
+    "        k = cv2.waitKey(1) & 0xFF\n",
+    "\n",
+    "        # Press C to save as correct form\n",
+    "        if k == ord('c'): \n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"C\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as low back\n",
+    "        elif k == ord(\"l\"):\n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"L\")\n",
+    "            save_counts += 1\n",
+    "        # Press L to save as high back\n",
+    "        elif k == ord(\"h\"):\n",
+    "            export_landmark_to_csv(TEST_DATASET_PATH, results, \"H\")\n",
+    "            save_counts += 1\n",
+    "\n",
+    "        # Press q to stop\n",
+    "        elif k == ord(\"q\"):\n",
+    "            break\n",
+    "        else: continue\n",
+    "\n",
+    "    cap.release()\n",
+    "    cv2.destroyAllWindows()\n",
+    "\n",
+    "    # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n",
+    "    for i in range (1, 5):\n",
+    "        cv2.waitKey(1)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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', 'left_elbow_x', 'left_elbow_y', 'left_elbow_z', 'left_elbow_v', 'right_elbow_x', 'right_elbow_y', 'right_elbow_z', 'right_elbow_v', 'left_wrist_x', 'left_wrist_y', 'left_wrist_z', 'left_wrist_v', 'right_wrist_x', 'right_wrist_y', 'right_wrist_z', 'right_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', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 710 \n",
+      "Number of columns: 69\n",
+      "\n",
+      "Labels: \n",
+      "H    241\n",
+      "L    235\n",
+      "C    234\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(TEST_DATASET_PATH)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='count', ylabel='label'>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.countplot(y='label', data=test_df, palette=\"Set1\") "
+   ]
+  },
+  {
+   "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
+}

core/plank_model/2.sklearn.ipynb

@@ -0,0 +1,762 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mediapipe as mp\n",
+    "import cv2\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.calibration import CalibratedClassifierCV\n",
+    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "\n",
+    "from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score, confusion_matrix\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. Train Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.1. Describe data and split dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_frame(frame, percent=50):\n",
+    "    '''\n",
+    "    Rescale a frame to a certain percentage compare to its original frame\n",
+    "    '''\n",
+    "    width = int(frame.shape[1] * percent/ 100)\n",
+    "    height = int(frame.shape[0] * percent/ 100)\n",
+    "    dim = (width, height)\n",
+    "    return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n",
+    "\n",
+    "\n",
+    "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": "code",
+   "execution_count": 56,
+   "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', 'left_elbow_x', 'left_elbow_y', 'left_elbow_z', 'left_elbow_v', 'right_elbow_x', 'right_elbow_y', 'right_elbow_z', 'right_elbow_v', 'left_wrist_x', 'left_wrist_y', 'left_wrist_z', 'left_wrist_v', 'right_wrist_x', 'right_wrist_y', 'right_wrist_z', 'right_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', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 28520 \n",
+      "Number of columns: 69\n",
+      "\n",
+      "Labels: \n",
+      "C    9904\n",
+      "L    9546\n",
+      "H    9070\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    },
+    {
+     "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>label</th>\n",
+       "      <th>nose_x</th>\n",
+       "      <th>nose_y</th>\n",
+       "      <th>nose_z</th>\n",
+       "      <th>nose_v</th>\n",
+       "      <th>left_shoulder_x</th>\n",
+       "      <th>left_shoulder_y</th>\n",
+       "      <th>left_shoulder_z</th>\n",
+       "      <th>left_shoulder_v</th>\n",
+       "      <th>right_shoulder_x</th>\n",
+       "      <th>...</th>\n",
+       "      <th>right_heel_z</th>\n",
+       "      <th>right_heel_v</th>\n",
+       "      <th>left_foot_index_x</th>\n",
+       "      <th>left_foot_index_y</th>\n",
+       "      <th>left_foot_index_z</th>\n",
+       "      <th>left_foot_index_v</th>\n",
+       "      <th>right_foot_index_x</th>\n",
+       "      <th>right_foot_index_y</th>\n",
+       "      <th>right_foot_index_z</th>\n",
+       "      <th>right_foot_index_v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>28517</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.735630</td>\n",
+       "      <td>0.543294</td>\n",
+       "      <td>0.007467</td>\n",
+       "      <td>0.999246</td>\n",
+       "      <td>0.695831</td>\n",
+       "      <td>0.417349</td>\n",
+       "      <td>0.155194</td>\n",
+       "      <td>0.995723</td>\n",
+       "      <td>0.720067</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.086010</td>\n",
+       "      <td>0.966131</td>\n",
+       "      <td>0.226601</td>\n",
+       "      <td>0.598075</td>\n",
+       "      <td>0.219305</td>\n",
+       "      <td>0.470830</td>\n",
+       "      <td>0.220079</td>\n",
+       "      <td>0.614120</td>\n",
+       "      <td>0.026265</td>\n",
+       "      <td>0.934942</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28518</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.775572</td>\n",
+       "      <td>0.517579</td>\n",
+       "      <td>0.012821</td>\n",
+       "      <td>0.999378</td>\n",
+       "      <td>0.704168</td>\n",
+       "      <td>0.404210</td>\n",
+       "      <td>0.162908</td>\n",
+       "      <td>0.995909</td>\n",
+       "      <td>0.730823</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.070911</td>\n",
+       "      <td>0.967070</td>\n",
+       "      <td>0.238810</td>\n",
+       "      <td>0.610591</td>\n",
+       "      <td>0.198591</td>\n",
+       "      <td>0.496140</td>\n",
+       "      <td>0.228907</td>\n",
+       "      <td>0.625559</td>\n",
+       "      <td>0.018591</td>\n",
+       "      <td>0.938905</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28519</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.790600</td>\n",
+       "      <td>0.498958</td>\n",
+       "      <td>0.007789</td>\n",
+       "      <td>0.999467</td>\n",
+       "      <td>0.710651</td>\n",
+       "      <td>0.394019</td>\n",
+       "      <td>0.164441</td>\n",
+       "      <td>0.996123</td>\n",
+       "      <td>0.736771</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.085872</td>\n",
+       "      <td>0.967943</td>\n",
+       "      <td>0.238197</td>\n",
+       "      <td>0.609329</td>\n",
+       "      <td>0.233198</td>\n",
+       "      <td>0.510583</td>\n",
+       "      <td>0.227823</td>\n",
+       "      <td>0.626068</td>\n",
+       "      <td>0.036127</td>\n",
+       "      <td>0.940917</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3 rows × 69 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      label    nose_x    nose_y    nose_z    nose_v  left_shoulder_x  \\\n",
+       "28517     1  0.735630  0.543294  0.007467  0.999246         0.695831   \n",
+       "28518     1  0.775572  0.517579  0.012821  0.999378         0.704168   \n",
+       "28519     1  0.790600  0.498958  0.007789  0.999467         0.710651   \n",
+       "\n",
+       "       left_shoulder_y  left_shoulder_z  left_shoulder_v  right_shoulder_x  \\\n",
+       "28517         0.417349         0.155194         0.995723          0.720067   \n",
+       "28518         0.404210         0.162908         0.995909          0.730823   \n",
+       "28519         0.394019         0.164441         0.996123          0.736771   \n",
+       "\n",
+       "       ...  right_heel_z  right_heel_v  left_foot_index_x  left_foot_index_y  \\\n",
+       "28517  ...      0.086010      0.966131           0.226601           0.598075   \n",
+       "28518  ...      0.070911      0.967070           0.238810           0.610591   \n",
+       "28519  ...      0.085872      0.967943           0.238197           0.609329   \n",
+       "\n",
+       "       left_foot_index_z  left_foot_index_v  right_foot_index_x  \\\n",
+       "28517           0.219305           0.470830            0.220079   \n",
+       "28518           0.198591           0.496140            0.228907   \n",
+       "28519           0.233198           0.510583            0.227823   \n",
+       "\n",
+       "       right_foot_index_y  right_foot_index_z  right_foot_index_v  \n",
+       "28517            0.614120            0.026265            0.934942  \n",
+       "28518            0.625559            0.018591            0.938905  \n",
+       "28519            0.626068            0.036127            0.940917  \n",
+       "\n",
+       "[3 rows x 69 columns]"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = describe_dataset(\"./train.csv\")\n",
+    "df.loc[df[\"label\"] == \"C\", \"label\"] = 0\n",
+    "df.loc[df[\"label\"] == \"H\", \"label\"] = 1\n",
+    "df.loc[df[\"label\"] == \"L\", \"label\"] = 2\n",
+    "df.tail(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract features and class\n",
+    "X = df.drop(\"label\", axis=1)\n",
+    "y = df[\"label\"].astype(\"int\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sc = StandardScaler()\n",
+    "X = pd.DataFrame(sc.fit_transform(X))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1469    0\n",
+       "292     0\n",
+       "1568    0\n",
+       "Name: label, dtype: int64"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)\n",
+    "y_test.head(3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.2. Train model using Scikit-Learn and train set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "algorithms =[(\"LR\", LogisticRegression()),\n",
+    "         (\"SVC\", SVC(probability=True)),\n",
+    "         ('KNN',KNeighborsClassifier()),\n",
+    "         (\"DTC\", DecisionTreeClassifier()),\n",
+    "         (\"SGDC\", CalibratedClassifierCV(SGDClassifier())),\n",
+    "         (\"NB\", GaussianNB()),\n",
+    "         ('RF', RandomForestClassifier()),]\n",
+    "\n",
+    "models = {}\n",
+    "final_results = []\n",
+    "\n",
+    "for name, model in algorithms:\n",
+    "    trained_model = model.fit(X_train, y_train)\n",
+    "    models[name] = trained_model\n",
+    "\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(X_test)\n",
+    "\n",
+    "    p_score = precision_score(y_test, model_results, average=None, labels=[0, 1, 2])\n",
+    "    a_score = accuracy_score(y_test, model_results)\n",
+    "    r_score = recall_score(y_test, model_results, average=None, labels=[0, 1, 2])\n",
+    "    f1_score_result = f1_score(y_test, model_results, average=None, labels=[0, 1, 2])\n",
+    "    cm = confusion_matrix(y_test, model_results, labels=[0, 1, 2])\n",
+    "    final_results.append(( name,  round_up_metric_results(p_score), a_score, round_up_metric_results(r_score), round_up_metric_results(f1_score_result), cm))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "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>Accuracy score</th>\n",
+       "      <th>Recall 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.999, 1.0, 1.0]</td>\n",
+       "      <td>0.999825</td>\n",
+       "      <td>[1.0, 1.0, 0.999]</td>\n",
+       "      <td>[1.0, 1.0, 1.0]</td>\n",
+       "      <td>[[1915, 0, 0], [0, 1844, 0], [1, 0, 1944]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>LR</td>\n",
+       "      <td>[0.999, 1.0, 0.999]</td>\n",
+       "      <td>0.999649</td>\n",
+       "      <td>[0.999, 1.0, 0.999]</td>\n",
+       "      <td>[0.999, 1.0, 0.999]</td>\n",
+       "      <td>[[1914, 0, 1], [0, 1844, 0], [1, 0, 1944]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>[0.998, 1.0, 0.999]</td>\n",
+       "      <td>0.999299</td>\n",
+       "      <td>[0.999, 1.0, 0.998]</td>\n",
+       "      <td>[0.999, 1.0, 0.999]</td>\n",
+       "      <td>[[1914, 0, 1], [0, 1844, 0], [3, 0, 1942]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>[0.998, 1.0, 1.0]</td>\n",
+       "      <td>0.999474</td>\n",
+       "      <td>[1.0, 0.999, 0.999]</td>\n",
+       "      <td>[0.999, 1.0, 0.999]</td>\n",
+       "      <td>[[1915, 0, 0], [1, 1843, 0], [2, 0, 1943]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>[0.999, 0.998, 0.999]</td>\n",
+       "      <td>0.998597</td>\n",
+       "      <td>[0.997, 1.0, 0.999]</td>\n",
+       "      <td>[0.998, 0.999, 0.999]</td>\n",
+       "      <td>[[1909, 4, 2], [0, 1844, 0], [2, 0, 1943]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>[0.994, 1.0, 0.999]</td>\n",
+       "      <td>0.997721</td>\n",
+       "      <td>[0.999, 0.998, 0.995]</td>\n",
+       "      <td>[0.997, 0.999, 0.997]</td>\n",
+       "      <td>[[1914, 0, 1], [3, 1841, 0], [9, 0, 1936]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>[0.816, 0.931, 0.941]</td>\n",
+       "      <td>0.892532</td>\n",
+       "      <td>[0.883, 0.951, 0.847]</td>\n",
+       "      <td>[0.848, 0.941, 0.892]</td>\n",
+       "      <td>[[1690, 122, 103], [91, 1753, 0], [290, 7, 1648]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model        Precision Score  Accuracy score           Recall Score  \\\n",
+       "0   KNN      [0.999, 1.0, 1.0]        0.999825      [1.0, 1.0, 0.999]   \n",
+       "1    LR    [0.999, 1.0, 0.999]        0.999649    [0.999, 1.0, 0.999]   \n",
+       "2   SVC    [0.998, 1.0, 0.999]        0.999299    [0.999, 1.0, 0.998]   \n",
+       "3    RF      [0.998, 1.0, 1.0]        0.999474    [1.0, 0.999, 0.999]   \n",
+       "4  SGDC  [0.999, 0.998, 0.999]        0.998597    [0.997, 1.0, 0.999]   \n",
+       "5   DTC    [0.994, 1.0, 0.999]        0.997721  [0.999, 0.998, 0.995]   \n",
+       "6    NB  [0.816, 0.931, 0.941]        0.892532  [0.883, 0.951, 0.847]   \n",
+       "\n",
+       "                F1 score                                   Confusion Matrix  \n",
+       "0        [1.0, 1.0, 1.0]         [[1915, 0, 0], [0, 1844, 0], [1, 0, 1944]]  \n",
+       "1    [0.999, 1.0, 0.999]         [[1914, 0, 1], [0, 1844, 0], [1, 0, 1944]]  \n",
+       "2    [0.999, 1.0, 0.999]         [[1914, 0, 1], [0, 1844, 0], [3, 0, 1942]]  \n",
+       "3    [0.999, 1.0, 0.999]         [[1915, 0, 0], [1, 1843, 0], [2, 0, 1943]]  \n",
+       "4  [0.998, 0.999, 0.999]         [[1909, 4, 2], [0, 1844, 0], [2, 0, 1943]]  \n",
+       "5  [0.997, 0.999, 0.997]         [[1914, 0, 1], [3, 1841, 0], [9, 0, 1936]]  \n",
+       "6  [0.848, 0.941, 0.892]  [[1690, 122, 103], [91, 1753, 0], [290, 7, 1648]]  "
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Sort results by F1 score\n",
+    "final_results.sort(key=lambda k: sum(k[4]), reverse=True)\n",
+    "\n",
+    "pd.DataFrame(final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.3. Test set evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "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', 'left_elbow_x', 'left_elbow_y', 'left_elbow_z', 'left_elbow_v', 'right_elbow_x', 'right_elbow_y', 'right_elbow_z', 'right_elbow_v', 'left_wrist_x', 'left_wrist_y', 'left_wrist_z', 'left_wrist_v', 'right_wrist_x', 'right_wrist_y', 'right_wrist_z', 'right_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', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n",
+      "Number of rows: 710 \n",
+      "Number of columns: 69\n",
+      "\n",
+      "Labels: \n",
+      "H    241\n",
+      "L    235\n",
+      "C    234\n",
+      "Name: label, dtype: int64\n",
+      "\n",
+      "Missing values: False\n",
+      "\n",
+      "Duplicate Rows : 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_df = describe_dataset(\"./test.csv\")\n",
+    "test_df = test_df.sample(frac=1).reset_index(drop=True)\n",
+    "\n",
+    "test_df.loc[test_df[\"label\"] == \"C\", \"label\"] = 0\n",
+    "test_df.loc[test_df[\"label\"] == \"H\", \"label\"] = 1\n",
+    "test_df.loc[test_df[\"label\"] == \"L\", \"label\"] = 2\n",
+    "\n",
+    "test_x = test_df.drop(\"label\", axis=1)\n",
+    "test_y = test_df[\"label\"].astype(\"int\")\n",
+    "\n",
+    "test_x = pd.DataFrame(sc.transform(test_x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "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>Accuracy score</th>\n",
+       "      <th>Recall 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.987, 1.0, 1.0]</td>\n",
+       "      <td>0.995775</td>\n",
+       "      <td>[1.0, 0.996, 0.991]</td>\n",
+       "      <td>[0.994, 0.998, 0.996]</td>\n",
+       "      <td>[[234, 0, 0], [1, 240, 0], [2, 0, 233]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>SVC</td>\n",
+       "      <td>[0.963, 1.0, 1.0]</td>\n",
+       "      <td>0.987324</td>\n",
+       "      <td>[1.0, 0.992, 0.97]</td>\n",
+       "      <td>[0.981, 0.996, 0.985]</td>\n",
+       "      <td>[[234, 0, 0], [2, 239, 0], [7, 0, 228]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>SGDC</td>\n",
+       "      <td>[0.974, 0.975, 0.996]</td>\n",
+       "      <td>0.981690</td>\n",
+       "      <td>[0.974, 0.983, 0.987]</td>\n",
+       "      <td>[0.974, 0.979, 0.991]</td>\n",
+       "      <td>[[228, 6, 0], [3, 237, 1], [3, 0, 232]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>KNN</td>\n",
+       "      <td>[0.869, 0.996, 1.0]</td>\n",
+       "      <td>0.949296</td>\n",
+       "      <td>[0.996, 0.992, 0.86]</td>\n",
+       "      <td>[0.928, 0.994, 0.924]</td>\n",
+       "      <td>[[233, 1, 0], [2, 239, 0], [33, 0, 202]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>RF</td>\n",
+       "      <td>[0.765, 1.0, 1.0]</td>\n",
+       "      <td>0.898592</td>\n",
+       "      <td>[1.0, 1.0, 0.694]</td>\n",
+       "      <td>[0.867, 1.0, 0.819]</td>\n",
+       "      <td>[[234, 0, 0], [0, 241, 0], [72, 0, 163]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>NB</td>\n",
+       "      <td>[0.892, 0.737, 0.945]</td>\n",
+       "      <td>0.842254</td>\n",
+       "      <td>[0.632, 0.942, 0.949]</td>\n",
+       "      <td>[0.74, 0.827, 0.947]</td>\n",
+       "      <td>[[148, 73, 13], [14, 227, 0], [4, 8, 223]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>DTC</td>\n",
+       "      <td>[0.69, 1.0, 0.625]</td>\n",
+       "      <td>0.767606</td>\n",
+       "      <td>[0.543, 0.988, 0.766]</td>\n",
+       "      <td>[0.608, 0.994, 0.688]</td>\n",
+       "      <td>[[127, 0, 107], [2, 238, 1], [55, 0, 180]]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Model        Precision Score  Accuracy score           Recall Score  \\\n",
+       "0    LR      [0.987, 1.0, 1.0]        0.995775    [1.0, 0.996, 0.991]   \n",
+       "1   SVC      [0.963, 1.0, 1.0]        0.987324     [1.0, 0.992, 0.97]   \n",
+       "2  SGDC  [0.974, 0.975, 0.996]        0.981690  [0.974, 0.983, 0.987]   \n",
+       "3   KNN    [0.869, 0.996, 1.0]        0.949296   [0.996, 0.992, 0.86]   \n",
+       "4    RF      [0.765, 1.0, 1.0]        0.898592      [1.0, 1.0, 0.694]   \n",
+       "5    NB  [0.892, 0.737, 0.945]        0.842254  [0.632, 0.942, 0.949]   \n",
+       "6   DTC     [0.69, 1.0, 0.625]        0.767606  [0.543, 0.988, 0.766]   \n",
+       "\n",
+       "                F1 score                            Confusion Matrix  \n",
+       "0  [0.994, 0.998, 0.996]     [[234, 0, 0], [1, 240, 0], [2, 0, 233]]  \n",
+       "1  [0.981, 0.996, 0.985]     [[234, 0, 0], [2, 239, 0], [7, 0, 228]]  \n",
+       "2  [0.974, 0.979, 0.991]     [[228, 6, 0], [3, 237, 1], [3, 0, 232]]  \n",
+       "3  [0.928, 0.994, 0.924]    [[233, 1, 0], [2, 239, 0], [33, 0, 202]]  \n",
+       "4    [0.867, 1.0, 0.819]    [[234, 0, 0], [0, 241, 0], [72, 0, 163]]  \n",
+       "5   [0.74, 0.827, 0.947]  [[148, 73, 13], [14, 227, 0], [4, 8, 223]]  \n",
+       "6  [0.608, 0.994, 0.688]  [[127, 0, 107], [2, 238, 1], [55, 0, 180]]  "
+      ]
+     },
+     "execution_count": 70,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "testset_final_results = []\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    # Evaluate model\n",
+    "    model_results = model.predict(test_x)\n",
+    "\n",
+    "    p_score = precision_score(test_y, model_results, average=None, labels=[0, 1, 2])\n",
+    "    a_score = accuracy_score(test_y, model_results)\n",
+    "    r_score = recall_score(test_y, model_results, average=None, labels=[0, 1, 2])\n",
+    "    f1_score_result = f1_score(test_y, model_results, average=None, labels=[0, 1, 2])\n",
+    "    cm = confusion_matrix(test_y, model_results, labels=[0, 1, 2])\n",
+    "    testset_final_results.append(( name,  round_up_metric_results(p_score), a_score, round_up_metric_results(r_score), round_up_metric_results(f1_score_result), cm ))\n",
+    "\n",
+    "\n",
+    "testset_final_results.sort(key=lambda k: sum(k[4]), reverse=True)\n",
+    "pd.DataFrame(testset_final_results, columns=[\"Model\", \"Precision Score\", \"Accuracy score\", \"Recall Score\", \"F1 score\", \"Confusion Matrix\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.4. Dumped model and input scaler using pickle\n",
+    "\n",
+    "According to the evaluations, there are multiple good models at the moment, therefore, the best models are LR and Ridge."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/all_sklearn.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models, f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/LR_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"LR\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"./model/SVC_model.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(models[\"SVC\"], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Dump input scaler\n",
+    "with open(\"./model/input_scaler.pkl\", \"wb\") as f:\n",
+    "    pickle.dump(sc, f)"
+   ]
+  }
+ ],
+ "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
+}