Data_preparation_Library.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Data Prep and Deep Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm.notebook import tqdm\n",
    "from time import time\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "import matplotlib.patches as mpatches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rms_df(df,window):\n",
    "    labels = df.columns\n",
    "    for x in labels:\n",
    "        rms_vals = [0]*window\n",
    "        for i in range(len(df[x])-window):\n",
    "            j = i + window\n",
    "            rms = np.sqrt(np.mean(df[x][j-window:j]**2))\n",
    "            rms_vals.append(rms)\n",
    "        df[x] = np.array(rms_vals)\n",
    "    return df\n",
    "\n",
    "def difference(dataset, interval=1):\n",
    "\tdiff = []\n",
    "\tfor i in range(interval, len(dataset)):\n",
    "\t\tvalue = dataset[i] - dataset[i - interval]\n",
    "\t\tdiff.append(value)\n",
    "\treturn np.array(diff)\n",
    "\n",
    "def norm(df):\n",
    "    scaler = MinMaxScaler()\n",
    "    scaler.fit(df)\n",
    "    df = scaler.transform(df)\n",
    "    return df\n",
    "\n",
    "# def norm(df):\n",
    "#     scaler = StandardScaler(with_mean=True,\n",
    "#                             with_std=True,\n",
    "#                             copy=False).fit(df)\n",
    "#     df = scaler.transform(df)\n",
    "#     return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_data(df,window,angle_label,interval=0,Normalize=False,rms=False,angle_thresh = 0.001,plot=False):\n",
    "    \n",
    "    emg_labels = ['EMG1', 'EMG2', 'EMG3', 'EMG4', 'EMG5', 'EMG6',\n",
    "           'EMG7', 'EMG8'] # , 'EMG9', 'EMG10', 'EMG11', 'EMG12'\n",
    "    emg_df = df[emg_labels]\n",
    "    \n",
    "\n",
    "    if(Normalize==True):\n",
    "        emg_df = pd.DataFrame(norm(emg_df),columns=emg_labels)\n",
    "        \n",
    "    if(rms==True):\n",
    "        emg_df = rms_df(emg_df,window)\n",
    "        \n",
    "    emg_array = np.array(emg_df)\n",
    "    all_angle = np.array(df[angle_label])\n",
    "    segments = []\n",
    "    X = []\n",
    "    y = []\n",
    "    i = 0\n",
    "    counter = [0,0,0]\n",
    "    while i < df.shape[0]-window:\n",
    "        rmin = i\n",
    "        rmax = i+window\n",
    "        \n",
    "        loc_arr = emg_array[rmin:rmax]\n",
    "        X.append(loc_arr)\n",
    "        angles = all_angle[rmin:rmax]\n",
    "        \n",
    "        diff = difference(angles).mean()\n",
    "        \n",
    "        if(abs(diff)<angle_thresh):\n",
    "            y.append([1,0,0])\n",
    "            segments.append([rmin,rmax,'1'])\n",
    "            counter[0]=counter[0]+1\n",
    "        elif(diff>0):\n",
    "            y.append([0,1,0])\n",
    "            segments.append([rmin,rmax,'r'])\n",
    "            counter[1]=counter[1]+1\n",
    "        else:\n",
    "            y.append([0,0,1])\n",
    "            segments.append([rmin,rmax,'b'])\n",
    "            counter[2]=counter[2]+1\n",
    "        i = i + interval\n",
    "            \n",
    "    X = np.array(X)\n",
    "    y = np.array(y)\n",
    "\n",
    "    \n",
    "    ## Plot Codes\n",
    "    if plot==True:\n",
    "        fig_size = (20,8)\n",
    "        emg_df.plot(figsize=fig_size,title='EMG')\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        plt.show()\n",
    "        plt.figure(figsize=fig_size)\n",
    "        plt.plot(all_angle,label=angle_label)\n",
    "        clear_patch = mpatches.Patch(color='white', label='No Motion')\n",
    "        blue_patch = mpatches.Patch(color='blue', label='Negative Motion(-)')\n",
    "        red_patch = mpatches.Patch(color='red', label='Positive Motion(+)')\n",
    "        plt.legend(handles=[clear_patch,red_patch,blue_patch],loc=2)\n",
    "        plt.title(angle_label)\n",
    "        plt.xlabel('t [2000hz]')\n",
    "        plt.ylabel('Angle (deg)')\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        plt.show()\n",
    "        for i in range(3):\n",
    "            print(i,'->',counter[i]*100/df.shape[0],'%')\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_data_prosup(df,window,interval=0,Normalize=False,rms=False,angle_thresh = 0.001,plot=False):\n",
    "\n",
    "    angle_label = 'Pronation_Angle'\n",
    "    emg_labels = ['EMG1', 'EMG2', 'EMG3', 'EMG4', 'EMG5', 'EMG6',\n",
    "           'EMG7', 'EMG8'] # , 'EMG9', 'EMG10', 'EMG11', 'EMG12'\n",
    "    emg_df = df[emg_labels]\n",
    "    \n",
    "\n",
    "    if(Normalize==True):\n",
    "        emg_df = pd.DataFrame(norm(emg_df),columns=emg_labels)\n",
    "        \n",
    "    if(rms==True):\n",
    "        emg_df = rms_df(emg_df,window)\n",
    "        \n",
    "    emg_array = np.array(emg_df)\n",
    "    all_angle = np.array(df[angle_label])\n",
    "    segments = []\n",
    "    X = []\n",
    "    y = []\n",
    "    i = 0\n",
    "    counter = [0,0,0]\n",
    "    while i < df.shape[0]-window:\n",
    "        rmin = i\n",
    "        rmax = i+window\n",
    "        \n",
    "        loc_arr = emg_array[rmin:rmax]\n",
    "        X.append(loc_arr)\n",
    "        angles = all_angle[rmin:rmax]\n",
    "        \n",
    "        diff = difference(angles).mean()\n",
    "        \n",
    "        if(abs(diff)<angle_thresh):\n",
    "            y.append([1,0,0])\n",
    "            segments.append([rmin,rmax,'1'])\n",
    "            counter[0]=counter[0]+1\n",
    "        elif(diff>0):\n",
    "            y.append([0,1,0])\n",
    "            segments.append([rmin,rmax,'r'])\n",
    "            counter[1]=counter[1]+1\n",
    "        else:\n",
    "            y.append([0,0,1])\n",
    "            segments.append([rmin,rmax,'b'])\n",
    "            counter[2]=counter[2]+1\n",
    "        i = i + interval\n",
    "            \n",
    "    X = np.array(X)\n",
    "    y = np.array(y)\n",
    "\n",
    "    \n",
    "    ## Plot Codes\n",
    "    if plot==True:\n",
    "        fig_size = (20,8)\n",
    "        emg_df.plot(figsize=fig_size,title='EMG')\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        clear_patch = mpatches.Patch(color='white', label='No Motion')\n",
    "        blue_patch = mpatches.Patch(color='blue', label='Negative Motion(-)')\n",
    "        red_patch = mpatches.Patch(color='red', label='Positive Motion(+)')\n",
    "        plt.legend(handles=[clear_patch,red_patch,blue_patch],loc=2)\n",
    "        plt.show()\n",
    "        \n",
    "        plt.figure(figsize=fig_size)\n",
    "        plt.plot(all_angle)\n",
    "        plt.title(angle_label)\n",
    "        plt.xlabel('t [2000hz]')\n",
    "        plt.ylabel('Angle (deg)')\n",
    "        plt.legend([angle_label])\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        plt.show()\n",
    "        for i in range(3):\n",
    "            print(i,'->',counter[i]*100/df.shape[0],'%')\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_data_DTM(df,window,interval=0,Normalize=False,rms=False,angle_thresh = 0.008,plot=False):\n",
    "\n",
    "    emg_labels = ['EMG1', 'EMG2', 'EMG3', 'EMG4', 'EMG5', 'EMG6',\n",
    "           'EMG7', 'EMG8'] # , 'EMG9', 'EMG10', 'EMG11', 'EMG12'\n",
    "    emg_df = df[emg_labels]\n",
    "    \n",
    "\n",
    "    if(Normalize==True):\n",
    "        emg_df = pd.DataFrame(norm(emg_df),columns=emg_labels)\n",
    "        \n",
    "    if(rms==True):\n",
    "        emg_df = rms_df(emg_df,window)\n",
    "        \n",
    "    emg_array = np.array(emg_df)\n",
    "    all_angle_flexion = np.array(df['Flexion_Angle'])\n",
    "    all_angle_radial = np.array(df['Radial_Angle'])\n",
    "    \n",
    "    segments = []\n",
    "    X = []\n",
    "    y = []\n",
    "    i = 0\n",
    "    counter = [0,0,0]\n",
    "    while i < df.shape[0]-window:\n",
    "        rmin = i\n",
    "        rmax = i+window\n",
    "        \n",
    "        loc_arr = emg_array[rmin:rmax]\n",
    "        X.append(loc_arr)\n",
    "        angles_flexion = all_angle_flexion[rmin:rmax]\n",
    "        angles_radial = all_angle_radial[rmin:rmax]\n",
    "        diff_flexion = difference(angles_flexion).mean()\n",
    "        diff_radial = difference(angles_radial).mean()\n",
    "        \n",
    "        if(abs(diff_flexion)<angle_thresh and abs(diff_radial)<angle_thresh):\n",
    "            y.append([1,0,0])\n",
    "            segments.append([rmin,rmax,'1'])\n",
    "            counter[0]=counter[0]+1\n",
    "        elif(diff_flexion>0 and diff_radial>0):\n",
    "            y.append([0,1,0])\n",
    "            segments.append([rmin,rmax,'r'])\n",
    "            counter[1]=counter[1]+1\n",
    "        else:\n",
    "            y.append([0,0,1])\n",
    "            segments.append([rmin,rmax,'b'])\n",
    "            counter[2]=counter[2]+1\n",
    "        i = i + interval\n",
    "            \n",
    "    X = np.array(X)\n",
    "    y = np.array(y)\n",
    "\n",
    "    \n",
    "    ## Plot Codes\n",
    "    if plot==True:\n",
    "        fig_size = (20,8)\n",
    "        emg_df.plot(figsize=fig_size,title='EMG')\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        clear_patch = mpatches.Patch(color='white', label='No Motion')\n",
    "        blue_patch = mpatches.Patch(color='blue', label='Negative Motion(-)')\n",
    "        red_patch = mpatches.Patch(color='red', label='Positive Motion(+)')\n",
    "        plt.legend(handles=[clear_patch,red_patch,blue_patch],loc=2)\n",
    "        plt.show()\n",
    "        \n",
    "        plt.figure(figsize=fig_size)\n",
    "        plt.plot(all_angle_flexion)\n",
    "        plt.plot(all_angle_radial)\n",
    "        plt.title(angle_label)\n",
    "        plr.legend(['Pronation Angle','Radial Angle'])\n",
    "        plt.xlabel('t [2000hz]')\n",
    "        plt.ylabel('Angle (deg)')\n",
    "        for x in segments:\n",
    "            plt.axvspan(x[0],x[1],facecolor= x[2], alpha=0.5)\n",
    "        plt.show()\n",
    "        for i in range(3):\n",
    "            print(i,'->',counter[i]*100/df.shape[0],'%')\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = 'Subjects/Fazil/day_04_24_21/computed_Hammer.csv'\n",
    "df = pd.read_csv(file,index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 -> 0.07777777777777778 %\n",
      "1 -> 0.06296296296296296 %\n",
      "2 -> 0.05925925925925926 %\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(108, 400, 8)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X, y = prep_data_prosup(df,window=400,interval=500,plot=True,Normalize=False)\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multifile Stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Subjects/Fazil/day_04_24_21/computed_Bulb.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Bulb01.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Bulb02.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Hammer.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Hammer01.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Hammer02.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Cup.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Cup01.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Cup02.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Screw.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Screw01.csv',\n",
       " 'Subjects/Fazil/day_04_24_21/computed_Screw02.csv']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "files = []\n",
    "path = 'Subjects/Fazil/day_04_24_21'\n",
    "# trial_names = ['Hammer','Bulb'] # 'Bulb','Hammer' ,'Cup','Screw'\n",
    "trial_names = ['Bulb','Hammer' ,'Cup','Screw']\n",
    "for exp in trial_names:\n",
    "    for i in range(3):\n",
    "        if(i==0):\n",
    "            files.append(path+'/computed_'+exp+'.csv')\n",
    "        else:\n",
    "            files.append(path+'/computed_'+exp+'0'+str(i)+'.csv')\n",
    "files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "files_df = []\n",
    "for file in files:\n",
    "    files_df.append(pd.read_csv(file,index_col=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiple_prep_data(df_list,window,angle_label,Normalize=True,rms=False):\n",
    "    X_all, y_all = [], []\n",
    "    for df in tqdm(df_list):\n",
    "        X, y = prep_data(df,window,angle_label,Normalize,rms)\n",
    "        X_all.append(X)\n",
    "        y_all.append(y)\n",
    "        \n",
    "    X_all_stack = np.vstack((X_all[0],X_all[1]))\n",
    "    X_all_stack = np.vstack((X_all_stack,X_all[2]))\n",
    "    \n",
    "    y_all_stack = np.vstack((y_all[0],y_all[1]))\n",
    "    y_all_stack = np.vstack((y_all_stack,y_all[2]))\n",
    "    return X_all_stack, y_all_stack\n",
    "\n",
    "def multiple_prep_data_DTM(df_list,window,Normalize=True,rms=False):\n",
    "    X_all, y_all = [], []\n",
    "    for df in tqdm(df_list):\n",
    "        X, y = prep_data_DTM(df,window,Normalize,rms)\n",
    "        X_all.append(X)\n",
    "        y_all.append(y)\n",
    "        \n",
    "    X_all_stack = np.vstack((X_all[0],X_all[1]))\n",
    "    X_all_stack = np.vstack((X_all_stack,X_all[2]))\n",
    "    \n",
    "    y_all_stack = np.vstack((y_all[0],y_all[1]))\n",
    "    y_all_stack = np.vstack((y_all_stack,y_all[2]))\n",
    "    return X_all_stack, y_all_stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "window = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c2959c4872744a6b923bf901a73281c5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "ename": "MemoryError",
     "evalue": "Unable to allocate 3.16 GiB for an array with shape (53000, 1000, 8) and data type float64",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mMemoryError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-4d1f3ee4fc4a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mX_prosup\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_prosup\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmultiple_prep_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfiles_df\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mwindow\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'Pronation_Angle'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mNormalize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrms\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-34-dd6dcd6c0350>\u001b[0m in \u001b[0;36mmultiple_prep_data\u001b[1;34m(df_list, window, angle_label, Normalize, rms)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0mX_all\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_all\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mdf\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m         \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mprep_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mwindow\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mangle_label\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mNormalize\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m         \u001b[0mX_all\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[0my_all\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-30-2ffce18a94e4>\u001b[0m in \u001b[0;36mprep_data\u001b[1;34m(df, window, angle_label, Normalize, file_save, rms)\u001b[0m\n\u001b[0;32m     28\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m             \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 30\u001b[1;33m     \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     31\u001b[0m     \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mMemoryError\u001b[0m: Unable to allocate 3.16 GiB for an array with shape (53000, 1000, 8) and data type float64"
     ]
    }
   ],
   "source": [
    "X_prosup, y_prosup = multiple_prep_data(files_df,window,'Pronation_Angle',Normalize=False,rms=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_dtm, y_dtm = multiple_prep_data_DTM(files_df,window,Normalize=False,rms=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_X_y(X_prosup, y_prosup,X_dtm, y_dtm):\n",
    "    \"\"\"\n",
    "    0 - Pro/Sup\n",
    "    1 - DTM\n",
    "    \"\"\"\n",
    "    y = []\n",
    "    \n",
    "    X = []\n",
    "    \n",
    "    for i in tqdm(range(len(y_prosup))):\n",
    "        if(y_prosup[i][0]!=1):\n",
    "            y.append([1,0])\n",
    "            X.append(X_prosup[i])\n",
    "            \n",
    "    for i in tqdm(range(len(y_dtm))):\n",
    "        if(y_dtm[i][0]!=1):\n",
    "            y.append([0,1])\n",
    "            X.append(X_dtm[i])\n",
    "            \n",
    "    y = np.array(y)\n",
    "    X = np.array(X)\n",
    "    print(X.shape,y.shape)\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = merge_X_y(X_prosup, y_prosup,X_dtm, y_dtm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('prepared_data/X',X)\n",
    "np.save('prepared_data/y',y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.load('prepared_data/X.npy')\n",
    "Y = np.load('prepared_data/y.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for data in [X_train, X_test, y_train, y_test]:\n",
    "    print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = []\n",
    "for d in y_test:\n",
    "    idx = list(d).index(1)\n",
    "    y_true.append(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count(y):\n",
    "    s0 = 0\n",
    "    s1 = 0\n",
    "    for arr in y:\n",
    "        if arr[0]==1:\n",
    "            s0 = s0+1\n",
    "        if arr[1]==1:\n",
    "            s1 = s1+1\n",
    "    ls = [s0,s1]\n",
    "    for i in range(2):\n",
    "        print(i,'-',ls[i],'[',ls[i]*100/len(y),'%]')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count(y_test)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.0 64-bit",
   "language": "python",
   "name": "python38064bitcaed634bb72a48a5bf9eda0dc4f94389"
  },
  "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": 4
}