VRTL-classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import animation, rc\n",
    "from IPython.display import HTML\n",
    "import imageio\n",
    "import os\n",
    "import glob\n",
    "import matplotlib.pyplot as plt\n",
    "import json\n",
    "from mpl_toolkits.mplot3d import Axes3D \n",
    "from matplotlib import animation, rc, cm\n",
    "import seaborn as sns\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n",
    "from tensorflow.keras.regularizers import l2\n",
    "from keras_self_attention import SeqSelfAttention\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "model = load_model('/Users/catherinekim/Desktop/VRTL/best_model.keras')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ready input file for classifier\n",
    "\n",
    "direc = '/Users/catherinekim/Desktop/VRTL'\n",
    "participants = ['VRTL3', 'VRTL6', 'VRTL9', 'VRTL10', 'VRTL11']\n",
    "#participants = ['VRTL3']\n",
    "session_label = ['S3','S4']\n",
    "camera = 'Camera6'\n",
    "\n",
    "entire_data = []\n",
    "# Loop through each participant to extract the S4 entropy\n",
    "for participant in participants:\n",
    "    # Construct the file path for each participant's entropy file\n",
    "    for session in session_label:\n",
    "        file_path = f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}{session}_{camera}.csv\"\n",
    "        data = pd.read_csv(file_path)\n",
    "\n",
    "        label = 0 if session == 'S3' else 1 #label 0 = X zombie; label 1= zombie\n",
    "\n",
    "        #adding columns\n",
    "        data['label'] = label\n",
    "        data['participant'] = participant\n",
    "        data['session'] = session\n",
    "\n",
    "        filtered_data = data[['participant','timepoint', 'x_pos_pixel','y_pos_pixel','session','label']]\n",
    "        \n",
    "        entire_data.append(filtered_data)\n",
    "    \n",
    "combined_data = pd.concat(entire_data, ignore_index = True)\n",
    "#output_file = f\"{direc}/VRTL_input_classifier.csv\"\n",
    "#combined_data.to_csv(output_file, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input file for S5 + S6\n",
    "\n",
    "direc = '/Users/catherinekim/Desktop/VRTL'\n",
    "participants = ['VRTL3', 'VRTL6', 'VRTL7','VRTL8', 'VRTL9','VRTL10', 'VRTL11']\n",
    "#participants = ['VRTL3']\n",
    "flip_label = ['VRTL6','VRTL8','VRTL9','VRTL10']\n",
    "session_label = ['S5','S6']\n",
    "camera = 'Camera6'\n",
    "\n",
    "# Dictionary to store data for easy access and analysis\n",
    "session_A = [] #temporally distant \n",
    "session_B = [] #temporally closer\n",
    "\n",
    "# Loop through each participant to extract the S4 entropy\n",
    "for participant in participants:\n",
    "    if participant in flip_label: \n",
    "        #path_session_B = f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S5_{camera}.csv\"\n",
    "        #session_A = f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S6_{camera}.csv\"\n",
    "        participant_sessionB = pd.read_csv(f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S5_{camera}.csv\")\n",
    "        participant_sessionA = pd.read_csv(f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S6_{camera}.csv\")\n",
    "        participant_sessionB['participant'] = participant\n",
    "        participant_sessionA['participant'] = participant\n",
    "        \n",
    "    else:\n",
    "        participant_sessionA = pd.read_csv(f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S5_{camera}.csv\")\n",
    "        participant_sessionB = pd.read_csv(f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}S6_{camera}.csv\")\n",
    "        participant_sessionB['participant'] = participant\n",
    "        participant_sessionA['participant'] = participant\n",
    "        \n",
    "    session_A.append(participant_sessionA)\n",
    "    session_B.append(participant_sessionB)\n",
    "\n",
    "combined_sessionA = pd.concat(session_A, ignore_index = True)\n",
    "combined_sessionB = pd.concat(session_B, ignore_index = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test S1 + S2\n",
    "\n",
    "direc = '/Users/catherinekim/Desktop/VRTL'\n",
    "participants = ['VRTL3', 'VRTL6', 'VRTL8', 'VRTL9', 'VRTL10', 'VRTL11']\n",
    "#participants = ['VRTL3']\n",
    "session_label = ['S1','S2']\n",
    "camera = 'Camera6'\n",
    "\n",
    "entire_data = []\n",
    "# Loop through each participant to extract the S4 entropy\n",
    "for participant in participants:\n",
    "    # Construct the file path for each participant's entropy file\n",
    "    for session in session_label:\n",
    "        file_path = f\"{direc}/{participant}/eyetracking/preprocessed/preprocessed_{participant}{session}_{camera}.csv\"\n",
    "        data = pd.read_csv(file_path)\n",
    "        data['participant'] = participant\n",
    "\n",
    "        filtered_data = data[['participant','timepoint', 'x_pos_pixel','y_pos_pixel']]\n",
    "        \n",
    "        entire_data.append(filtered_data)\n",
    "    \n",
    "S1_S2_combined_data = pd.concat(entire_data, ignore_index = True)\n",
    "#output_file = f\"{direc}/VRTL_input_classifier.csv\"\n",
    "#combined_data.to_csv(output_file, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_sequences(data, sequence_length=1500, stride=40):\n",
    "    grouped_data = data.groupby('participant')  # Group by participants\n",
    "    sequences = []\n",
    "    scaler = MinMaxScaler()\n",
    "\n",
    "    # Iterate through each participant's data\n",
    "    for participant, group in grouped_data:\n",
    "        # Extract features\n",
    "        features = group[['timepoint', 'x_pos_pixel', 'y_pos_pixel']].values\n",
    "        features_scaled = scaler.fit_transform(features)\n",
    "\n",
    "        # Create sequences using a sliding window\n",
    "        for i in range(0, len(features_scaled) - sequence_length + 1, stride):\n",
    "            sequence = features_scaled[i:i+sequence_length]\n",
    "            sequences.append(sequence)\n",
    "    \n",
    "    return np.array(sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m59/59\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 363ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.41305277, 0.58694744], dtype=float32)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences = create_sequences(S1_S2_combined_data)\n",
    "probabilities_S1S2 = model.predict(sequences)\n",
    "np.mean(probabilities_S1S2,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.33287635, 0.6671238 ], dtype=float32)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m28/28\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 396ms/step\n",
      "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 399ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/catherinekim/Library/Python/3.9/lib/python/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Users/catherinekim/Library/Python/3.9/lib/python/site-packages/numpy/core/_methods.py:121: RuntimeWarning: invalid value encountered in divide\n",
      "  ret = um.true_divide(\n"
     ]
    }
   ],
   "source": [
    "sequences_sessionA = create_sequences(combined_sessionA)\n",
    "sequences_sessionB = create_sequences(combined_sessionB)\n",
    "\n",
    "probabilities_sessionA = model.predict(sequences_sessionA) #temporally distant\n",
    "probabilities_sessionB = model.predict(sequences_sessionB) #temporally closer\n",
    "\n",
    "avg_probabilities_sessionA = np.mean(probabilities_sessionA[len(probabilities_sessionA):], axis=0)\n",
    "avg_probabilities_sessionB = np.mean(probabilities_sessionB[len(probabilities_sessionB):], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nan nan]\n",
      "[nan nan]\n"
     ]
    }
   ],
   "source": [
    "print(avg_probabilities_sessionA)\n",
    "print(avg_probabilities_sessionB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Count'>"
      ]
     },
     "execution_count": 43,
     "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.histplot(probabilities_sessionA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Count'>"
      ]
     },
     "execution_count": 44,
     "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.histplot(probabilities_sessionB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Session A Probabilities (for labels 0 and 1):\n",
      "[0.28827178 0.7117288 ]\n",
      "Session B Probabilities (for labels 0 and 1):\n",
      "[0.2846849 0.7153155]\n"
     ]
    }
   ],
   "source": [
    "# Print results\n",
    "\n",
    "avg_probabilities_sessionA = np.mean(probabilities_sessionA, axis=0)\n",
    "avg_probabilities_sessionB = np.mean(probabilities_sessionB, axis=0)\n",
    "\n",
    "print(\"Session A Probabilities (for labels 0 and 1):\")\n",
    "print(avg_probabilities_sessionA)\n",
    "print(\"Session B Probabilities (for labels 0 and 1):\")\n",
    "print(avg_probabilities_sessionB)\n",
    "\n",
    "\n",
    "# print(\"\\nSession 5 Probabilities (for labels 0 and 1):\")\n",
    "# print(probabilities_sessionB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = combined_data[['timepoint','x_pos_pixel', 'y_pos_pixel']].values\n",
    "y = combined_data['label'].values\n",
    "\n",
    "#normalize to improve model performance\n",
    "scaler = MinMaxScaler()\n",
    "X = scaler.fit_transform(X)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_data = combined_data.groupby(['participant']) #group by participants\n",
    "\n",
    "#sequence_length = 2500 # change length for contextual information The zombie sequence is around 3000\n",
    "sequence_length = 2500\n",
    "stride = 40\n",
    "\n",
    "X_sequences = []\n",
    "y_labels = []\n",
    "\n",
    "for participant, group in grouped_data: #RNN- creating sequences seperating participants\n",
    "    # Extract features and labels for this participant\n",
    "    X_participant = group[['timepoint', 'x_pos_pixel', 'y_pos_pixel']].values\n",
    "    y_participant = group['label'].values\n",
    "\n",
    "    # Create sequences for this participant\n",
    "    for i in range(0, len(X_participant) - sequence_length + 1, stride):\n",
    "        sequence = X_participant[i:i+sequence_length]\n",
    "        label = y_participant[i+sequence_length-1]  # Label based on the last time step\n",
    "        X_sequences.append(sequence)\n",
    "        y_labels.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_padded = pad_sequences(X_sequences, padding='post', dtype='float32') #Padding: for LSTM- X needs to have same size\n",
    "y_categorical = to_categorical(y_labels) #convert to one-hot encoding\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train + split data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_padded, y_categorical, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/40\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/catherinekim/Library/Python/3.9/lib/python/site-packages/keras/src/layers/rnn/rnn.py:200: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(**kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.5586 - loss: 0.6788 - precision: 0.5586 - recall: 0.5586\n",
      "Epoch 1: val_loss improved from inf to 0.65076, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m192s\u001b[0m 3s/step - accuracy: 0.5589 - loss: 0.6787 - precision: 0.5589 - recall: 0.5589 - val_accuracy: 0.6720 - val_loss: 0.6508 - val_precision: 0.6720 - val_recall: 0.6720\n",
      "Epoch 2/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.5848 - loss: 0.6686 - precision: 0.5848 - recall: 0.5848\n",
      "Epoch 2: val_loss improved from 0.65076 to 0.62149, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m171s\u001b[0m 3s/step - accuracy: 0.5851 - loss: 0.6684 - precision: 0.5851 - recall: 0.5851 - val_accuracy: 0.7000 - val_loss: 0.6215 - val_precision: 0.7000 - val_recall: 0.7000\n",
      "Epoch 3/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.6685 - loss: 0.6323 - precision: 0.6685 - recall: 0.6685\n",
      "Epoch 3: val_loss improved from 0.62149 to 0.58906, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m185s\u001b[0m 3s/step - accuracy: 0.6687 - loss: 0.6322 - precision: 0.6687 - recall: 0.6687 - val_accuracy: 0.7080 - val_loss: 0.5891 - val_precision: 0.7080 - val_recall: 0.7080\n",
      "Epoch 4/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.6969 - loss: 0.6084 - precision: 0.6969 - recall: 0.6969\n",
      "Epoch 4: val_loss improved from 0.58906 to 0.55361, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m177s\u001b[0m 3s/step - accuracy: 0.6966 - loss: 0.6085 - precision: 0.6966 - recall: 0.6966 - val_accuracy: 0.7280 - val_loss: 0.5536 - val_precision: 0.7280 - val_recall: 0.7280\n",
      "Epoch 5/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.6768 - loss: 0.6038 - precision: 0.6768 - recall: 0.6768\n",
      "Epoch 5: val_loss improved from 0.55361 to 0.51381, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m180s\u001b[0m 3s/step - accuracy: 0.6772 - loss: 0.6037 - precision: 0.6772 - recall: 0.6772 - val_accuracy: 0.8080 - val_loss: 0.5138 - val_precision: 0.8080 - val_recall: 0.8080\n",
      "Epoch 6/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.7390 - loss: 0.5693 - precision: 0.7390 - recall: 0.7390\n",
      "Epoch 6: val_loss improved from 0.51381 to 0.48013, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m184s\u001b[0m 3s/step - accuracy: 0.7386 - loss: 0.5694 - precision: 0.7386 - recall: 0.7386 - val_accuracy: 0.8240 - val_loss: 0.4801 - val_precision: 0.8240 - val_recall: 0.8240\n",
      "Epoch 7/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.7446 - loss: 0.5232 - precision: 0.7446 - recall: 0.7446\n",
      "Epoch 7: val_loss improved from 0.48013 to 0.45673, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m172s\u001b[0m 3s/step - accuracy: 0.7446 - loss: 0.5234 - precision: 0.7446 - recall: 0.7446 - val_accuracy: 0.8000 - val_loss: 0.4567 - val_precision: 0.8000 - val_recall: 0.8000\n",
      "Epoch 8/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.7823 - loss: 0.5123 - precision: 0.7823 - recall: 0.7823\n",
      "Epoch 8: val_loss improved from 0.45673 to 0.43601, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m173s\u001b[0m 3s/step - accuracy: 0.7822 - loss: 0.5122 - precision: 0.7822 - recall: 0.7822 - val_accuracy: 0.8040 - val_loss: 0.4360 - val_precision: 0.8040 - val_recall: 0.8040\n",
      "Epoch 9/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8130 - loss: 0.4691 - precision: 0.8130 - recall: 0.8130\n",
      "Epoch 9: val_loss improved from 0.43601 to 0.38806, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m190s\u001b[0m 3s/step - accuracy: 0.8129 - loss: 0.4692 - precision: 0.8129 - recall: 0.8129 - val_accuracy: 0.8320 - val_loss: 0.3881 - val_precision: 0.8320 - val_recall: 0.8320\n",
      "Epoch 10/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8194 - loss: 0.4305 - precision: 0.8194 - recall: 0.8194\n",
      "Epoch 10: val_loss improved from 0.38806 to 0.38202, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m172s\u001b[0m 3s/step - accuracy: 0.8196 - loss: 0.4304 - precision: 0.8196 - recall: 0.8196 - val_accuracy: 0.8240 - val_loss: 0.3820 - val_precision: 0.8240 - val_recall: 0.8240\n",
      "Epoch 11/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8399 - loss: 0.3884 - precision: 0.8399 - recall: 0.8399\n",
      "Epoch 11: val_loss improved from 0.38202 to 0.35985, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m172s\u001b[0m 3s/step - accuracy: 0.8398 - loss: 0.3886 - precision: 0.8398 - recall: 0.8398 - val_accuracy: 0.8440 - val_loss: 0.3598 - val_precision: 0.8440 - val_recall: 0.8440\n",
      "Epoch 12/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8400 - loss: 0.3991 - precision: 0.8400 - recall: 0.8400\n",
      "Epoch 12: val_loss improved from 0.35985 to 0.35898, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m186s\u001b[0m 3s/step - accuracy: 0.8401 - loss: 0.3989 - precision: 0.8401 - recall: 0.8401 - val_accuracy: 0.8440 - val_loss: 0.3590 - val_precision: 0.8440 - val_recall: 0.8440\n",
      "Epoch 13/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8565 - loss: 0.3610 - precision: 0.8565 - recall: 0.8565\n",
      "Epoch 13: val_loss did not improve from 0.35898\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m184s\u001b[0m 3s/step - accuracy: 0.8565 - loss: 0.3612 - precision: 0.8565 - recall: 0.8565 - val_accuracy: 0.8040 - val_loss: 0.4135 - val_precision: 0.8040 - val_recall: 0.8040\n",
      "Epoch 14/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.8371 - loss: 0.4045 - precision: 0.8371 - recall: 0.8371\n",
      "Epoch 14: val_loss did not improve from 0.35898\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m171s\u001b[0m 3s/step - accuracy: 0.8373 - loss: 0.4044 - precision: 0.8373 - recall: 0.8373 - val_accuracy: 0.8120 - val_loss: 0.4055 - val_precision: 0.8120 - val_recall: 0.8120\n",
      "Epoch 15/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8810 - loss: 0.3393 - precision: 0.8810 - recall: 0.8810\n",
      "Epoch 15: val_loss improved from 0.35898 to 0.30125, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m163s\u001b[0m 3s/step - accuracy: 0.8810 - loss: 0.3393 - precision: 0.8810 - recall: 0.8810 - val_accuracy: 0.8920 - val_loss: 0.3013 - val_precision: 0.8920 - val_recall: 0.8920\n",
      "Epoch 16/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8876 - loss: 0.3221 - precision: 0.8876 - recall: 0.8876\n",
      "Epoch 16: val_loss did not improve from 0.30125\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - accuracy: 0.8875 - loss: 0.3221 - precision: 0.8875 - recall: 0.8875 - val_accuracy: 0.8680 - val_loss: 0.3499 - val_precision: 0.8680 - val_recall: 0.8680\n",
      "Epoch 17/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8914 - loss: 0.3127 - precision: 0.8914 - recall: 0.8914\n",
      "Epoch 17: val_loss did not improve from 0.30125\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m163s\u001b[0m 3s/step - accuracy: 0.8914 - loss: 0.3127 - precision: 0.8914 - recall: 0.8914 - val_accuracy: 0.8760 - val_loss: 0.3513 - val_precision: 0.8760 - val_recall: 0.8760\n",
      "Epoch 18/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8940 - loss: 0.3226 - precision: 0.8940 - recall: 0.8940\n",
      "Epoch 18: val_loss did not improve from 0.30125\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - accuracy: 0.8941 - loss: 0.3225 - precision: 0.8941 - recall: 0.8941 - val_accuracy: 0.8880 - val_loss: 0.3184 - val_precision: 0.8880 - val_recall: 0.8880\n",
      "Epoch 19/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.9055 - loss: 0.2989 - precision: 0.9055 - recall: 0.9055\n",
      "Epoch 19: val_loss improved from 0.30125 to 0.29087, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m157s\u001b[0m 2s/step - accuracy: 0.9054 - loss: 0.2990 - precision: 0.9054 - recall: 0.9054 - val_accuracy: 0.9080 - val_loss: 0.2909 - val_precision: 0.9080 - val_recall: 0.9080\n",
      "Epoch 20/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8962 - loss: 0.2980 - precision: 0.8962 - recall: 0.8962\n",
      "Epoch 20: val_loss did not improve from 0.29087\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - accuracy: 0.8962 - loss: 0.2979 - precision: 0.8962 - recall: 0.8962 - val_accuracy: 0.8960 - val_loss: 0.2981 - val_precision: 0.8960 - val_recall: 0.8960\n",
      "Epoch 21/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.8834 - loss: 0.3141 - precision: 0.8834 - recall: 0.8834\n",
      "Epoch 21: val_loss improved from 0.29087 to 0.25663, saving model to best_model.keras\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - accuracy: 0.8837 - loss: 0.3138 - precision: 0.8837 - recall: 0.8837 - val_accuracy: 0.9160 - val_loss: 0.2566 - val_precision: 0.9160 - val_recall: 0.9160\n",
      "Epoch 22/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2s/step - accuracy: 0.9297 - loss: 0.2616 - precision: 0.9297 - recall: 0.9297\n",
      "Epoch 22: val_loss did not improve from 0.25663\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m162s\u001b[0m 3s/step - accuracy: 0.9295 - loss: 0.2618 - precision: 0.9295 - recall: 0.9295 - val_accuracy: 0.8960 - val_loss: 0.3047 - val_precision: 0.8960 - val_recall: 0.8960\n",
      "Epoch 23/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.9121 - loss: 0.2631 - precision: 0.9121 - recall: 0.9121\n",
      "Epoch 23: val_loss did not improve from 0.25663\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m174s\u001b[0m 3s/step - accuracy: 0.9119 - loss: 0.2638 - precision: 0.9119 - recall: 0.9119 - val_accuracy: 0.9080 - val_loss: 0.2821 - val_precision: 0.9080 - val_recall: 0.9080\n",
      "Epoch 24/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.9178 - loss: 0.2593 - precision: 0.9178 - recall: 0.9178\n",
      "Epoch 24: val_loss did not improve from 0.25663\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m186s\u001b[0m 3s/step - accuracy: 0.9177 - loss: 0.2596 - precision: 0.9177 - recall: 0.9177 - val_accuracy: 0.9160 - val_loss: 0.2688 - val_precision: 0.9160 - val_recall: 0.9160\n",
      "Epoch 25/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.9195 - loss: 0.2531 - precision: 0.9195 - recall: 0.9195\n",
      "Epoch 25: val_loss did not improve from 0.25663\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m173s\u001b[0m 3s/step - accuracy: 0.9194 - loss: 0.2534 - precision: 0.9194 - recall: 0.9194 - val_accuracy: 0.8840 - val_loss: 0.3493 - val_precision: 0.8840 - val_recall: 0.8840\n",
      "Epoch 26/40\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3s/step - accuracy: 0.9139 - loss: 0.2784 - precision: 0.9139 - recall: 0.9139\n",
      "Epoch 26: val_loss did not improve from 0.25663\n",
      "\u001b[1m63/63\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m170s\u001b[0m 3s/step - accuracy: 0.9137 - loss: 0.2789 - precision: 0.9137 - recall: 0.9137 - val_accuracy: 0.8640 - val_loss: 0.3713 - val_precision: 0.8640 - val_recall: 0.8640\n"
     ]
    }
   ],
   "source": [
    "model = Sequential([\n",
    "    # First LSTM layer (returns sequences for stacking)\n",
    "    LSTM(128, activation='tanh', return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])),\n",
    "    Dropout(0.5),  # Dropout for regularization\n",
    "    # SeqSelfAttention(attention_width=15, #attention mechanism to focus on most important timesteps\n",
    "    #                  attention_type=SeqSelfAttention.ATTENTION_TYPE_MUL,  # Multiplicative attention\n",
    "    #                  attention_activation='softmax'),\n",
    "    LSTM(64, activation='tanh', return_sequences=True),\n",
    "    Dropout(0.5),\n",
    "    Dense(64, activation='relu'),\n",
    "    Dropout(0.3),\n",
    "    LSTM(32, activation='tanh', return_sequences=False),  # New LSTM layer\n",
    "    Dropout(0.5),\n",
    "    Dense(32, activation='relu'),\n",
    "    Dropout(0.3),\n",
    "    Dense(2, activation='softmax')  # Output layer for binary classification\n",
    "])\n",
    "\n",
    "Optimizer = Adam(learning_rate=0.00005)\n",
    "# Compile the model\n",
    "model.compile(optimizer = Optimizer, loss='categorical_crossentropy', metrics=['accuracy', tf.keras.metrics.Precision(), tf.keras.metrics.Recall()])\n",
    "\n",
    "checkpoint = ModelCheckpoint(filepath='best_model.keras', monitor='val_loss', save_best_only=True, verbose=1)\n",
    "\n",
    "#model.summary()\n",
    "#early stopping for when model stops learning in training.\n",
    "early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True) \n",
    "# Train the model\n",
    "history = model.fit(X_train, y_train, epochs=40, batch_size=16, validation_split=0.2, callbacks=[checkpoint,early_stopping]) #earlystopping to mitigate overfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#save model\n",
    "model.save('/Users/catherinekim/Desktop/VRTL/best_model.keras')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/catherinekim/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "model = load_model('/Users/catherinekim/Desktop/VRTL/best_model.keras')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 568ms/step - accuracy: 0.9060 - loss: 0.2320\n",
      "test_loss: 0.2160763442516327\n",
      "test_accuracy: 0.9169328808784485\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_accuracy = model.evaluate(X_test, y_test)\n",
    "print(f\"test_loss: {test_loss}\")\n",
    "print(f\"test_accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for sequence in X_sequences[:5]:  # Plot first few sequences\n",
    "    plt.plot(sequence[:, 0], sequence[:, 1])  # Plot x_pos_pixel vs. y_pos_pixel\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of samples: 10\n",
      "Training samples: 8\n",
      "Test samples: 2\n"
     ]
    }
   ],
   "source": [
    "print(f\"Total number of samples: {len(X_padded)}\")\n",
    "print(f\"Training samples: {len(X_train)}\")\n",
    "print(f\"Test samples: {len(X_test)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "participant  label\n",
      "VRTL11       1        7164\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data.groupby(['participant', 'label']).size())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}