Main_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# First section"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\41794\\anaconda3\\envs\\ada\\Lib\\site-packages\\torchvision\\io\\image.py:13: UserWarning: Failed to load image Python extension: '[WinError 127] La procédure spécifiée est introuvable'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n",
      "  warn(\n"
     ]
    }
   ],
   "source": [
    "import helpers\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset,TensorDataset\n",
    "from torch.optim import lr_scheduler\n",
    "import pandas as pd"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "id": "uYd4BrSRyxxu",
   "metadata": {
    "id": "uYd4BrSRyxxu"
   },
   "outputs": [],
   "source": [
    "# Import preprocessed dataset\n",
    "train_path = 'Datasets/train_set_augmented.parquet'\n",
    "test_path = 'Datasets/test_set.parquet'\n",
    "\n",
    "# Import trained models\n",
    "exercise_model_path = 'paths/MLPEX_trained.path'\n",
    "set_model_path = 'paths/PhysioMLP_trained.path'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "# Set variable to True if you want to retrain the models. Otherwise, it will print accuracies based on our saved models.\n",
    "train_eval = False\n",
    "\n",
    "# Decide if you want to train on augmented or not augmented train set. We recommend that you keep it to True, since it yields better results\n",
    "is_augmented = True\n",
    "\n",
    "train_df = pd.read_parquet(train_path, engine='pyarrow')\n",
    "test_df = pd.read_parquet(test_path, engine='pyarrow')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "exercise_mapping = {\n",
    "    'Abduction': 0,\n",
    "    'Bird': 1,\n",
    "    'Bridge': 2,\n",
    "    'Knee': 3,\n",
    "    'Shoulder': 4,\n",
    "    'Squat': 5,\n",
    "    'Stretch': 6\n",
    "}\n",
    "set_mapping = {\n",
    "    'Correct' : 0,\n",
    "    'A': 1,\n",
    "    'B': 2,\n",
    "    'C': 3,\n",
    "    'D': 4,\n",
    "    'E': 5,\n",
    "    'F': 6\n",
    "}"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "iGK8DAIxqmQE",
   "metadata": {
    "id": "iGK8DAIxqmQE"
   },
   "outputs": [],
   "source": [
    "video_indices = test_df.groupby('video_id').size().values\n",
    "video_indices = np.insert(video_indices, 0, 0)\n",
    "video_indices = np.cumsum(video_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "We define the two models"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "LQSJUeklXg32",
   "metadata": {
    "id": "LQSJUeklXg32"
   },
   "outputs": [],
   "source": [
    "get_mlp3x256 = lambda: torch.nn.Sequential(\n",
    "\n",
    "    torch.nn.Flatten(),\n",
    "    torch.nn.Linear(100, 256),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(256, 256),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(256, 256),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(256, 256),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(256, 7),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bdHQHrzx4wdq",
   "metadata": {
    "id": "bdHQHrzx4wdq"
   },
   "outputs": [],
   "source": [
    "get_physio_mlp = lambda: torch.nn.Sequential(\n",
    "\n",
    "    nn.Flatten(),\n",
    "    nn.Linear(107, 512),\n",
    "    nn.BatchNorm1d(512),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.3),\n",
    "    nn.Linear(512, 512),\n",
    "    nn.BatchNorm1d(512),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.3),\n",
    "    nn.Linear(512, 512),\n",
    "    nn.BatchNorm1d(512),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.3),\n",
    "    nn.Linear(512, 512),\n",
    "    nn.BatchNorm1d(512),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(512, 7)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "g7I_TUn5wXRx",
   "metadata": {
    "id": "g7I_TUn5wXRx"
   },
   "source": [
    "# Training the model to predict exercises\n",
    "We first split the train and test set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "BcRVUlhaseFY",
   "metadata": {
    "id": "BcRVUlhaseFY"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = helpers.import_data_exercise(train_df, test_df, exercise_mapping, is_augmented)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pa17ibuZYBAb",
   "metadata": {
    "id": "pa17ibuZYBAb"
   },
   "source": [
    "We then define everything we need to train our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "suffering-nudist",
   "metadata": {
    "id": "suffering-nudist"
   },
   "outputs": [],
   "source": [
    "#Defines hyperparameters\n",
    "learning_rate = 2e-3\n",
    "batch_size = 128\n",
    "\n",
    "# Creates an instance of the dataset\n",
    "dataset = TensorDataset(X_train, y_train)\n",
    "\n",
    "# Creates a DataLoader\n",
    "dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "# Defines the model\n",
    "model = get_mlp3x256()\n",
    "model.train()\n",
    "\n",
    "# Defines the path to save the model's state dictionnary\n",
    "model_path = 'MLPEX.path'\n",
    "\n",
    "# Defines loss function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Creates an optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Creates a scheduler\n",
    "scheduler = lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "-Ve3LpE1Zndd",
   "metadata": {
    "id": "-Ve3LpE1Zndd"
   },
   "source": [
    "We procede to train the model. It converges to sufficiently trained state to perform 100% accuracy on test set in a single iteration. Note that the already trained model state dictionnary can be loaded from the path 'MLPEX_trained.path' by uncommenting the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2Ft7Cfhubd-J",
   "metadata": {
    "id": "2Ft7Cfhubd-J"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on each frame: 0.9606\n",
      "Accuracy for videos: 1.0000\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        60\n",
      "           1       1.00      1.00      1.00        60\n",
      "           2       1.00      1.00      1.00        60\n",
      "           3       1.00      1.00      1.00        60\n",
      "           4       1.00      1.00      1.00        60\n",
      "           5       1.00      1.00      1.00        60\n",
      "           6       1.00      1.00      1.00        60\n",
      "\n",
      "    accuracy                           1.00       420\n",
      "   macro avg       1.00      1.00      1.00       420\n",
      "weighted avg       1.00      1.00      1.00       420\n",
      "\n"
     ]
    }
   ],
   "source": [
    "if not train_eval:\n",
    "    model.load_state_dict(torch.load(exercise_model_path))\n",
    "    # Test accuracy\n",
    "    helpers.test_accuracy(model, X_test,y_test,video_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "armed-trail",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 470
    },
    "executionInfo": {
     "elapsed": 8931,
     "status": "error",
     "timestamp": 1702921904743,
     "user": {
      "displayName": "baptiste maquignaz",
      "userId": "09858058211747966059"
     },
     "user_tz": -60
    },
    "id": "armed-trail",
    "outputId": "8892f81c-e661-4727-fb43-8bc0de55fdd2"
   },
   "outputs": [],
   "source": [
    "if train_eval:\n",
    "    # Trains the model\n",
    "    helpers.train_model(1, model, optimizer, criterion, dataloader, scheduler, model_path)\n",
    "\n",
    "    # Prints a report on the accuracy and F1 score\n",
    "    helpers.test_accuracy(model, X_test,y_test,video_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "C9M6v2fhwm0S",
   "metadata": {
    "id": "C9M6v2fhwm0S"
   },
   "source": [
    "# Training of PhysioMLP to predict sets\n",
    "\n",
    "We first split the train and test set, this time we one-hot encoded our predictions of the exercise in the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ShqlDMUXutXg",
   "metadata": {
    "id": "ShqlDMUXutXg"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = helpers.import_data_set(train_df, test_df, set_mapping, is_augmented)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "NtUqeJc4583a",
   "metadata": {
    "id": "NtUqeJc4583a"
   },
   "outputs": [],
   "source": [
    "#Defines hyperparameters\n",
    "learning_rate = 0.001\n",
    "batch_size = 128\n",
    "\n",
    "# Creates an instance of the dataset\n",
    "dataset = TensorDataset(X_train, y_train)\n",
    "\n",
    "# Creates a DataLoader\n",
    "dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "# Defines the model\n",
    "model = get_physio_mlp()\n",
    "model.train()\n",
    "\n",
    "# Defines the path to save the model's state dictionnary\n",
    "model_path = 'PhysioMLP.path'\n",
    "\n",
    "# Defines loss function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Creates an optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Creates a scheduler\n",
    "scheduler = lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3fa258fc-8d8a-4f11-a9a8-aedc87a7c83d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on each frame: 0.4033\n",
      "Accuracy for videos: 0.5905\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.58      0.67      0.62       140\n",
      "           1       0.64      0.58      0.61        76\n",
      "           2       0.62      0.58      0.60        72\n",
      "           3       0.60      0.52      0.55        64\n",
      "           4       0.62      0.53      0.57        40\n",
      "           5       0.45      0.56      0.50        16\n",
      "           6       0.42      0.42      0.42        12\n",
      "\n",
      "    accuracy                           0.59       420\n",
      "   macro avg       0.56      0.55      0.55       420\n",
      "weighted avg       0.59      0.59      0.59       420\n",
      "\n"
     ]
    }
   ],
   "source": [
    "if not train_eval:\n",
    "    model.load_state_dict(torch.load(set_model_path))\n",
    "    helpers.test_accuracy(model, X_test,y_test,video_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "EZiRAlm45-jE",
   "metadata": {
    "colab": {
     "background_save": true,
     "base_uri": "https://localhost:8080/"
    },
    "id": "EZiRAlm45-jE",
    "outputId": "d64ab15b-1dd8-4099-a4af-5214c0621528"
   },
   "outputs": [],
   "source": [
    "if train_eval:\n",
    "    for i in range(30):\n",
    "      # Trains the model\n",
    "      helpers.train_model(1, model, optimizer, criterion, dataloader, scheduler, model_path)\n",
    "      # Prints a report on the accuracy and F1 score\n",
    "      helpers.test_accuracy(model, X_test,y_test,video_indices)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "name": "conda-env-ada-py",
   "language": "python",
   "display_name": "Python [conda env:ada] *"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}