666 lines (665 with data), 54.7 kB

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from datetime import date, datetime, timedelta\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.stats import kurtosis, skew\n",
    "from scipy.signal import find_peaks\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler, OneHotEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix\n",
    "\n",
    "import ruptures as rpt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def statistical_features(arr):\n",
    "    vmin = np.amin(arr)\n",
    "    vmax = np.amax(arr)\n",
    "    mean = np.mean(arr)\n",
    "    std = np.std(arr)\n",
    "    return vmin, vmax, mean, std\n",
    "\n",
    "def shape_features(arr):\n",
    "    skewness = skew(arr)\n",
    "    kurt = kurtosis(arr)\n",
    "    return skewness, kurt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "user = 'DF'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import_path = f'{user}'\n",
    "export_path = f'{user}'\n",
    "\n",
    "rightEDAdatapath  = f'{import_path}/EDA.csv'\n",
    "rightHRdatapath   = f'{import_path}/HR.csv'\n",
    "rightTEMPdatapath = f'{import_path}/TEMP.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rightHRdatapath = np.loadtxt(rightHRdatapath, delimiter = ',')\n",
    "rightHRdatapath = np.repeat(rightHRdatapath, 4)\n",
    "np.savetxt('hr_new.csv', rightHRdatapath, delimiter = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "edat =  pd.read_csv(f'{user}/EDA.csv',  header = 2,  names = ['EDA'])\n",
    "hrt =   pd.read_csv(f'hr_new.csv',      header = 12, names = ['HR'])\n",
    "tempt = pd.read_csv(f'{user}/Temp.csv', header = 2,  names = ['TEMP'])\n",
    "gt =    pd.read_csv(f'{user}/EDA.csv',  nrows  = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_time = gt.iloc[0,0]\n",
    "min_len = min(len(edat), len(hrt), len(tempt))\n",
    "\n",
    "eda = edat.iloc[:min_len, 0]\n",
    "hrt = hrt.iloc[:min_len, 0]\n",
    "tempt = tempt.iloc[:min_len, 0]\n",
    "df_original = pd.concat([eda, hrt, tempt], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = df_original.values\n",
    "data = pd.DataFrame(array)\n",
    "data.columns = ['EDA','HR','temp']\n",
    "\n",
    "cols = [\n",
    "    'EDA_Mean','EDA_Min','EDA_Max','EDA_Std', 'EDA_Kurtosis', 'EDA_Skew','EDA_Num_Peaks','EDA_Amphitude','EDA_Duration',\n",
    "    'HR_Mean','HR_Min','HR_Max','HR_Std','HR_RMS','temp_Mean', 'temp_Min','temp_Max','temp_Std'\n",
    "]\n",
    "df_features = pd.DataFrame(columns=cols)\n",
    "\n",
    "index = 0\n",
    "\n",
    "for i in range(0,len(data['EDA']), 20):\n",
    "    df_partial = data.iloc[i:i+40,]\n",
    "    plen = len(df_partial['EDA'])\n",
    "    \n",
    "    if plen < 40:\n",
    "        continue\n",
    "    \n",
    "    eda = df_partial['EDA'].values\n",
    "    hr = df_partial['HR'].values\n",
    "    temp = df_partial['temp'].values\n",
    "\n",
    "    eda_min, eda_max, eda_mean, eda_std = statistical_features(eda)\n",
    "    hr_min, hr_max, hr_mean, hr_std = statistical_features(hr)\n",
    "    temp_min, temp_max, temp_mean, temp_std = statistical_features(temp)\n",
    "    eda_skew, eda_kurtosis = shape_features(eda)\n",
    "    \n",
    "    hr_rms = np.sqrt(np.mean(np.square(np.ediff1d(hr))))\n",
    "    temp_rms= np.sqrt(np.mean(np.square(np.ediff1d(temp))))\n",
    "\n",
    "    peaks,properties = find_peaks(eda, width=5)\n",
    "    num_Peaks = len(peaks)\n",
    "    \n",
    "    prominences = np.array(properties['prominences'])\n",
    "    widths = np.array(properties['widths'])\n",
    "    amphitude = np.sum(prominences)\n",
    "    duration = np.sum(widths)\n",
    "\n",
    "    df_features.loc[index] = [eda_mean, eda_min, eda_max, eda_std, eda_kurtosis, eda_skew, num_Peaks, amphitude, duration, hr_mean, hr_min, hr_max, hr_std,hr_rms, temp_mean, temp_min, temp_max, temp_std]\n",
    "\n",
    "    index = index+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = list(map(str, range(30, 0, -1)))\n",
    "df_lag_features = pd.DataFrame(columns=cols)\n",
    "df_lag_features = pd.concat([\n",
    "    df_features['HR_Mean'].shift(10),  df_features['HR_Mean'].shift(9),    df_features['HR_Mean'].shift(8),\n",
    "    df_features['HR_Mean'].shift(7),   df_features['HR_Mean'].shift(6),    df_features['HR_Mean'].shift(5),\n",
    "    df_features['HR_Mean'].shift(4),   df_features['HR_Mean'].shift(3),    df_features['HR_Mean'].shift(2),\n",
    "    df_features['HR_Mean'].shift(1),   df_features['temp_Mean'].shift(10), df_features['temp_Mean'].shift(9),\n",
    "    df_features['temp_Mean'].shift(8), df_features['temp_Mean'].shift(7),  df_features['temp_Mean'].shift(6),\n",
    "    df_features['temp_Mean'].shift(5), df_features['temp_Mean'].shift(4),  df_features['temp_Mean'].shift(3),\n",
    "    df_features['temp_Mean'].shift(2), df_features['temp_Mean'].shift(1),  df_features['EDA_Mean'].shift(10),\n",
    "    df_features['EDA_Mean'].shift(9),  df_features['EDA_Mean'].shift(8),   df_features['EDA_Mean'].shift(7),\n",
    "    df_features['EDA_Mean'].shift(6),  df_features['EDA_Mean'].shift(5),   df_features['EDA_Mean'].shift(4),\n",
    "    df_features['EDA_Mean'].shift(3),  df_features['EDA_Mean'].shift(2),   df_features['EDA_Mean'].shift(1)], axis=1)\n",
    "df_lag_features.columns = cols\n",
    "df_lag_features = df_lag_features.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp = df_features.iloc[30:3238, 0:31]\n",
    "df_total = pd.concat([df_lag_features, df_temp], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stress detection model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc = 0.950572193815437\n",
      "pre = 0.9493557683135115\n",
      "recall = 0.931917414618591\n",
      "f1 = 0.9395137969324274\n"
     ]
    }
   ],
   "source": [
    "df_lag = pd.read_csv('combined_lagEDA.csv')\n",
    "train_set = df_lag.iloc[:,0:48]\n",
    "labels = df_lag.iloc[:,48:49]\n",
    "\n",
    "#Create a random forest Classifier\n",
    "clf = RandomForestClassifier(n_estimators=100,max_depth=15)\n",
    "\n",
    "# Split our data\n",
    "train, test, train_labels, test_labels = train_test_split(train_set, labels, test_size=0.33, random_state=30)\n",
    "\n",
    "#Train the model using the training sets y_pred=clf.predict(X_test)\n",
    "clf.fit(train, train_labels.values.ravel())\n",
    "\n",
    "y_pred = clf.predict(test)\n",
    "\n",
    "f1score   = f1_score        (test_labels, y_pred, average = 'macro')\n",
    "recall    = recall_score    (test_labels, y_pred, average = 'macro')\n",
    "precision = precision_score (test_labels, y_pred, average = 'macro')\n",
    "accuracy  = accuracy_score  (test_labels, y_pred)\n",
    "\n",
    "print('acc =', accuracy)\n",
    "print('pre =', precision)\n",
    "print('recall =', recall) \n",
    "print('f1 =', f1score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting the stress"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda3\\envs\\stress\\lib\\site-packages\\sklearn\\base.py:450: UserWarning: X does not have valid feature names, but RandomForestClassifier was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "df_total = df_total.dropna()\n",
    "scalar = MinMaxScaler()\n",
    "x_scaled = scalar.fit_transform(df_total.iloc[:,0:48])\n",
    "data = pd.DataFrame(x_scaled)\n",
    "data = data.fillna(0)\n",
    "\n",
    "pred_t = clf.predict(data)\n",
    "pred_t = pd.DataFrame(pred_t)\n",
    "pred_t.columns=['pred']\n",
    "pred_t.head(30)\n",
    "pred_t.to_csv('pred'+user+'.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_total['pred'] = pred_t\n",
    "df_total.to_csv('pred{user}.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_total['MA_3'] = np.ceil(df_total.iloc[:,48:49].rolling(window=31).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 155, 220, 235, 250, 300, 395, 490, 570, 685, 715, 760, 860, 940, 980, 990, 1020, 1040, 1070, 1115]\n"
     ]
    }
   ],
   "source": [
    "signal = df_total.iloc[:,49:50].values\n",
    "\n",
    "algo = rpt.Window(model=\"l2\", width=10).fit(signal)\n",
    "result = algo.predict(n_bkps=60)\n",
    "\n",
    "rpt.display(signal, result, figsize=(16, 6))\n",
    "plt.title('Change Point Detection: Pelt Search Method')\n",
    "plt.show()\n",
    "\n",
    "result.insert(0, 0)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating the event by start and end epoch_times"
   ]
  },
  {
   "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>start</th>\n",
       "      <th>end</th>\n",
       "      <th>stress</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>155.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>155.0</td>\n",
       "      <td>220.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>220.0</td>\n",
       "      <td>235.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>235.0</td>\n",
       "      <td>250.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>250.0</td>\n",
       "      <td>300.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>300.0</td>\n",
       "      <td>395.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>395.0</td>\n",
       "      <td>490.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>490.0</td>\n",
       "      <td>570.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>570.0</td>\n",
       "      <td>685.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>685.0</td>\n",
       "      <td>715.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>715.0</td>\n",
       "      <td>760.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>760.0</td>\n",
       "      <td>860.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>860.0</td>\n",
       "      <td>940.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>940.0</td>\n",
       "      <td>980.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>980.0</td>\n",
       "      <td>990.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>990.0</td>\n",
       "      <td>1020.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1020.0</td>\n",
       "      <td>1040.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1040.0</td>\n",
       "      <td>1070.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>1070.0</td>\n",
       "      <td>1115.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     start     end  stress\n",
       "0      0.0   155.0     0.0\n",
       "1    155.0   220.0     1.0\n",
       "2    220.0   235.0     2.0\n",
       "3    235.0   250.0     1.0\n",
       "4    250.0   300.0     0.0\n",
       "5    300.0   395.0     1.0\n",
       "6    395.0   490.0     2.0\n",
       "7    490.0   570.0     1.0\n",
       "8    570.0   685.0     0.0\n",
       "9    685.0   715.0     1.0\n",
       "10   715.0   760.0     0.0\n",
       "11   760.0   860.0     1.0\n",
       "12   860.0   940.0     0.0\n",
       "13   940.0   980.0     1.0\n",
       "14   980.0   990.0     0.0\n",
       "15   990.0  1020.0     1.0\n",
       "16  1020.0  1040.0     2.0\n",
       "17  1040.0  1070.0     1.0\n",
       "18  1070.0  1115.0     2.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_start = 0\n",
    "temp_end = result[0]\n",
    "\n",
    "stress = []\n",
    "for i in range (len(result)-1):\n",
    "    \n",
    "    temp = df_total.iloc[result[i]:(result[i+1]-1), 49:50].mean()[0]\n",
    "    \n",
    "    if temp > 1.3:\n",
    "        temp = 2.0\n",
    "    elif temp >= .65:\n",
    "        temp = 1\n",
    "    else:\n",
    "        temp = 0\n",
    "\n",
    "    stress.append(temp)\n",
    "    \n",
    "df_temp = pd.DataFrame(columns=['start', 'end', 'stress'])\n",
    "c = 0\n",
    "for i in range(len(result)-1):\n",
    "    stressLength = (result[i+1] - result[i]) / 12\n",
    "\n",
    "    start_point  = result[i]\n",
    "    end_point    = result[i + 1]\n",
    "    stress_value = stress[i]\n",
    "    \n",
    "    if temp_end <= start_point:\n",
    "        temp_end       = end_point\n",
    "        df_temp.loc[c] = [start_point, end_point, stress_value]\n",
    "        c = c +1\n",
    "\n",
    "df_temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change event time to datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prev: 0:12:55 18:00:04 18:12:59 0.0\n",
      "Prev: 0:05:25 18:12:59 18:18:24 1.0\n",
      "Prev: 0:01:15 18:18:24 18:19:39 2.0\n",
      "Prev: 0:01:15 18:19:39 18:20:54 1.0\n",
      "Prev: 0:04:10 18:20:54 18:25:04 0.0\n",
      "Prev: 0:07:55 18:25:04 18:32:59 1.0\n",
      "Prev: 0:07:55 18:32:59 18:40:54 2.0\n",
      "Prev: 0:06:40 18:40:54 18:47:34 1.0\n",
      "Prev: 0:09:35 18:47:34 18:57:09 0.0\n",
      "Prev: 0:02:30 18:57:09 18:59:39 1.0\n",
      "Prev: 0:03:45 18:59:39 19:03:24 0.0\n",
      "Prev: 0:08:20 19:03:24 19:11:44 1.0\n",
      "Prev: 0:06:40 19:11:44 19:18:24 0.0\n",
      "Prev: 0:03:20 19:18:24 19:21:44 1.0\n",
      "Prev: 0:00:50 19:21:44 19:22:34 0.0\n",
      "Prev: 0:02:30 19:22:34 19:25:04 1.0\n",
      "Prev: 0:01:40 19:25:04 19:26:44 2.0\n",
      "Prev: 0:02:30 19:26:44 19:29:14 1.0\n",
      "Final: 0:02:30 19:29:14 19:32:59 2.0\n"
     ]
    }
   ],
   "source": [
    "stress_start = 0\n",
    "stress_end = 0\n",
    "tse = 0\n",
    "previous_stress = -1\n",
    "\n",
    "for index, row in df_temp.iterrows():\n",
    "\n",
    "    if row['stress'] == previous_stress:\n",
    "        stress_end = row['end']\n",
    "    else:\n",
    "        if(previous_stress != -1):\n",
    "            start    = datetime.fromtimestamp(reference_time + (stress_start * 5))\n",
    "            end      = datetime.fromtimestamp(reference_time + (stress_end * 5))\n",
    "            timediff = end - start\n",
    "            print('Prev:', timediff, datetime.fromtimestamp(reference_time + (stress_start * 5)).strftime('%H:%M:%S'), datetime.fromtimestamp(reference_time + (stress_end * 5)).strftime('%H:%M:%S'), previous_stress)\n",
    "        \n",
    "        stress_start    = row['start']\n",
    "        stress_end      = row['end']\n",
    "        previous_stress = row['stress']\n",
    "        \n",
    "print('Final:', timediff, datetime.fromtimestamp(reference_time + (stress_start * 5)).strftime('%H:%M:%S'), datetime.fromtimestamp(reference_time + (stress_end * 5)).strftime('%H:%M:%S'), previous_stress)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}