deap_full_preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3615e04d",
   "metadata": {},
   "source": [
    "# DEAP Dataset Preprocessing\n",
    "\n",
    "This Notebook can be used in order to preprocess the DEAP Dataset in the following way: <br/>\n",
    "1. Collect all the Data form the mat files\n",
    "2. Remove the baseline from the SEEG Signals\n",
    "3. Filter the EEG Signals, either with a bandpass filter, a lowpass filter or a highpass filter\n",
    "4. Downsample the EEG Signals to a certain sampling rate\n",
    "5. Select only certain EEG Channels and rearange them in a given order\n",
    "6. Cut the EEG Signals into Windows of given length with given overlap\n",
    "7. Convert the Labels from Valence, Arousal, Dominance into the Classes Negative, Neutral, Positive\n",
    "8. Safe the generated Dataset\n",
    "9. Generate some decent plots to compare the old signal with the new signal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7be93100",
   "metadata": {},
   "source": [
    "## Description, Dataset Access and Citation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ecfbe5",
   "metadata": {},
   "source": [
    "<b>For a full description and access to the Dataset please see:</b> <br/>\n",
    "url: http://www.eecs.qmul.ac.uk/mmv/datasets/deap/readme.html <br/>\n",
    "[1] Koelstra, S.; Muhl, C.; Soleymani, M.; Lee, J.-S.; Yazdani, A.; Ebrahimi, T.; Pun, T.;Nijholt, A.; Patras, I.: Deap: A Database for Emotion Analysis using Physiological Signals. IEEE transactions on affective computing 3 (2011) 1, p. 18–31.<br/>\n",
    "<b>If you find this code helpfull please cite:</b><br/>\n",
    "tbd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba7a022",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b4afaead",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir ='../Datasets/raw/deap/data_preprocessed_python'\n",
    "output_dir = '../Datasets/full_preprocessing/'\n",
    "baseline_removal_window = 3\n",
    "cutoff_frequencies = [4,40]\n",
    "seconds_to_use = 60\n",
    "downsampling_rate = 128\n",
    "channels_to_use = ['AF3', 'F7', 'F3', 'FC5', 'T7', 'P7', 'O1', 'O2', 'P8', 'T8', 'FC6', 'F4', 'F8', 'AF4']\n",
    "window_size = 2\n",
    "window_overlap = 0\n",
    "convert_labels_to_nnp = True\n",
    "save_plots_to_file = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be4dcb8f",
   "metadata": {},
   "source": [
    "<b>data dir (String)</b>               - the path to the raw Dataset, e.g. \"'../Datasets/raw/deap/data_preprocessed_python'\" <br/>\n",
    "<b>output dir (String)</b>             - the path, where you want to save the preprocessed Dataset, e.g.                                                   \"myDatasets/DEAP/ <br/>\n",
    "<b>baseline_removal_window (float)</b> - the timewindow, to calculate a baseline (average) from. This value gets                                             subtracted from the whole timeseries. If you don't want to use baseline_removal,                                   set it to 0 <br/>\n",
    "<b>cutoff_frequencies (touple)</b>     - the cutoff frequencies for the filter, if the first value ist set to None,                                         allowpass-filtering is used, if the second value is set to None, a highpass filt                                   ist used, if both values are set, a bandpass filter is used <br/>\n",
    "<b>seconds_to_use (int)</b> - The window in seconds to use from the timeseries, if for example seconds_to_use ist set to 45, only the last 45 seconds will be used. If you want to use the whole timeseries, set it to None <br/>\n",
    "<b>downsampling_rate (int)</b>         - the frequency, to which the eeg signals should be downsampled. If you don't want to downsample the signal, set it to 0 <br/>\n",
    "<b>channels_to_use (list)</b> a list of eeg channels you want to use, if you want to use all channels from the dataset, set it to None<br/>\n",
    "<b>window_size (int)</b>              - the lenght of the timewindow in seconds, the dataset should be cut into <br/>\n",
    "<b>window_overlap (int)</b>            - overlap of the windows in seconds, if set to 0, the windows don't overlap <br/>\n",
    "<b>convert_labels_to_nnp (boolean)</b> - wheter or not you want to convert the labels of the dataset from valence, arousal, liking, dominance to negative, neutral, positive <br/>\n",
    "<b>save_plots_to_file (boolean)</b> - wheter or not you want to save the generated plots, if you choose False, the plots will be only shown in this notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851cbb79",
   "metadata": {},
   "source": [
    "## necessary imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "17dedaa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.io as sio\n",
    "from tqdm.notebook import tqdm, trange\n",
    "import os\n",
    "import warnings\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "526af223",
   "metadata": {},
   "source": [
    "## Data Collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6e8c8d07",
   "metadata": {},
   "outputs": [],
   "source": [
    "sampling_rate = 128\n",
    "channel_names = ['FP1', 'AF3', 'F3', 'F7', 'FC5', 'FC1', 'C3', 'T7', 'CP5', 'CP1', 'P3', 'P7', 'PO3', 'O1', 'OZ', 'PZ', 'FP2', 'AF4', 'FZ', 'F4', 'F8', 'FC6', 'FC2', 'CZ', 'C4', 'T8', 'CP6', 'CP2', 'P4', 'P8', 'PO4', 'O2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ab822262",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.empty((1280,32,8064))\n",
    "X_len = np.empty((1280,), dtype=int)\n",
    "Y = np.empty((1280,4))\n",
    "trial = np.empty((1280), dtype=np.int8)\n",
    "subject = np.empty((1280,), dtype=np.int8)\n",
    "session = np.ones((1280,), dtype=np.int8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5882b57e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ac8712b5cf84919bb1ce7ae21a7c58e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sys\n",
    "np.set_printoptions(threshold=sys.maxsize)\n",
    "file_id = 0\n",
    "for index, filename in tqdm(enumerate(sorted(os.listdir(data_dir)),start=1)):\n",
    "    if filename.endswith(\".dat\"):\n",
    "        temp_file = pickle.load(open(os.path.join(data_dir, filename), 'rb'), encoding='iso-8859-1')\n",
    "        X_len[file_id*40:file_id*40+40] = np.ones((40,))*temp_file['data'].shape[2]\n",
    "        X[file_id*40:file_id*40+40,:,:] = temp_file['data'][:,:32,:]\n",
    "        Y[file_id*40:file_id*40+40,:] = temp_file['labels']\n",
    "        subject[file_id*40:file_id*40+40] = np.ones((40,), dtype=np.int8)* (file_id+1)\n",
    "        trial[file_id*40:file_id*40+40] = np.arange(1,41)\n",
    "        file_id = file_id +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c08e64c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the Time Series Array X: (1280, 32, 8064)\n",
      "Unique Session Indices: [1]\n",
      "Unique Subject Indices: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24\n",
      " 25 26 27 28 29 30 31 32]\n",
      "Unique Trial Indices: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24\n",
      " 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40]\n",
      "Minimum length of Timeseries: 8064\n",
      "Maximum length of Timeseries: 8064\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of the Time Series Array X: \" + str(X.shape))\n",
    "print(\"Unique Session Indices: \" + str(np.unique(session)))\n",
    "print(\"Unique Subject Indices: \" + str(np.unique(subject)))\n",
    "print(\"Unique Trial Indices: \" + str(np.unique(trial)))\n",
    "print(\"Minimum length of Timeseries: \" + str(min(X_len)))\n",
    "print(\"Maximum length of Timeseries: \" + str(max(X_len)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "702d3059",
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_raw is later used for plotting, if you don't want to see the plots, you can uncomment this line\n",
    "X_raw = X.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c1c39ea",
   "metadata": {},
   "source": [
    "## Baseline-Removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0dd53f6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52a0facf99994e5fa35fe4c830e57a1f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/8064 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not(baseline_removal_window==0):\n",
    "    baseline_datapoints = baseline_removal_window * sampling_rate\n",
    "    baseline = X[:,:,:baseline_datapoints].sum(2) / baseline_datapoints\n",
    "    for timestep in trange(X.shape[2]):\n",
    "        X[:,:,timestep] = X[:,:,timestep] - baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014418e4",
   "metadata": {},
   "source": [
    "## Filtering (Bandpass or Highpass or Lowpass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b262a663",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.signal import butter, sosfilt, sosfreqz\n",
    "\n",
    "def butter_bandpass(lowcut, highcut, fs, btype='band', order=5):\n",
    "        nyq = 0.5 * fs\n",
    "        if btype == 'bandpass':\n",
    "            low = lowcut / nyq\n",
    "            high = highcut / nyq\n",
    "            sos = butter(order, [low, high], analog=False, btype='bandpass', output='sos')\n",
    "        elif btype == 'highpass':\n",
    "            low = lowcut / nyq\n",
    "            sos = butter(order, low, analog=False, btype='highpass', output='sos')\n",
    "        elif btype == 'lowpass':\n",
    "            high = highcut / nyq\n",
    "            sos = butter(order, high, analog=False, btype='lowpass', output='sos')\n",
    "        return sos\n",
    "\n",
    "def butter_bandpass_filter(X, lowcut, highcut, fs, btype='bandpass', order=5):\n",
    "        sos = butter_bandpass(lowcut, highcut, fs, btype=btype, order=order)\n",
    "        X = sosfilt(sos, X)\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ab52cfca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "82d7e660c9a94168969f8d7e5a31c444",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not(cutoff_frequencies[0] == None):\n",
    "    if not(cutoff_frequencies[1] == None):\n",
    "        btype='bandpass'\n",
    "    else:\n",
    "        btype='highpass'\n",
    "elif not (cutoff_frequencies[1] == None):\n",
    "        btype='lowpass'\n",
    "\n",
    "for experiment_id in trange(X.shape[0]):\n",
    "    for channel_id in range(X.shape[1]):\n",
    "        X[experiment_id, channel_id, :] = butter_bandpass_filter(\n",
    "                                                        X[experiment_id, channel_id, :],\n",
    "                                                        cutoff_frequencies[0],\n",
    "                                                        cutoff_frequencies[1],\n",
    "                                                        sampling_rate,\n",
    "                                                        btype=btype,\n",
    "                                                        order=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87b8e642",
   "metadata": {},
   "source": [
    "## Use only the last n seconds of the timeseries\n",
    "(As determined with the hyperparameter seconds_to_use)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6ee1f399",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d52a8c059b647cba72ff30b70282e36",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not(seconds_to_use == None):\n",
    "    num_sample_points_to_use = seconds_to_use * sampling_rate\n",
    "    X_selected = np.zeros((X.shape[0], X.shape[1], num_sample_points_to_use))\n",
    "    for exp_id in trange(len(X_len)):\n",
    "        X_selected[exp_id,:,:] = X[exp_id,:,X_len[exp_id]-num_sample_points_to_use:X_len[exp_id]]\n",
    "    X = X_selected"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee886ac4",
   "metadata": {},
   "source": [
    "## Downsampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "22f7d571",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.signal import resample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b4681edb",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not(downsampling_rate == 0) and not(downsampling_rate == sampling_rate):\n",
    "    new_length = int(X.shape[2] / sampling_rate * downsampling_rate)\n",
    "    X_downsampled = np.zeros((X.shape[0], X.shape[1], new_length))\n",
    "    for experiment_id in trange(X.shape[0]):\n",
    "        for channel_id in range(X.shape[1]):\n",
    "            X_downsampled[experiment_id, channel_id, :] = resample(X[experiment_id, channel_id, :], new_length)\n",
    "    X = X_downsampled"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e366fa5",
   "metadata": {},
   "source": [
    "## Select certain channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "56c0c6bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "if channels_to_use == None:\n",
    "    channels_to_use = channel_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "174e654f",
   "metadata": {},
   "outputs": [],
   "source": [
    "channel_index_list = list()\n",
    "for i in range(len(channels_to_use)):\n",
    "    if channels_to_use[i] in channel_names:\n",
    "        channel_index_list.append(channel_names.index(channels_to_use[i]))\n",
    "    else:\n",
    "        warnings.warn(' Channel ' + channels_to_use[i] +' could not be found in the list of actual channels')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "05ffc734",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f4ce9c295ebd414e847901db6e404bf3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/14 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_selected_channels = np.zeros((X.shape[0], len(channels_to_use), X.shape[2]))\n",
    "for channel in trange(len(channel_index_list)):\n",
    "    X_selected_channels[:,channel,:] = X[:,channel_index_list[channel],:]\n",
    "X = X_selected_channels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80727c76",
   "metadata": {},
   "source": [
    "## Cut into windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f8466137",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef04381dfa224319bdb733f0374611e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_points_per_window = window_size * downsampling_rate\n",
    "num_points_overlap = window_overlap * downsampling_rate\n",
    "stride = num_points_per_window - num_points_overlap\n",
    "start_index = [0]\n",
    "end_index = [num_points_per_window]\n",
    "num_windows_per_exp = 1\n",
    "while(end_index[-1]+stride < X.shape[2]):\n",
    "    num_windows_per_exp = num_windows_per_exp + 1\n",
    "    start_index.append(start_index[-1] + stride)\n",
    "    end_index.append(end_index[-1] + stride)\n",
    "X_cut = np.zeros((num_windows_per_exp*X.shape[0],X.shape[1], num_points_per_window))\n",
    "Y_cut = np.zeros((num_windows_per_exp*X.shape[0],4))\n",
    "session_cut = np.zeros(num_windows_per_exp*X.shape[0],)\n",
    "subject_cut = np.zeros(num_windows_per_exp*X.shape[0],)\n",
    "trial_cut = np.zeros(num_windows_per_exp*X.shape[0],)\n",
    "for exp_id in trange(X.shape[0]):\n",
    "    for window_id in range(len(start_index)):\n",
    "        X_cut[exp_id*num_windows_per_exp+window_id,:,:] = X[exp_id,:,start_index[window_id]:end_index[window_id]]\n",
    "        Y_cut[exp_id*num_windows_per_exp+window_id,:] = Y[exp_id,:]\n",
    "        session_cut[exp_id*num_windows_per_exp+window_id] = session[exp_id]\n",
    "        subject_cut[exp_id*num_windows_per_exp+window_id] = subject[exp_id]\n",
    "        trial_cut[exp_id*num_windows_per_exp+window_id] = trial[exp_id]\n",
    "X = X_cut\n",
    "Y = Y_cut\n",
    "session = session_cut\n",
    "subject = subject_cut\n",
    "trial = trial_cut"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8cb3095",
   "metadata": {},
   "source": [
    "## Label Conversion\n",
    "The Labels get converted from Valence Arousal Dominance Liking into the Classes Negative, Neutral, Positive using a <b>K-Means Clustering </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "85f7a8b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import KMeans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "65739882",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_centeroids(centeroids):\n",
    "    # calculates the distance between given centeroids\n",
    "    # and the corners bottom-right, bottom-left, top-left, top-right\n",
    "    # and returns them in the order that the point closest to the br corner is returned first,\n",
    "    # the one closest to the bl second,\n",
    "    # the one clostest to the tl third,\n",
    "    # and the one closest to the top right fourth\n",
    "    \n",
    "    distance_br = np.zeros(centeroids.shape[0])\n",
    "    distance_bl = np.zeros(centeroids.shape[0])\n",
    "    distance_tl = np.zeros(centeroids.shape[0])\n",
    "    distance_tr = np.zeros(centeroids.shape[0])\n",
    "    \n",
    "    for i in range(centeroids.shape[0]):\n",
    "        distance_br[i] = abs((1-centeroids[i,0])**2 + (-1-centeroids[i,1])**2)\n",
    "        distance_bl[i] = abs((-1-centeroids[i,0])**2 + (-1-centeroids[i,1])**2)\n",
    "        distance_tl[i] = abs((-1-centeroids[i,0])**2 + (1-centeroids[i,1])**2)\n",
    "        distance_tr[i] = abs((1-centeroids[i,0])**2 + (1-centeroids[i,1])**2)\n",
    "    \n",
    "    br_idx = np.argmin(distance_br)\n",
    "    bl_idx = np.argmin(distance_bl)\n",
    "    tl_idx = np.argmin(distance_tl)\n",
    "    tr_idx = np.argmin(distance_tr)\n",
    "    \n",
    "    return br_idx, bl_idx, tl_idx, tr_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "972652aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "valence = scaler.fit_transform(Y[:,0].reshape(-1,1))\n",
    "arousal = scaler.fit_transform(Y[:,1].reshape(-1,1))\n",
    "datapoints = np.concatenate((valence,arousal),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "26a0bbaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeans = KMeans(n_clusters=4, random_state=7).fit(datapoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "fa06435d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sad_label, fear_label, neutral_label, happy_label = sort_centeroids(kmeans.cluster_centers_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5781b80b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Fear: 8033 - #Sad: 8961 - #Neutral: 9860 - Happy: 10266\n"
     ]
    }
   ],
   "source": [
    "plt.scatter(valence,arousal, c=kmeans.labels_, edgecolors='none')\n",
    "plt.xlabel('Valence')\n",
    "plt.ylabel('Arousal')\n",
    "plt.title('DEAP - NNP Label via K-Means')\n",
    "plt.show()\n",
    "print('#Fear: %i - #Sad: %i - #Neutral: %i - Happy: %i'\n",
    "      %(np.count_nonzero(kmeans.labels_ == fear_label),\n",
    "        np.count_nonzero(kmeans.labels_ == sad_label),\n",
    "        np.count_nonzero(kmeans.labels_ == neutral_label),\n",
    "        np.count_nonzero(kmeans.labels_ == happy_label)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e8b5ec9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "idx_sad = np.where(kmeans.labels_==sad_label)\n",
    "idx_fear = np.where(kmeans.labels_==fear_label)\n",
    "idx_neutral = np.where(kmeans.labels_==neutral_label)\n",
    "idx_happy = np.where(kmeans.labels_==happy_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "324e02a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_nnp = np.zeros(Y.shape[0],)\n",
    "Y_nnp[idx_sad] = -1\n",
    "Y_nnp[idx_fear] = -1\n",
    "Y_nnp[idx_neutral] = 0\n",
    "Y_nnp[idx_happy] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ff726206",
   "metadata": {},
   "outputs": [],
   "source": [
    "if convert_labels_to_nnp:\n",
    "    Y = Y_nnp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c8fa321",
   "metadata": {},
   "source": [
    "## Save Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4751752",
   "metadata": {},
   "source": [
    "Please note: This step can take up to several minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0f1ed2bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved File\n"
     ]
    }
   ],
   "source": [
    "np.savez_compressed(\n",
    "                    output_dir +'/DEAP.npz',\n",
    "                    X=X,\n",
    "                    Y=Y,\n",
    "                    session = session,\n",
    "                    subject = subject,\n",
    "                    trial = trial,\n",
    "                    downsampling_rate = downsampling_rate,\n",
    "                    channel_names = channels_to_use,\n",
    "                    window_size=window_size,\n",
    "                    window_overlap = window_overlap,\n",
    "                    cutoff_frequencies = cutoff_frequencies,\n",
    "                    baseline_removal_window = baseline_removal_window,\n",
    "                    seconds_to_use = seconds_to_use\n",
    "                    )\n",
    "print('Saved File')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045e9ddd",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "32ed410c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def perform_FFT(X, sampling_rate):\n",
    "    n = len(X) # length of the signal\n",
    "    k = np.arange(n)\n",
    "    T = n/sampling_rate\n",
    "    frq = k/T # two sides frequency range\n",
    "    frq = frq[:len(frq)//2] # one side frequency range\n",
    "\n",
    "    X_FT = np.fft.fft(X)/n # dft and normalization\n",
    "    X_FT = X_FT[:n//2]\n",
    "    return X_FT, frq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "725ca1c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "channel_id_to_plot = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "12b68daf",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_ts = X_raw[0,channel_names.index(channels_to_use[channel_id_to_plot]),0:sampling_rate*window_size]\n",
    "preprocessed_ts = X[0,channel_id_to_plot,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8bf692dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "84c637e2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(0,sampling_rate*window_size),raw_ts, label=\"Raw Signal\")\n",
    "plt.plot(np.arange(0,downsampling_rate*window_size)/downsampling_rate*sampling_rate,preprocessed_ts, label=\"Preprocessed Signal\")\n",
    "plt.title(\"Comparison of an Exemplary Time Series\")\n",
    "plt.xticks([0,sampling_rate,2*sampling_rate],[0,1,2])\n",
    "plt.xlabel(\"Time t [s]\")\n",
    "plt.ylabel(\"Voltage U [mV]\")\n",
    "plt.legend()\n",
    "if save_plots_to_file:\n",
    "    plt.savefig(output_dir+'figures/DEAP_Timespace.png', facecolor=\"white\")\n",
    "else:\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "da931e69",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_fs, raw_frq = perform_FFT(raw_ts, sampling_rate)\n",
    "preprocessed_fs, preprocessed_frq = perform_FFT(preprocessed_ts, downsampling_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "379880e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(raw_frq, abs(raw_fs), label=\"Raw Signal\")\n",
    "plt.plot(preprocessed_frq, abs(preprocessed_fs), label=\"Preprocessed Signal\")\n",
    "plt.title(\"Comparison of an Exemplary Spectrum\")\n",
    "plt.xlabel(\"Frequency f [Hz]\")\n",
    "plt.ylabel(\"Amplitude |X(f)|\")\n",
    "plt.legend()\n",
    "if save_plots_to_file:\n",
    "    plt.savefig(output_dir+'figures/DEAP_Frequencyspace.png', facecolor=\"white\")\n",
    "else:\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "787d79b9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}