EEG_batch_processing_for_all.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import pickle, os, glob\n",
    "import numpy as np\n",
    "import sys, copy, time\n",
    "\n",
    "import mne\n",
    "mne.set_log_level('WARNING')\n",
    "from EEG.info import info_exp\n",
    "from EEG.converter import converter_mne\n",
    "from EEG.utils import load, save, data_prep, plot_confusion_matrix, plot_mult_conf_matrices,psd\n",
    "\n",
    "import scipy.signal as spsig\n",
    "\n",
    "from mne.decoding import CSP,UnsupervisedSpatialFilter, Vectorizer\n",
    "from mne.time_frequency import psd_multitaper\n",
    "from pyriemann.classification import MDM, TSclassifier\n",
    "from pyriemann.estimation import covariances, XdawnCovariances\n",
    "\n",
    "\n",
    "from sklearn import metrics\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.multiclass import OneVsRestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def psd(raw,picks,tmax,fmax):\n",
    "    psds, freqs = psd_multitaper(raw, low_bias=True, tmax=4.499,\n",
    "                              fmax=50., proj=True, picks=picks,\n",
    "                              n_jobs=1)\n",
    "    psds = 10 * np.log10(psds)\n",
    "    psds_mean = psds.mean(0)\n",
    "    psds_std = psds.std(0)\n",
    "    \n",
    "    return psds_mean, psds_std, freqs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success\n"
     ]
    }
   ],
   "source": [
    "root = \"C:\\\\eeg\\\\01exp\\\\\"\n",
    "labtests = [\"20161129_DBS_001\",\"20161209_KPS_001\",\"20161210_GSH_001\"]\n",
    "names = [\"exp_data_aligned_start_0.cls\",\"exp_data_aligned_start_150.cls\"]\n",
    "filters = [{'min':0,'max':20},{'min':6,'max':16},{'min':10,'max':16}]\n",
    "\n",
    "decoders = [\n",
    "        CSP(n_components=2, reg='ledoit_wolf', log=True),\n",
    "        'Riemann'\n",
    "      ]\n",
    "\n",
    "clfs = [\n",
    "    LinearDiscriminantAnalysis(),\n",
    "    GaussianNB(),\n",
    "    KNeighborsClassifier(),\n",
    "    DecisionTreeClassifier(),\n",
    "    SVC(),\n",
    "    MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(4, 10), random_state=1),\n",
    "    LogisticRegression()\n",
    "]\n",
    "\n",
    "# специфичный параметр продолжительности эпохи \n",
    "tepochs = 4.499\n",
    "\n",
    "statdata = {}\n",
    "stattable = []\n",
    "\n",
    "# по всем испытуемым\n",
    "for idlab, lab in enumerate(labtests):\n",
    "    statdata.update({lab:{}})\n",
    "    \n",
    "    # по всем отсечкам времени переходов \n",
    "    for idname, name in enumerate(names):\n",
    "        statdata[lab].update({name:{}})\n",
    "        test = load(root + lab,name)\n",
    "        data  = converter_mne(test)\n",
    "       \n",
    "        # по всем диапазонам фильтрации\n",
    "        for idpsd, pfilter in enumerate(filters):\n",
    "            freqlabel = str(pfilter['min']) +\"-\" +str(pfilter['max'])\n",
    "            statdata[lab][name].update({freqlabel:{}})\n",
    "            epochs = data.train_epochs()\n",
    "            raw = data.train_raw()\n",
    "            # отфильтруем данные\n",
    "            raw.filter(pfilter['min'],pfilter['max'],\n",
    "                       phase='zero',filter_length='auto', \n",
    "                       fir_window='hamming',l_trans_bandwidth='auto', \n",
    "                       h_trans_bandwidth='auto')\n",
    "            picks = mne.pick_types(info=data.mne_info(), meg=False, eeg=True, misc=False)\n",
    "            # вычислим для вывода графика спектральной плотности мощьности\n",
    "            psds_mean, psds_std, freqs = psd(raw,picks,tepochs,50.)\n",
    "            statdata[lab][name][freqlabel].update({'psd':{'psds_mean':psds_mean,'psds_std':psds_std,'freqs':freqs}})\n",
    "                \n",
    "                \n",
    "            ### decoder\n",
    "            for dec in decoders:\n",
    "                statdata[lab][name][freqlabel].update({dec:{}})\n",
    "                csp = dec\n",
    "\n",
    "                for clf in clfs:\n",
    "                    clfname = copy.copy(clf.__class__.__name__)\n",
    "                    statdata[lab][name][freqlabel][dec].update({clfname:{}})\n",
    "                    \n",
    "                    test_list = []\n",
    "                    for i in range(0,data.num_tests):\n",
    "                        epochs_test = data.test_epochs(i)\n",
    "                        Y_test = epochs_test.events[:,-1]\n",
    "                        X_test = epochs_test.get_data()\n",
    "                        test_list.append({'Y_test':Y_test,'X_test':X_test})\n",
    "                    \n",
    "                    start_time = time.time()\n",
    "                    if(csp == 'Riemann'):\n",
    "                        Y_train = epochs.events[:,-1][:test_list[0]['Y_test'].shape[0]]\n",
    "                        X_train = epochs.get_data()[:test_list[0]['Y_test'].shape[0]]\n",
    "                        X_train = data_prep(X_train, 1000, pfilter['min'], pfilter['max'])\n",
    "                        clf = TSclassifier(clf=clf)\n",
    "                        # compute covariance matricestest_list[i]['Y_test']\n",
    "                        data_cov = covariances(X_train, estimator='oas')\n",
    "                        clf.fit(data_cov , Y_train)\n",
    "\n",
    "                    else:\n",
    "                        Y_train = epochs.events[:,-1]\n",
    "                        X_train = epochs.get_data()\n",
    "                        X_train = data_prep(X_train, 1000, pfilter['min'], pfilter['max'])\n",
    "                        X_train = csp.fit_transform(X_train, Y_train)\n",
    "                        clf.fit(X_train, Y_train)\n",
    "\n",
    "                    tfitv = time.time() - start_time\n",
    "                    \n",
    "                    scores = []\n",
    "                    tscores = []\n",
    "                    classification_report = []\n",
    "                    confusion_matrix = []\n",
    "                    \n",
    "                    for i in range(0, len(test_list)):\n",
    "                        if(csp == 'Riemann'):\n",
    "                            X_test = data_prep(test_list[i]['X_test'][:test_list[0]['Y_test'].shape[0]], 1000, pfilter['min'], pfilter['max'])\n",
    "                            X_test = covariances(X_test, estimator='oas')\n",
    "                            Y_test = test_list[i]['Y_test'][:test_list[0]['Y_test'].shape[0]]\n",
    "                        else:\n",
    "                            X_test = data_prep(test_list[i]['X_test'], 1000, pfilter['min'], pfilter['max'])\n",
    "                            X_test = csp.transform(X_test)\n",
    "                        start_time = time.time()\n",
    "                        scores.append(clf.score(X_test, test_list[i]['Y_test']))\n",
    "                        tscores.append(time.time() - start_time)\n",
    "\n",
    "                        predicted =  clf.predict(X_test)\n",
    "                        classification_report.append(metrics.classification_report(test_list[i]['Y_test'], predicted))\n",
    "                        confusion_matrix.append(metrics.confusion_matrix(test_list[i]['Y_test'],predicted))\n",
    "                    \n",
    "                    #plot_mult_conf_matrices(confusion_matrix,[u'Rest',u'left',u'right'])\n",
    "                    \n",
    "                    statdata[lab][name][freqlabel][dec][clfname].update({\n",
    "                        'max': np.max(scores),\n",
    "                        'mean': np.mean(scores),\n",
    "                        'min': np.min(scores),\n",
    "                        'disp': np.std(scores),\n",
    "                        'conf_matrix': confusion_matrix\n",
    "                    })\n",
    "                    \n",
    "                    if(dec.__class__.__name__ != 'str'):\n",
    "                        decs =  dec.__class__.__name__\n",
    "                    \n",
    "                    stattable.append([\n",
    "                        lab,name,freqlabel,decs,clfname,\n",
    "                        np.max(scores), np.mean(scores),\n",
    "                        np.min(scores), np.std(scores),\n",
    "                        tfitv, np.mean(tscores),\n",
    "                        confusion_matrix,\n",
    "                        {'psds_mean':psds_mean,'psds_std':psds_std,'freqs':freqs}\n",
    "                        \n",
    "                    ])\n",
    "                    \n",
    "                    \n",
    "save(root,'result.dat',stattable)\n",
    "print \"success\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}