main_0101.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FIR　EEG-ECoG 共通 EEG 予測 共通\n",
    "\n",
    "1. FIR 0, IIR 1, LSTM 2\n",
    "2. EEG-ECoG間でフィルター共通 0, バラバラ 1\n",
    "3. 予測対象 EEG 0, ECoG 1\n",
    "4. 予測の仕方 共通 0, NNをわける（フォルター特性が変わる） 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data_type = '0101'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf_8 -*-  \n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn\n",
    "\n",
    "import copy\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime\n",
    "import math\n",
    "import time\n",
    "\n",
    "import chainer\n",
    "from chainer import cuda, Function, gradient_check, utils, Variable\n",
    "from chainer import optimizers, serializers\n",
    "from chainer import Link, Chain, ChainList\n",
    "import chainer.functions as F\n",
    "import chainer.links as L\n",
    "from scipy import signal\n",
    "\n",
    "\n",
    "import pickle\n",
    "import sys\n",
    "import random\n",
    "import h5py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test=h5py.File('Ma/DeepANES.mat')\n",
    "\n",
    "ECoG = np.array(test['ECoG'])\n",
    "EEG = np.array(test['EEG'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "EEG = np.delete(EEG, 14, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "EEG = EEG.astype('float32')\n",
    "ECoG = ECoG.astype('float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# FIR をEEG, ECoG 全部で共通　9808.40625\n",
    "class TimeSpacePerceptron(Chain):\n",
    "    def __init__(self):\n",
    "        self.tt = time_range\n",
    "        self.eeg_num =1\n",
    "        self.ecog_num = 256\n",
    "        super(TimeSpacePerceptron, self).__init__(\n",
    "            transformECoG = L.Linear(self.ecog_num, self.eeg_num)# ECoG to EEG 空間\n",
    "            )\n",
    "        super(TimeSpacePerceptron, self).add_link('IIR_ECoG', L.Linear(10, 1))\n",
    "        super(TimeSpacePerceptron, self).add_link('IIR_EEG', L.Linear(10, 1))\n",
    "        #for eeg_ch in range(self.eeg_num):\n",
    "        #    super(TimeSpacePerceptron, self).add_link('IIR_EEG{0}'.format(eeg_ch), L.Linear(10, 1))\n",
    "        #for ecog_ch in range(self.ecog_num):\n",
    "        #    super(TimeSpacePerceptron, self).add_link('IIR_ECoG{0}'.format(ecog_ch), L.Linear(10, 1))\n",
    "        self.EEG_filtered_prev = [Variable(np.zeros((self.tt, 1)).astype('float32')) for j in range(self.eeg_num)] #前の出力をいれるところ　(RNN)\n",
    "        self.ECoG_filtered_prev = [Variable(np.zeros((self.tt, 1)).astype('float32')) for j in range(self.ecog_num)] #前の出力をいれるところ\n",
    "        \n",
    "    def __call__(self, EEG_t, ECoG_t, train=False):\n",
    "        EEG_filtered_prev = self.EEG_filtered_prev\n",
    "        ECoG_filtered_prev = self.ECoG_filtered_prev\n",
    "        # EEG_t は 16 * time * time_delay\n",
    "        #EEG FIR\n",
    "        EEG_filtered = [] #  y0, y1, y2, y3, y4 が入る ch の数だけ配列\n",
    "        for ch in range(self.eeg_num):\n",
    "            pre_y = [np.zeros((self.tt, 1)).astype('float32') for  i in range(5)]\n",
    "            for t in range(5):\n",
    "                pre_y[t][t:] = EEG_filtered_prev[ch].data[:len(pre_y[t])-t]\n",
    "                pre_y[t] = Variable(pre_y[t])\n",
    "            x = F.concat((EEG_t, pre_y[0], pre_y[1], pre_y[2], pre_y[3], pre_y[4]))\n",
    "            y = self.__dict__['IIR_EEG'](x)\n",
    "            EEG_filtered.append(y)\n",
    "            EEG_filtered_prev[ch] = y\n",
    "        EEG_filtered = F.concat(tuple(EEG_filtered))\n",
    "        #ECoG FIR\n",
    "        ECoG_filtered = [] #  y0, y1, y2, y3, y4 が入る ch の数だけ配列\n",
    "        for ch in range(self.ecog_num):\n",
    "            pre_y = [np.zeros((self.tt, 1)).astype('float32') for  i in range(5)]\n",
    "            for t in range(5):\n",
    "                pre_y[t][t:] = ECoG_filtered_prev[ch].data[:len(pre_y[t])-t]\n",
    "                pre_y[t] = Variable(pre_y[t])\n",
    "            x = F.concat((ECoG_t[:, ch, :], pre_y[0], pre_y[1], pre_y[2], pre_y[3], pre_y[4]))\n",
    "            y = self.__dict__['IIR_ECoG'](x)\n",
    "            ECoG_filtered.append(y)\n",
    "            ECoG_filtered_prev[ch] = y\n",
    "        ECoG_filtered = F.concat(tuple(ECoG_filtered))\n",
    "        # ここまで FIR\n",
    "        ecog_space = self.transformECoG(ECoG_filtered)\n",
    "        ecog_space_dropout = F.dropout(ecog_space, train=train, ratio=0.5)\n",
    "        eeg  = EEG_filtered\n",
    "        self.EEG_filtered_prev =EEG_filtered_prev\n",
    "        self.ECoG_filtered_prev = ECoG_filtered_prev\n",
    "        return ecog_space_dropout, eeg\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "order = 5\n",
    "time_range = 1999\n",
    "\n",
    "train_time = [0, time_range]\n",
    "hamming = signal.hamming(train_time[1]-train_time[0])\n",
    "#training ぶんだけにする\n",
    "#EEG_t = np.zeros((EEG.shape[0]-order+1, EEG.shape[1], order))\n",
    "#ECoG_t = np.zeros((ECoG.shape[0]-order+1, ECoG.shape[1], order))\n",
    "EEG_t = np.zeros((train_time[1]-train_time[0], EEG.shape[1], order))\n",
    "ECoG_t = np.zeros((train_time[1]-train_time[0], ECoG.shape[1], order))\n",
    "EEG_tmp = EEG[train_time[0]:train_time[1], :] *np.array([hamming]*EEG.shape[1]).T\n",
    "ECoG_tmp = ECoG[train_time[0]:train_time[1], :] *np.array([hamming]*ECoG.shape[1]).T\n",
    "for t in range(order):\n",
    "    for ch in range(EEG.shape[1]):\n",
    "        #EEG_t[:,ch,t] = EEG[:EEG.shape[0]-order+1, ch] \n",
    "        EEG_t[t:,ch,t] = EEG_tmp[t:, ch] \n",
    "    for ch in range(ECoG.shape[1]):\n",
    "        #ECoG_t[:,ch,t] = ECoG[:ECoG.shape[0]-order+1, ch] \n",
    "        ECoG_t[t:,ch,t] = ECoG_tmp[t:, ch] \n",
    "EEG_t = EEG_t[train_time[0]:train_time[1], :, :]\n",
    "ECoG_t = ECoG_t[train_time[0]:train_time[1], :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0176591873168945\n",
      "7544197.0\n",
      "1.7481658458709717\n",
      "16092539.0\n",
      "2.05792498588562\n",
      "1074483.375\n",
      "1.8893039226531982\n",
      "1620915.875\n",
      "1.7801530361175537\n",
      "91314.203125\n",
      "1.7710201740264893\n",
      "9058863.0\n",
      "1.8062660694122314\n",
      "509042.3125\n",
      "1.7201440334320068\n",
      "2732715.0\n",
      "1.6833701133728027\n",
      "114285.734375\n",
      "1.7724418640136719\n",
      "41786332.0\n",
      "1.7436118125915527\n",
      "26400162.0\n",
      "1.8413119316101074\n",
      "15676139.0\n",
      "1.7251341342926025\n",
      "34202984.0\n",
      "1.7238011360168457\n",
      "38799.55078125\n",
      "1.8825671672821045\n",
      "12494269.0\n",
      "1.7458701133728027\n",
      "16754257.0\n"
     ]
    }
   ],
   "source": [
    "saved_data = dict()\n",
    "for ch_eeg in range(EEG.shape[1]):\n",
    "    outout = []\n",
    "    out_loss_history = []\n",
    "    saved_data_ch = dict()\n",
    "    for n in range(1):#20回\n",
    "        loop = 1 #200\n",
    "        out = []\n",
    "        loss_history = np.zeros((loop, 1))\n",
    "        st = time.time()\n",
    "        timeSpacePerceptron = TimeSpacePerceptron()\n",
    "        #optimizer = optimizers.RMSprop()\n",
    "        optimizer = optimizers.AdaDelta()\n",
    "        optimizer.setup(timeSpacePerceptron)\n",
    "        optimizer.add_hook(chainer.optimizer.WeightDecay(0.05))\n",
    "        #optimizer.add_hook(chainer.optimizer.Lasso(0.5))\n",
    "        optimizer.add_hook(chainer.optimizer.GradientClipping(0.5))\n",
    "        #timeSpacePerceptron.zerograds()\n",
    "        eeg_data = Variable((EEG_t[:, ch_eeg,:]).astype('float32'))\n",
    "        ecog_data = Variable((ECoG_t).astype('float32'))\n",
    "        for i in range(loop):\n",
    "            timeSpacePerceptron.zerograds()\n",
    "            x1, x2 = timeSpacePerceptron(eeg_data, ecog_data, train=True)\n",
    "            loss = F.mean_squared_error(x1, x2)\n",
    "            loss.backward()\n",
    "            optimizer.prepare()\n",
    "            optimizer.update()\n",
    "            loss_history[i] = loss.data\n",
    "            out.append(copy.deepcopy(timeSpacePerceptron))\n",
    "        out_loss_history.append(loss_history)\n",
    "        outout.append(out)\n",
    "    print(time.time()-st)\n",
    "    print(loss.data)\n",
    "    saved_data_ch['loss_history'] = out_loss_history\n",
    "    saved_data_ch['NN'] = outout\n",
    "    saved_data[ch_eeg] = saved_data_ch\n",
    "\n",
    "pickle.dump(saved_data, open('result{0}.pkl'.format(data_type), 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#a = pickle.load(open('result{0}.pkl'.format(data_type), 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}