main_FIR.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": [
    "# -*- 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\n",
    "\n",
    "import fir_class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test=h5py.File('Ma/DeepANES.mat')\n",
    "\n",
    "ECoG = np.array(test['ECoG'])\n",
    "EEG = np.array(test['EEG'])\n",
    "EEG = np.delete(EEG, 14, axis=1)\n",
    "EEG = EEG.astype('float32')\n",
    "ECoG = ECoG.astype('float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "order = 5\n",
    "time_range = 100\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 = Variable((EEG_t[train_time[0]:train_time[1], :, :]).astype('float32'))\n",
    "ECoG_t = Variable((ECoG_t[train_time[0]:train_time[1], :, :]).astype('float32'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def calNN(timeSpacePerceptron, EEG_t, ECoG_t, EEG_filtered_prev, ECoG_filtered_prev, loop=200):\n",
    "    loss_history = np.zeros((loop, 1))\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",
    "    for i in range(loop):\n",
    "        timeSpacePerceptron.zerograds()\n",
    "        x1, x2, EEG_filtered_prev, ECoG_filtered_prev = timeSpacePerceptron(EEG_t, ECoG_t, EEG_filtered_prev, ECoG_filtered_prev, 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",
    "    return timeSpacePerceptron, loss_history, EEG_filtered_prev, ECoG_filtered_prev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loop_calNN(EEG_t, ECoG_t, data_type, loop=200, loop_num=20):\n",
    "    EEG_filtered_prev = [Variable(np.zeros((time_range, 1)).astype('float32')) for j in range(EEG.shape[1])] #前の出力をいれるところ　(RNN)\n",
    "    ECoG_filtered_prev = [Variable(np.zeros((time_range, 1)).astype('float32')) for j in range(ECoG.shape[1])] #前の出力をいれるところ\n",
    "    saved_data = dict()\n",
    "    outout = []\n",
    "    out_loss_history = []\n",
    "    for n in range(loop_num):\n",
    "        out = []\n",
    "        loss_history = np.zeros((loop, 1))\n",
    "        timeSpacePerceptron = fir_class.__dict__[\"TimeSpacePerceptron{0}\".format(data_type)](time_range)\n",
    "        timeSpacePerceptron, loss_history, EEG_filtered_prev, ECoG_filtered_prev = calNN(timeSpacePerceptron, EEG_t, ECoG_t, EEG_filtered_prev, ECoG_filtered_prev, loop=loop)\n",
    "        out_loss_history.append(loss_history)\n",
    "        outout.append(timeSpacePerceptron)\n",
    "    saved_data['loss_history'] = out_loss_history\n",
    "    saved_data['NN'] = outout\n",
    "    return saved_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.168619155883789\n",
      "24.177961111068726\n",
      "35.94694805145264\n",
      "47.4869270324707\n"
     ]
    }
   ],
   "source": [
    "saved_data = dict()\n",
    "loop = 50\n",
    "loop_num = 1\n",
    "st = time.time()\n",
    "\n",
    "# channle をわけない\n",
    "data_type ='0000'\n",
    "saved_data[data_type] =  loop_calNN(EEG_t, ECoG_t, data_type, loop=loop, loop_num=loop_num)\n",
    "print(time.time()-st)\n",
    "\n",
    "data_type ='0100'\n",
    "saved_data[data_type] =  loop_calNN(EEG_t, ECoG_t, data_type, loop=loop, loop_num=loop_num)\n",
    "print(time.time()-st)\n",
    "\n",
    "data_type ='0010'\n",
    "saved_data[data_type] =  loop_calNN(EEG_t, ECoG_t, data_type, loop=loop, loop_num=loop_num)\n",
    "print(time.time()-st)\n",
    "\n",
    "data_type ='0110'\n",
    "saved_data[data_type] =  loop_calNN(EEG_t, ECoG_t, data_type, loop=loop, loop_num=loop_num)\n",
    "print(time.time()-st)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "226.63573098182678\n",
      "404.01942706108093\n",
      "576.5715849399567\n",
      "759.396605014801\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/vv000844/.pyenvi/versions/anaconda3-2.5.0/lib/python3.5/site-packages/chainer/optimizer.py:520: RuntimeWarning: invalid value encountered in multiply\n",
      "  grad *= rate\n"
     ]
    }
   ],
   "source": [
    "# channle をわける\n",
    "# EEG\n",
    "data_type ='0001'\n",
    "tmp_data = []\n",
    "for ch in range(EEG.shape[1]):\n",
    "    tmp_data.append(loop_calNN(EEG_t[:, ch, :], ECoG_t, data_type, loop=loop, loop_num=loop_num))\n",
    "saved_data[data_type] =  tmp_data\n",
    "print(time.time()-st)\n",
    "\n",
    "data_type ='0101'\n",
    "tmp_data = []\n",
    "for ch in range(EEG.shape[1]):\n",
    "    tmp_data.append(loop_calNN(EEG_t[:, ch, :], ECoG_t, data_type, loop=loop, loop_num=loop_num))\n",
    "saved_data[data_type] =  tmp_data\n",
    "print(time.time()-st)\n",
    "\n",
    "# ECoG\n",
    "data_type ='0011'\n",
    "tmp_data = []\n",
    "for ch in range(ECoG.shape[1]):\n",
    "    tmp_data.append(loop_calNN(EEG_t, ECoG_t[:, ch, :], data_type, loop=loop, loop_num=loop_num))\n",
    "saved_data[data_type] =  tmp_data\n",
    "print(time.time()-st)\n",
    "\n",
    "data_type ='0111'\n",
    "tmp_data = []\n",
    "for ch in range(ECoG.shape[1]):\n",
    "    tmp_data.append(loop_calNN(EEG_t, ECoG_t[:, ch, :], data_type, loop=loop, loop_num=loop_num))\n",
    "saved_data[data_type] =  tmp_data\n",
    "print(time.time()-st)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pickle.dump(saved_data, open('result_FIR_{0}{1}.pkl'.format(loop, loop_num), 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#train_time[1]-train_time[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#eeg_reconstruct, eeg_filtered = outout[2][99](EEG_t, ECoG_t, train=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#for i in range(16):\n",
    "#    print(np.corrcoef(eeg_reconstruct.data[:,i], eeg_filtered.data[:,i])[0, 1])"
   ]
  },
  {
   "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
}