original_CNN_GRU.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 运行先安MNE，pip install mne\n",
    "# 解压文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:33.437387Z",
     "iopub.status.busy": "2021-10-31T14:04:33.437174Z",
     "iopub.status.idle": "2021-10-31T14:04:33.439881Z",
     "shell.execute_reply": "2021-10-31T14:04:33.439341Z",
     "shell.execute_reply.started": "2021-10-31T14:04:33.437340Z"
    }
   },
   "outputs": [],
   "source": [
    "# !unzip \"data/data112870/BCICIV_2a_mat.zip\" -d data/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:33.440707Z",
     "iopub.status.busy": "2021-10-31T14:04:33.440507Z",
     "iopub.status.idle": "2021-10-31T14:04:34.257824Z",
     "shell.execute_reply": "2021-10-31T14:04:34.256948Z",
     "shell.execute_reply.started": "2021-10-31T14:04:33.440665Z"
    }
   },
   "outputs": [],
   "source": [
    "from read_data import read_data\r\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:34.259049Z",
     "iopub.status.busy": "2021-10-31T14:04:34.258711Z",
     "iopub.status.idle": "2021-10-31T14:04:34.262600Z",
     "shell.execute_reply": "2021-10-31T14:04:34.261629Z",
     "shell.execute_reply.started": "2021-10-31T14:04:34.258894Z"
    }
   },
   "outputs": [],
   "source": [
    "train_path = r\"data/A01T.mat\"\n",
    "test_path = r\"data/A01E.mat\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trian Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:34.264059Z",
     "iopub.status.busy": "2021-10-31T14:04:34.263681Z",
     "iopub.status.idle": "2021-10-31T14:04:38.791645Z",
     "shell.execute_reply": "2021-10-31T14:04:38.790940Z",
     "shell.execute_reply.started": "2021-10-31T14:04:34.263956Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n",
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n",
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n",
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n",
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n",
      "Creating RawArray with float64 data, n_channels=25, n_times=96735\n",
      "    Range : 0 ... 96734 =      0.000 ...   386.936 secs\n",
      "Ready.\n",
      "Not setting metadata\n",
      "Not setting metadata\n",
      "48 matching events found\n",
      "Setting baseline interval to [3.0, 6.0] sec\n",
      "Applying baseline correction (mode: mean)\n",
      "0 projection items activated\n",
      "Loading data for 48 events and 751 original time points ...\n",
      "0 bad epochs dropped\n"
     ]
    }
   ],
   "source": [
    "train_data=np.zeros((6,1056,751),dtype=np.float32)\n",
    "train_label=np.zeros((6,1056),dtype=np.int64)\n",
    "for i in range(6):\n",
    "    data,label = read_data(train_path,-(i+1))\n",
    "    train_data[i]=data\n",
    "    label = np.array(label[:])\n",
    "    train_label[i]=label\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:38.792783Z",
     "iopub.status.busy": "2021-10-31T14:04:38.792562Z",
     "iopub.status.idle": "2021-10-31T14:04:38.795508Z",
     "shell.execute_reply": "2021-10-31T14:04:38.794844Z",
     "shell.execute_reply.started": "2021-10-31T14:04:38.792741Z"
    }
   },
   "outputs": [],
   "source": [
    "# test_data=np.zeros((6,1056,751),dtype=np.float32)\n",
    "# test_label=np.zeros((6,1056),dtype=np.int64)\n",
    "# for i in range(6):\n",
    "#     data,label = read_data(test_path,-(i+1))\n",
    "#     test_data[i]=data\n",
    "#     label = np.array(label[:])\n",
    "#     test_label[i]=label\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data_Reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:38.797797Z",
     "iopub.status.busy": "2021-10-31T14:04:38.797560Z",
     "iopub.status.idle": "2021-10-31T14:04:38.805968Z",
     "shell.execute_reply": "2021-10-31T14:04:38.804683Z",
     "shell.execute_reply.started": "2021-10-31T14:04:38.797752Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4.29707\n"
     ]
    }
   ],
   "source": [
    "train_data = train_data.reshape(6336,751)\n",
    "train_label = train_label.reshape(6336,)\n",
    "# test_data = test_data.reshape(6336,751)\n",
    "# test_label = test_label.reshape(6336,)\n",
    "print(train_data[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 验证标签的对错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:38.809554Z",
     "iopub.status.busy": "2021-10-31T14:04:38.809343Z",
     "iopub.status.idle": "2021-10-31T14:04:40.014017Z"
    }
   },
   "outputs": [],
   "source": [
    "import paddle\n",
    "import paddle.nn.functional as F\n",
    "import paddle.nn as nn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:40.015362Z",
     "iopub.status.busy": "2021-10-31T14:04:40.015130Z",
     "iopub.status.idle": "2021-10-31T14:04:40.026178Z"
    }
   },
   "outputs": [],
   "source": [
    "class CNN_GRU(nn.Layer):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv1D(1,32,9,1,padding='same',data_format='NCL')\n",
    "        self.padding1 = nn.MaxPool1D(kernel_size=2,stride=2,padding='valid')\n",
    "        self.conv2 = nn.Conv1D(32,32,9,1,padding='same',data_format='NCL')\n",
    "        self.padding2 = nn.MaxPool1D(kernel_size=2,stride=2,padding='valid')\n",
    "        self.conv3 = nn.Conv1D(32,32,9,1,padding='same',\n",
    "        data_format='NCL')\n",
    "        self.padding3 = nn.MaxPool1D(kernel_size=2,stride=2,padding='valid')\n",
    "        self.flatten1 = nn.Flatten()\n",
    "        self.flatten2 = nn.Flatten()\n",
    "        # self.gru = nn.GRU(1,64,1)\n",
    "        self.gru = nn.GRU(2976,64,1)\n",
    "        self.dense1 = nn.Linear(64,64)\n",
    "        self.dense2 = nn.Linear(64,4)\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.relu2 = nn.ReLU()\n",
    "        self.relu3 = nn.ReLU()\n",
    "        self.relu4 = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(p=0.5)\n",
    "    def forward(self,x):\n",
    "        x=self.conv1(x)\n",
    "        x=self.relu1(x)\n",
    "        x=self.padding1(x)\n",
    "        x=self.conv2(x)\n",
    "        x=self.relu2(x)\n",
    "        x=self.padding2(x)\n",
    "        x=self.conv3(x)\n",
    "        x=self.relu3(x)\n",
    "        x=self.padding3(x)\n",
    "        x=self.flatten1(x)\n",
    "        # x = x.unsqueeze(-1)\n",
    "        x = x.unsqueeze(1)\n",
    "        x,h=self.gru(x)\n",
    "        x=self.dense1(x)\n",
    "        x=self.relu4(x)\n",
    "        x=self.dropout(x)\n",
    "        x=self.dense2(x)\n",
    "        x=self.flatten2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:40.027091Z",
     "iopub.status.busy": "2021-10-31T14:04:40.026898Z",
     "iopub.status.idle": "2021-10-31T14:04:42.900923Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------------------\n",
      " Layer (type)       Input Shape            Output Shape           Param #    \n",
      "===============================================================================\n",
      "   Conv1D-1        [[1, 1, 751]]           [1, 32, 751]             320      \n",
      "    ReLU-1         [[1, 32, 751]]          [1, 32, 751]              0       \n",
      "  MaxPool1D-1      [[1, 32, 751]]          [1, 32, 375]              0       \n",
      "   Conv1D-2        [[1, 32, 375]]          [1, 32, 375]            9,248     \n",
      "    ReLU-2         [[1, 32, 375]]          [1, 32, 375]              0       \n",
      "  MaxPool1D-2      [[1, 32, 375]]          [1, 32, 187]              0       \n",
      "   Conv1D-3        [[1, 32, 187]]          [1, 32, 187]            9,248     \n",
      "    ReLU-3         [[1, 32, 187]]          [1, 32, 187]              0       \n",
      "  MaxPool1D-3      [[1, 32, 187]]          [1, 32, 93]               0       \n",
      "   Flatten-1       [[1, 32, 93]]            [1, 2976]                0       \n",
      "     GRU-1         [[1, 1, 2976]]    [[1, 1, 64], [1, 1, 64]]     584,064    \n",
      "   Linear-1         [[1, 1, 64]]            [1, 1, 64]             4,160     \n",
      "    ReLU-4          [[1, 1, 64]]            [1, 1, 64]               0       \n",
      "   Dropout-1        [[1, 1, 64]]            [1, 1, 64]               0       \n",
      "   Linear-2         [[1, 1, 64]]            [1, 1, 4]               260      \n",
      "   Flatten-2        [[1, 1, 4]]               [1, 4]                 0       \n",
      "===============================================================================\n",
      "Total params: 607,300\n",
      "Trainable params: 607,300\n",
      "Non-trainable params: 0\n",
      "-------------------------------------------------------------------------------\n",
      "Input size (MB): 0.00\n",
      "Forward/backward pass size (MB): 0.83\n",
      "Params size (MB): 2.32\n",
      "Estimated Total Size (MB): 3.15\n",
      "-------------------------------------------------------------------------------\n",
      "\n",
      "Tensor(shape=[1, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=False,\n",
      "       [[-0.36932158, -0.30767888,  1.12718070,  0.78158110]])\n"
     ]
    }
   ],
   "source": [
    "input_spec = paddle.static.InputSpec(\n",
    "    shape=(-1,1,751),\n",
    "    dtype='float32',\n",
    "    name='x'\n",
    ")\n",
    "model = CNN_GRU()\n",
    "\n",
    "paddle.summary(model,input_spec)\n",
    "out = model(paddle.randn((1,1,750)))\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:42.902024Z",
     "iopub.status.busy": "2021-10-31T14:04:42.901792Z",
     "iopub.status.idle": "2021-10-31T14:04:42.905556Z"
    }
   },
   "outputs": [],
   "source": [
    "loss_function = paddle.nn.CrossEntropyLoss()\n",
    "# lr_scheduler = paddle.optimizer.lr.CosineAnnealingDecay(\n",
    "#     learning_rate=LEARNING_RATE,\n",
    "#     T_max=NUM_EPOCHS\n",
    "# )\n",
    "optimizer = paddle.optimizer.Adam(\n",
    "    learning_rate=1e-4,\n",
    "    parameters=model.parameters()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8:2 T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:42.906486Z",
     "iopub.status.busy": "2021-10-31T14:04:42.906292Z",
     "iopub.status.idle": "2021-10-31T14:04:43.315228Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6336, 751) (6336,)\n"
     ]
    }
   ],
   "source": [
    "data = train_data\n",
    "label = train_label-1\n",
    "print(data.shape,label.shape)\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler #标准化\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "sk = StandardScaler()\n",
    "data = sk.fit_transform(data)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "data=np.expand_dims(data,1)\n",
    "label=np.expand_dims(label,1)\n",
    "# train_data,test_data,train_label,test_label = train_test_split(data,label,train_size=0.8)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8:2 E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.316343Z",
     "iopub.status.busy": "2021-10-31T14:04:43.316132Z",
     "iopub.status.idle": "2021-10-31T14:04:43.319119Z"
    }
   },
   "outputs": [],
   "source": [
    "# data = test_data\n",
    "# label = test_label-1\n",
    "# print(data.shape,label.shape)\n",
    "\n",
    "# from sklearn.preprocessing import StandardScaler #标准化\n",
    "# from sklearn.preprocessing import MinMaxScaler\n",
    "# sk = StandardScaler()\n",
    "# data = sk.fit_transform(data)\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# label=label\n",
    "# data=np.expand_dims(data,1)\n",
    "# label=np.expand_dims(label,1)\n",
    "## train_data,test_data,train_label,test_label = train_test_split(data,label,train_size=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# E.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.320050Z",
     "iopub.status.busy": "2021-10-31T14:04:43.319843Z",
     "iopub.status.idle": "2021-10-31T14:04:43.323972Z"
    }
   },
   "outputs": [],
   "source": [
    "# train_label=train_label-1\n",
    "# test_label=test_label-1\n",
    "# from sklearn.preprocessing import StandardScaler #标准化\n",
    "# from sklearn.preprocessing import MinMaxScaler\n",
    "# sk = StandardScaler()\n",
    "# train_data = sk.fit_transform(train_data)\n",
    "# test_data = sk.fit_transform(test_data)\n",
    "# train_data=np.expand_dims(train_data,1)\n",
    "# train_label=np.expand_dims(train_label,1)\n",
    "# test_data=np.expand_dims(test_data,1)\n",
    "# test_label=np.expand_dims(test_label,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.324844Z",
     "iopub.status.busy": "2021-10-31T14:04:43.324658Z",
     "iopub.status.idle": "2021-10-31T14:04:43.328132Z"
    }
   },
   "outputs": [],
   "source": [
    "NUM_EPOCHS=100\n",
    "TRAIN_BATCH_SIZE=28\n",
    "# print(train_label.shape,test_label.shape)\n",
    "# print(train_data.shape,test_data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 五折交叉验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.329003Z",
     "iopub.status.busy": "2021-10-31T14:04:43.328800Z",
     "iopub.status.idle": "2021-10-31T14:04:43.337231Z"
    }
   },
   "outputs": [],
   "source": [
    "def k_fold_indices(num_samples, k=5):\n",
    "    indices = np.random.permutation(num_samples)\n",
    "    if k <= 1:\n",
    "        print(f\"Expect k>1, but received k={k}\")\n",
    "    n_samples_per_fold = num_samples // k\n",
    "\n",
    "    anchors = [n_samples_per_fold for _ in range(k)]\n",
    "    for i in range(0, num_samples - k * n_samples_per_fold):\n",
    "        anchors[i] += 1\n",
    "    for i in range(1, len(anchors)):\n",
    "        anchors[i] = anchors[i - 1] + anchors[i]\n",
    "    assert anchors[-1] == num_samples\n",
    "    anchors.pop(-1)\n",
    "    assert len(anchors) == k - 1\n",
    "    \n",
    "    folds = np.split(indices, anchors)\n",
    "    train_indices = [np.empty(0, dtype=np.int64) for _ in range(k)]\n",
    "    valid_indices = []\n",
    "\n",
    "    for i, fold in enumerate(folds):\n",
    "        valid_indices.append(fold)\n",
    "        for j in range(k):\n",
    "            if j == i:\n",
    "                continue\n",
    "            train_indices[j] = np.concatenate((train_indices[j], fold))\n",
    "\n",
    "    return list(zip(train_indices, valid_indices))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.338052Z",
     "iopub.status.busy": "2021-10-31T14:04:43.337872Z",
     "iopub.status.idle": "2021-10-31T14:04:43.342351Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from paddle.io import Dataset\n",
    "\n",
    "\n",
    "class MIDataset(Dataset):\n",
    "    def __init__(self, data,label):\n",
    "        self.data = data\n",
    "        self.label = label\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        data = self.data[idx]\n",
    "        label = self.label[idx]\n",
    "        return data, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-31T14:04:43.343163Z",
     "iopub.status.busy": "2021-10-31T14:04:43.342981Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The loss value printed in the log is the current step, and the metric is the average value of previous steps.\n",
      "Epoch 1/100\n",
      "step  20/181 [==>...........................] - loss: 1.3826 - acc: 0.2786 - ETA: 2s - 15ms/step"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/utils.py:77: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  return (isinstance(seq, collections.Sequence) and\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 181/181 [==============================] - loss: 1.2563 - acc: 0.3254 - 8ms/step          \n",
      "Eval begin...\n",
      "step 46/46 [==============================] - loss: 1.0529 - acc: 0.5055 - 4ms/step          \n",
      "Eval samples: 1268\n",
      "Epoch 2/100\n",
      "step 181/181 [==============================] - loss: 1.1867 - acc: 0.4773 - 7ms/step          \n",
      "Eval begin...\n",
      "step 46/46 [==============================] - loss: 1.1042 - acc: 0.6569 - 5ms/step          \n",
      "Eval samples: 1268\n",
      "Epoch 3/100\n",
      "step 181/181 [==============================] - loss: 0.8814 - acc: 0.6150 - 8ms/step          \n",
      "Eval begin...\n",
      "step 46/46 [==============================] - loss: 0.8707 - acc: 0.8021 - 4ms/step          \n",
      "Eval samples: 1268\n",
      "Epoch 4/100\n",
      "step 150/181 [=======================>......] - loss: 0.5813 - acc: 0.7350 - ETA: 0s - 7ms/step"
     ]
    }
   ],
   "source": [
    "result=[]\n",
    "for train_indices, valid_indices in k_fold_indices(data.shape[0], 5):\n",
    "    train_data = data[train_indices]\n",
    "    train_label = label[train_indices]\n",
    "    test_data = data[valid_indices]\n",
    "    test_label = label[valid_indices]\n",
    "    train_dataset = MIDataset(train_data,train_label)\n",
    "    test_dataset = MIDataset(test_data,test_label)\n",
    "    train_loader = paddle.io.DataLoader(\n",
    "        train_dataset, \n",
    "        batch_size=28, \n",
    "        shuffle=True,\n",
    "        drop_last=True)\n",
    "    test_loader = paddle.io.DataLoader(\n",
    "        test_dataset, \n",
    "        batch_size=28,\n",
    "        shuffle=True\n",
    "    )\n",
    "    model = CNN_GRU()\n",
    "    loss_function = paddle.nn.CrossEntropyLoss()\n",
    "    optimizer = paddle.optimizer.Adam(\n",
    "    learning_rate=1e-4,\n",
    "    parameters=model.parameters())\n",
    "    model_handler = paddle.Model(model)\n",
    "    model_handler.prepare(optimizer=optimizer,\n",
    "              loss=loss_function,\n",
    "              metrics=paddle.metric.Accuracy())\n",
    "    model_handler.fit(train_loader,\n",
    "          test_loader,\n",
    "          epochs=100,\n",
    "          batch_size=28,\n",
    "          verbose=1)\n",
    "    result.append(model_handler.evaluate(test_dataset, batch_size=test_data.shape[0]))\n",
    "a=0\n",
    "for i in range(5):\n",
    "    a=result[i]['acc']/5+a\n",
    "a"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "0e2cd77eede4fb534e37c318dcb84244d460c76d4a4178970183713b6b86de86"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}