EEGnet_CNN+Dense_Binary_Classifier-Conv1-GRID.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make sure you don't hog all the video memory\n",
    "import tensorflow as tf\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "sess = tf.Session(config=config)\n",
    "from keras import backend as K\n",
    "K.set_session(sess)\n",
    "###################################\n",
    "\n",
    "from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Dropout, BatchNormalization, Flatten, Conv1D, MaxPooling1D\n",
    "from keras.models import Model, load_model\n",
    "from keras.callbacks import TensorBoard, EarlyStopping, Callback\n",
    "from keras import optimizers\n",
    "from keras.initializers import Orthogonal as orth\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "import scipy.io as sio\n",
    "\n",
    "\n",
    "nb_filters = 30\n",
    "kernel_size = 40\n",
    "dense1_n = 10\n",
    "epochs = 1000\n",
    "\n",
    "patience = 30\n",
    "\n",
    "steps = np.arange(0.1, 0.6, 0.1)\n",
    "reps = range(7)\n",
    "\n",
    "acc = np.zeros((len(steps),len(reps)))\n",
    "\n",
    "for j in range(len(steps)):\n",
    "    for k in reps:\n",
    "    \n",
    "        print('Current test/train split is', steps[j], '/', 1-steps[j])\n",
    "        print('Repetition', k, 'out of', max(reps))\n",
    "\n",
    "        t0 = time.time()\n",
    "\n",
    "        # load data from the .mat file:\n",
    "        mat_contents = sio.loadmat('/home/amplifier/home/DATASETS/KOS_100Hz_ICA->0.5-38Hz,Env=1.mat')\n",
    "\n",
    "        X = mat_contents['X']\n",
    "        Y = mat_contents['Z'].T\n",
    "\n",
    "        winsize = mat_contents['winsize']\n",
    "        stepsize = mat_contents['stepsize']\n",
    "        trial_len = mat_contents['trial_len']\n",
    "        low_cutoff = mat_contents['low_cutoff']\n",
    "        high_cutoff = mat_contents['high_cutoff']\n",
    "        source = mat_contents['filein']\n",
    "\n",
    "        # verify that the model REALLY finds a mapping between the input and the labels. If we get\n",
    "        # our accuracy by chance, then we should get the same accuracy on a permuted dataset:\n",
    "        # Y = np.random.permutation(Y)\n",
    "\n",
    "        x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=steps[j])\n",
    "        print('Original data type:', x_train.dtype)\n",
    "\n",
    "        # convert to float64 for numerical stability:\n",
    "        x_train = x_train.astype('float64')\n",
    "        y_train = y_train.astype('float64')\n",
    "        x_test = x_test.astype('float64')\n",
    "        y_test = y_test.astype('float64')\n",
    "\n",
    "        # normalize to unit variance and zero mean:\n",
    "        for i in range(x_train.shape[0]):\n",
    "            x_train[i,:,:] = preprocessing.scale(x_train[i,:,:], axis=1)\n",
    "            x_train[i,:,:] = preprocessing.minmax_scale(x_train[i,:,:], axis=1)\n",
    "\n",
    "        for i in range(x_test.shape[0]):\n",
    "            x_test[i,:,:] = preprocessing.scale(x_test[i,:,:], axis=1)\n",
    "            x_test[i,:,:] = preprocessing.minmax_scale(x_test[i,:,:], axis=1)\n",
    "\n",
    "        # ensure the tensors are sized right:\n",
    "        x_train = np.transpose(x_train,(0,2,1))\n",
    "        x_test = np.transpose(x_test,(0,2,1))\n",
    "\n",
    "        # one hot encode the labels:\n",
    "        onehot_encoder = preprocessing.OneHotEncoder(sparse=False)\n",
    "        y_train = onehot_encoder.fit_transform(y_train)\n",
    "        y_test = onehot_encoder.fit_transform(y_test)\n",
    "\n",
    "        # convert to float16 to save space:\n",
    "        x_train = x_train.astype('float16')\n",
    "        y_train = y_train.astype('float16')\n",
    "        x_test = x_test.astype('float16')\n",
    "        y_test = y_test.astype('float16')\n",
    "        print('Normalized data type:', x_train.dtype)\n",
    "\n",
    "        print('test input shape', x_test.shape, \"Nomralized MEAN:\", np.mean(x_test), \"min\", np.min(x_test),\"max\", np.max(x_test))\n",
    "        print('train input shape', x_train.shape, \"Nomralized MEAN:\", np.mean(x_train), \"min\", np.min(x_train),\"max\", np.max(x_train))\n",
    "\n",
    "        print('test labels shape', y_test.shape, \"Nomralized MEAN:\", np.mean(y_test), \"min\", np.min(y_test),\"max\", np.max(y_test))\n",
    "        print('train labels shape', y_train.shape, \"Nomralized MEAN:\", np.mean(y_train), \"min\", np.min(y_train),\"max\", np.max(y_train))\n",
    "\n",
    "        print('Window length', winsize)\n",
    "        print('Step size:', stepsize)\n",
    "        print('Length of trial during experiment', trial_len)\n",
    "        print('Low cutoff freq.', low_cutoff)\n",
    "        print('High cutoff freq.', high_cutoff)\n",
    "        print('Source data file:', source)\n",
    "\n",
    "        leng = x_test.shape[1]\n",
    "\n",
    "        def Encoder():\n",
    "\n",
    "            input_img = Input(shape=(leng, 60))\n",
    "            inputbn = BatchNormalization(axis = 1)(input_img) ###########################################why this axis?\n",
    "\n",
    "            convolved = Conv1D(nb_filters, kernel_size, padding=\"same\", activation='relu',\n",
    "                              kernel_initializer = orth(gain=1.0, seed=None))(inputbn)\n",
    "            dropout1 = Dropout(0.1)(convolved)\n",
    "            convolvedbn = BatchNormalization()(dropout1)\n",
    "            pooled = MaxPooling1D()(convolvedbn)\n",
    "\n",
    "            convolved2 = Conv1D(nb_filters*2, kernel_size, padding=\"same\", activation='relu',\n",
    "                               kernel_initializer = orth(gain=1.0, seed=None))(pooled)\n",
    "            dropout2 = Dropout(0.2)(convolved2)\n",
    "            convolved2bn = BatchNormalization()(dropout2)\n",
    "            pooled2 = MaxPooling1D()(convolved2bn)\n",
    "\n",
    "            convolved3 = Conv1D(nb_filters*4, kernel_size, padding=\"same\", activation='relu',\n",
    "                               kernel_initializer = orth(gain=1.0, seed=None))(pooled2)\n",
    "            dropout3 = Dropout(0.3)(convolved3)\n",
    "            convolved3bn = BatchNormalization()(dropout3)\n",
    "            pooled3 = MaxPooling1D()(convolved3bn)\n",
    "\n",
    "            flat = Flatten()(pooled3)\n",
    "\n",
    "            dense1 = Dense(dense1_n, activation='relu')(flat)\n",
    "            dense1bn = BatchNormalization()(dense1)\n",
    "            dense1do = Dropout(0.5)(dense1bn)\n",
    "\n",
    "            out = Dense(2, activation='softmax')(dense1do)\n",
    "\n",
    "            return Model(input_img, out)\n",
    "\n",
    "\n",
    "        enc = Encoder()\n",
    "        enc.compile(loss=\"binary_crossentropy\", optimizer=\"adadelta\", metrics=[\"accuracy\"])\n",
    "\n",
    "        # enc.summary()\n",
    "        ##########################################################\n",
    "\n",
    "        # Training time!\n",
    "        from keras.callbacks import TensorBoard, EarlyStopping\n",
    "        early_stopping = EarlyStopping(monitor='val_loss', patience=patience, mode='min')\n",
    "\n",
    "        train_history = enc.fit(x_train, y_train,\n",
    "                        epochs=epochs,\n",
    "                        batch_size=40,\n",
    "                        shuffle=True,\n",
    "                        validation_data=(x_test, y_test),\n",
    "                        callbacks=[TensorBoard(log_dir='/home/amplifier/home/CNN_stim'), early_stopping])\n",
    "\n",
    "        ###########################################################\n",
    "\n",
    "        # let's predict a TRAINING sammple:\n",
    "        decoded_train = enc.predict(x_train)\n",
    "        decoded_test = enc.predict(x_test)\n",
    "        #####################################################\n",
    "\n",
    "        # now test sample by sample\n",
    "        cor_test = []\n",
    "        L = x_test.shape\n",
    "        for sample_no in range(x_test.shape[0]):\n",
    "            pred = enc.predict(np.expand_dims(x_test[sample_no],0))\n",
    "            if ((pred[0][0]<pred[0][1]) and (y_test[sample_no,0] < y_test[sample_no,1]) or\n",
    "               ((pred[0][0]>pred[0][1]) & (y_test[sample_no,0] > y_test[sample_no,1]))):\n",
    "                cor_test.append(1)\n",
    "            else:\n",
    "                cor_test.append(0)\n",
    "\n",
    "        cor_train = []\n",
    "        L = x_train.shape\n",
    "        for sample_no in range(x_train.shape[0]):\n",
    "            pred = enc.predict(np.expand_dims(x_train[sample_no],0))\n",
    "            if ((pred[0][0]<pred[0][1]) and (y_train[sample_no,0] < y_train[sample_no,1]) or\n",
    "               ((pred[0][0]>pred[0][1]) & (y_train[sample_no,0] > y_train[sample_no,1]))):\n",
    "                cor_train.append(1)\n",
    "            else:\n",
    "                cor_train.append(0)\n",
    "\n",
    "        # Report accuracies\n",
    "#         print('Accuracy on the test data:', np.mean(cor_test))\n",
    "#         print('Accuracy on the training data:', np.mean(cor_train))\n",
    "        t1 = time.time()\n",
    "        print('Elapsed', t1-t0, 'seconds')\n",
    "\n",
    "        acc[j,k] = np.mean(cor_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.80246914,  0.7654321 ,  0.86419753,  0.87654321,  0.81481481,\n",
       "         0.79012346,  0.81481481],\n",
       "       [ 0.75308642,  0.82098765,  0.7962963 ,  0.80864198,  0.85802469,\n",
       "         0.77160494,  0.69135802],\n",
       "       [ 0.80991736,  0.77272727,  0.7768595 ,  0.72727273,  0.7107438 ,\n",
       "         0.69834711,  0.71900826],\n",
       "       [ 0.58204334,  0.62848297,  0.62229102,  0.6130031 ,  0.61919505,\n",
       "         0.6873065 ,  0.62229102],\n",
       "       [ 0.64019851,  0.62531017,  0.61538462,  0.68238213,  0.63275434,\n",
       "         0.61538462,  0.61042184],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ,\n",
       "         0.        ,  0.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ,\n",
       "         0.        ,  0.        ]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Percent Accuracy')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe85978f7b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = steps\n",
    "y = np.mean(acc[0:len(steps)],1)\n",
    "yerr = 1.96*np.std(acc[0:len(steps),:], axis=1)/np.sqrt(len(steps))\n",
    "plt.errorbar(x, y, yerr=yerr, fmt='o')\n",
    "plt.title('Decoding accuracy on test samples' + '\\n' + 'Bars represent 95% confidence intervals')\n",
    "plt.xlabel('Test/Train Split')\n",
    "plt.ylabel('Percent Accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}