Datasets
Models
Downloads: 1
1318 lines (1317 with data), 45.7 kB
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# WESAD EMI-LSTM"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Adapted from Microsoft's notebooks, available at https://github.com/microsoft/EdgeML authored by Dennis et al."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Imports"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"ExecuteTime": {
"end_time": "2019-07-15T18:30:17.522073Z",
"start_time": "2019-07-15T18:30:17.217355Z"
},
"scrolled": true
},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"from tabulate import tabulate\n",
"import os\n",
"import datetime as datetime\n",
"import pickle as pkl"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## DataFrames from CSVs"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2019-07-15T18:30:28.212447Z",
"start_time": "2019-07-15T18:30:17.889941Z"
}
},
"outputs": [],
"source": [
"filtered_train = pd.read_csv('/home/sf/data/allchest.csv')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Preprocessing "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T16:01:09.440118Z",
"start_time": "2019-06-18T16:01:09.394271Z"
},
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['ID', 'chestACCx', 'chestACCy', 'chestACCz', 'chestECG', 'chestEMG',\n",
" 'chestEDA', 'chestTemp', 'chestResp', 'label'],\n",
" dtype='object')"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"filtered_train.columns"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[10 11 13 14 15 16 17 2 3 4 5 6 7 8 9]\n",
"[1 3 2]\n"
]
}
],
"source": [
"filtered_train = filtered_train[filtered_train['label']<4]\n",
"filtered_train = filtered_train[filtered_train['label']!=0]\n",
"print(filtered_train['ID'].unique())\n",
"print(filtered_train['label'].unique())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Split Ground Truth "
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"ExecuteTime": {
"end_time": "2019-07-15T18:30:37.760226Z",
"start_time": "2019-07-15T18:30:37.597908Z"
}
},
"outputs": [],
"source": [
"filtered_target = filtered_train['label']\n",
"filtered_train = filtered_train.drop(['ID', 'label'], axis=1)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"ExecuteTime": {
"end_time": "2019-07-15T18:32:27.581110Z",
"start_time": "2019-07-15T18:32:27.576162Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(23206404,)\n",
"(23206404, 8)\n"
]
}
],
"source": [
"print(filtered_target.shape)\n",
"print(filtered_train.shape)\n",
"filtered_target=filtered_target.replace({1:0,2:1,3:2})\n",
"filtered_train=filtered_train[0:23206400]\n",
"filtered_target=filtered_target[0:23206400]"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(23206400,)\n",
"(23206400, 8)\n"
]
}
],
"source": [
"print(filtered_target.shape)\n",
"print(filtered_train.shape)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:24:41.449331Z",
"start_time": "2019-06-19T05:24:41.445741Z"
},
"scrolled": true
},
"outputs": [],
"source": [
"filtered_target = filtered_target.values.reshape(132608, 175) # 128 is the size of 1 bag , \n",
" # 85744 = (size of the entire set) / 128"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Convert to 3D - (Bags, Timesteps, Features)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(filtered_train.columns)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:24:43.963421Z",
"start_time": "2019-06-19T05:24:43.944207Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(23206400, 8)\n",
"(132608, 175, 8)\n"
]
}
],
"source": [
"filtered_train = filtered_train.values\n",
"print(filtered_train.shape)\n",
"filtered_train = filtered_train.reshape(int(len(filtered_train) / 175), 175, 8)\n",
"print(filtered_train.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Filter Overlapping Bags"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:19.299273Z",
"start_time": "2019-06-19T05:25:18.952971Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[22740, 24268, 26924, 31644, 34344, 35832, 40532, 42020, 44764, 49484, 52176, 53648, 58372, 59860, 62752, 67328, 69788, 71236, 75796, 78356, 79856, 84488, 85976, 88516, 93308, 94804, 97384, 102104, 104704, 106192, 110936, 112424, 114984, 119660, 121140, 123820, 128540, 131120]\n"
]
}
],
"source": [
"# filtering bags that overlap with another class\n",
"bags_to_remove = []\n",
"for i in range(len(filtered_target)):\n",
" if len(set(filtered_target[i])) > 1:\n",
" bags_to_remove.append(i)\n",
"print(bags_to_remove)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:26.446153Z",
"start_time": "2019-06-19T05:25:26.256245Z"
}
},
"outputs": [],
"source": [
"filtered_train = np.delete(filtered_train, bags_to_remove, axis=0)\n",
"filtered_target = np.delete(filtered_target, bags_to_remove, axis=0)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:27.260726Z",
"start_time": "2019-06-19T05:25:27.254474Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(132570, 175, 8)"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"filtered_train.shape "
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:28.101475Z",
"start_time": "2019-06-19T05:25:28.096009Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(132570, 175)"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"filtered_target.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Categorical Representation "
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:50.094089Z",
"start_time": "2019-06-19T05:25:49.746284Z"
}
},
"outputs": [],
"source": [
"one_hot_list = []\n",
"for i in range(len(filtered_target)):\n",
" one_hot_list.append(set(filtered_target[i]).pop())"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:52.203633Z",
"start_time": "2019-06-19T05:25:52.198467Z"
}
},
"outputs": [],
"source": [
"categorical_y_ver = one_hot_list\n",
"categorical_y_ver = np.array(categorical_y_ver)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:53.132006Z",
"start_time": "2019-06-19T05:25:53.126314Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(132570,)"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"categorical_y_ver.shape"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:25:54.495163Z",
"start_time": "2019-06-19T05:25:54.489349Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"175"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"filtered_train.shape[1]"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:26:08.021392Z",
"start_time": "2019-06-19T05:26:08.017038Z"
}
},
"outputs": [],
"source": [
"def one_hot(y, numOutput):\n",
" y = np.reshape(y, [-1])\n",
" ret = np.zeros([y.shape[0], numOutput])\n",
" for i, label in enumerate(y):\n",
" ret[i, label] = 1\n",
" return ret"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Extract 3D Normalized Data with Validation Set"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:26:08.931435Z",
"start_time": "2019-06-19T05:26:08.927397Z"
}
},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"import pathlib"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:26:10.295822Z",
"start_time": "2019-06-19T05:26:09.832723Z"
}
},
"outputs": [],
"source": [
"x_train_val_combined, x_test, y_train_val_combined, y_test = train_test_split(filtered_train, categorical_y_ver, test_size=0.20, random_state=42)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:26:11.260084Z",
"start_time": "2019-06-19T05:26:11.253714Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0, 0, ..., 1, 0, 1])"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_test"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:24:41.832337Z",
"start_time": "2019-06-18T17:24:41.141678Z"
}
},
"outputs": [],
"source": [
"extractedDir = '/home/sf/data/WESAD'\n",
"# def generateData(extractedDir):\n",
"# x_train_val_combined, x_test, y_train_val_combined, y_test = readData(extractedDir)\n",
"timesteps = x_train_val_combined.shape[-2] #128/256\n",
"feats = x_train_val_combined.shape[-1] #16\n",
"\n",
"trainSize = int(x_train_val_combined.shape[0]*0.9) #6566\n",
"x_train, x_val = x_train_val_combined[:trainSize], x_train_val_combined[trainSize:] \n",
"y_train, y_val = y_train_val_combined[:trainSize], y_train_val_combined[trainSize:]\n",
"\n",
"# normalization\n",
"x_train = np.reshape(x_train, [-1, feats])\n",
"mean = np.mean(x_train, axis=0)\n",
"std = np.std(x_train, axis=0)\n",
"\n",
"# normalize train\n",
"x_train = x_train - mean\n",
"x_train = x_train / std\n",
"x_train = np.reshape(x_train, [-1, timesteps, feats])\n",
"\n",
"# normalize val\n",
"x_val = np.reshape(x_val, [-1, feats])\n",
"x_val = x_val - mean\n",
"x_val = x_val / std\n",
"x_val = np.reshape(x_val, [-1, timesteps, feats])\n",
"\n",
"# normalize test\n",
"x_test = np.reshape(x_test, [-1, feats])\n",
"x_test = x_test - mean\n",
"x_test = x_test / std\n",
"x_test = np.reshape(x_test, [-1, timesteps, feats])\n",
"\n",
"# shuffle test, as this was remaining\n",
"idx = np.arange(len(x_test))\n",
"np.random.shuffle(idx)\n",
"x_test = x_test[idx]\n",
"y_test = y_test[idx]"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:25:50.674962Z",
"start_time": "2019-06-18T17:25:50.481068Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"/home/sf/data/WESAD/\n"
]
}
],
"source": [
"# one-hot encoding of labels\n",
"numOutput = 3\n",
"y_train = one_hot(y_train, numOutput)\n",
"y_val = one_hot(y_val, numOutput)\n",
"y_test = one_hot(y_test, numOutput)\n",
"extractedDir += '/'\n",
"\n",
"pathlib.Path(extractedDir + 'RAW').mkdir(parents=True, exist_ok = True)\n",
"\n",
"np.save(extractedDir + \"RAW/x_train\", x_train)\n",
"np.save(extractedDir + \"RAW/y_train\", y_train)\n",
"np.save(extractedDir + \"RAW/x_test\", x_test)\n",
"np.save(extractedDir + \"RAW/y_test\", y_test)\n",
"np.save(extractedDir + \"RAW/x_val\", x_val)\n",
"np.save(extractedDir + \"RAW/y_val\", y_val)\n",
"\n",
"print(extractedDir)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:26:35.381650Z",
"start_time": "2019-06-18T17:26:35.136645Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x_test.npy x_train.npy x_val.npy y_test.npy y_train.npy y_val.npy\r\n"
]
}
],
"source": [
"ls \"/home/sf/data/WESAD/RAW\""
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:27:34.458130Z",
"start_time": "2019-06-18T17:27:34.323712Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(95450, 175, 8)"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.load('/home/sf/data/WESAD/RAW/x_train.npy').shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Make 4D EMI Data (Bags, Subinstances, Subinstance Length, Features)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:30:53.720179Z",
"start_time": "2019-06-19T05:30:53.713756Z"
}
},
"outputs": [],
"source": [
"def loadData(dirname):\n",
" x_train = np.load(dirname + '/' + 'x_train.npy')\n",
" y_train = np.load(dirname + '/' + 'y_train.npy')\n",
" x_test = np.load(dirname + '/' + 'x_test.npy')\n",
" y_test = np.load(dirname + '/' + 'y_test.npy')\n",
" x_val = np.load(dirname + '/' + 'x_val.npy')\n",
" y_val = np.load(dirname + '/' + 'y_val.npy')\n",
" return x_train, y_train, x_test, y_test, x_val, y_val"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:29:23.614052Z",
"start_time": "2019-06-18T17:29:23.601324Z"
}
},
"outputs": [],
"source": [
"def bagData(X, Y, subinstanceLen, subinstanceStride):\n",
" numClass = 3\n",
" numSteps = 175\n",
" numFeats = 8\n",
" assert X.ndim == 3\n",
" assert X.shape[1] == numSteps\n",
" assert X.shape[2] == numFeats\n",
" assert subinstanceLen <= numSteps\n",
" assert subinstanceLen > 0\n",
" assert subinstanceStride <= numSteps\n",
" assert subinstanceStride >= 0\n",
" assert len(X) == len(Y)\n",
" assert Y.ndim == 2\n",
" assert Y.shape[1] == numClass\n",
" x_bagged = []\n",
" y_bagged = []\n",
" for i, point in enumerate(X[:, :, :]):\n",
" instanceList = []\n",
" start = 0\n",
" end = subinstanceLen\n",
" while True:\n",
" x = point[start:end, :]\n",
" if len(x) < subinstanceLen:\n",
" x_ = np.zeros([subinstanceLen, x.shape[1]])\n",
" x_[:len(x), :] = x[:, :]\n",
" x = x_\n",
" instanceList.append(x)\n",
" if end >= numSteps:\n",
" break\n",
" start += subinstanceStride\n",
" end += subinstanceStride\n",
" bag = np.array(instanceList)\n",
" numSubinstance = bag.shape[0]\n",
" label = Y[i]\n",
" label = np.argmax(label)\n",
" labelBag = np.zeros([numSubinstance, numClass])\n",
" labelBag[:, label] = 1\n",
" x_bagged.append(bag)\n",
" label = np.array(labelBag)\n",
" y_bagged.append(label)\n",
" return np.array(x_bagged), np.array(y_bagged)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:33:06.531994Z",
"start_time": "2019-06-19T05:33:06.523884Z"
}
},
"outputs": [],
"source": [
"def makeEMIData(subinstanceLen, subinstanceStride, sourceDir, outDir):\n",
" x_train, y_train, x_test, y_test, x_val, y_val = loadData(sourceDir)\n",
" x, y = bagData(x_train, y_train, subinstanceLen, subinstanceStride)\n",
" np.save(outDir + '/x_train.npy', x)\n",
" np.save(outDir + '/y_train.npy', y)\n",
" print('Num train %d' % len(x))\n",
" x, y = bagData(x_test, y_test, subinstanceLen, subinstanceStride)\n",
" np.save(outDir + '/x_test.npy', x)\n",
" np.save(outDir + '/y_test.npy', y)\n",
" print('Num test %d' % len(x))\n",
" x, y = bagData(x_val, y_val, subinstanceLen, subinstanceStride)\n",
" np.save(outDir + '/x_val.npy', x)\n",
" np.save(outDir + '/y_val.npy', y)\n",
" print('Num val %d' % len(x))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:35:20.960014Z",
"start_time": "2019-06-19T05:35:20.050363Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Num train 95450\n",
"Num test 26514\n",
"Num val 10606\n"
]
}
],
"source": [
"subinstanceLen = 88\n",
"subinstanceStride = 30\n",
"extractedDir = '/home/sf/data/WESAD/'\n",
"from os import mkdir\n",
"#mkdir('/home/sf/data/WESAD/88_30')\n",
"rawDir = extractedDir + '/RAW'\n",
"sourceDir = rawDir\n",
"outDir = extractedDir + '/%d_%d/' % (subinstanceLen, subinstanceStride)\n",
"makeEMIData(subinstanceLen, subinstanceStride, sourceDir, outDir)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-18T17:48:58.293843Z",
"start_time": "2019-06-18T17:48:58.285383Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(95450, 4, 3)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.load('//home/sf/data/WESAD/88_30/y_train.npy').shape"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:35:48.609552Z",
"start_time": "2019-06-19T05:35:48.604291Z"
}
},
"outputs": [],
"source": [
"from edgeml.graph.rnn import EMI_DataPipeline\n",
"from edgeml.graph.rnn import EMI_BasicLSTM, EMI_FastGRNN, EMI_FastRNN, EMI_GRU\n",
"from edgeml.trainer.emirnnTrainer import EMI_Trainer, EMI_Driver\n",
"import edgeml.utils"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:43:48.032413Z",
"start_time": "2019-06-19T05:43:47.987839Z"
}
},
"outputs": [],
"source": [
"def lstm_experiment_generator(params, path = './DSAAR/64_16/'):\n",
" \"\"\"\n",
" Function that will generate the experiments to be run.\n",
" Inputs : \n",
" (1) Dictionary params, to set the network parameters.\n",
" (2) Name of the Model to be run from [EMI-LSTM, EMI-FastGRNN, EMI-GRU]\n",
" (3) Path to the dataset, where the csv files are present.\n",
" \"\"\"\n",
" \n",
" #Copy the contents of the params dictionary.\n",
" lstm_dict = {**params}\n",
" \n",
" #---------------------------PARAM SETTING----------------------#\n",
" \n",
" # Network parameters for our LSTM + FC Layer\n",
" NUM_HIDDEN = params[\"NUM_HIDDEN\"]\n",
" NUM_TIMESTEPS = params[\"NUM_TIMESTEPS\"]\n",
" ORIGINAL_NUM_TIMESTEPS = params[\"ORIGINAL_NUM_TIMESTEPS\"]\n",
" NUM_FEATS = params[\"NUM_FEATS\"]\n",
" FORGET_BIAS = params[\"FORGET_BIAS\"]\n",
" NUM_OUTPUT = params[\"NUM_OUTPUT\"]\n",
" USE_DROPOUT = True if (params[\"USE_DROPOUT\"] == 1) else False\n",
" KEEP_PROB = params[\"KEEP_PROB\"]\n",
"\n",
" # For dataset API\n",
" PREFETCH_NUM = params[\"PREFETCH_NUM\"]\n",
" BATCH_SIZE = params[\"BATCH_SIZE\"]\n",
"\n",
" # Number of epochs in *one iteration*\n",
" NUM_EPOCHS = params[\"NUM_EPOCHS\"]\n",
" # Number of iterations in *one round*. After each iteration,\n",
" # the model is dumped to disk. At the end of the current\n",
" # round, the best model among all the dumped models in the\n",
" # current round is picked up..\n",
" NUM_ITER = params[\"NUM_ITER\"]\n",
" # A round consists of multiple training iterations and a belief\n",
" # update step using the best model from all of these iterations\n",
" NUM_ROUNDS = params[\"NUM_ROUNDS\"]\n",
" LEARNING_RATE = params[\"LEARNING_RATE\"]\n",
"\n",
" # A staging direcory to store models\n",
" MODEL_PREFIX = params[\"MODEL_PREFIX\"]\n",
" \n",
" #----------------------END OF PARAM SETTING----------------------#\n",
" \n",
" #----------------------DATA LOADING------------------------------#\n",
" \n",
" x_train, y_train = np.load(path + 'x_train.npy'), np.load(path + 'y_train.npy')\n",
" x_test, y_test = np.load(path + 'x_test.npy'), np.load(path + 'y_test.npy')\n",
" x_val, y_val = np.load(path + 'x_val.npy'), np.load(path + 'y_val.npy')\n",
"\n",
" # BAG_TEST, BAG_TRAIN, BAG_VAL represent bag_level labels. These are used for the label update\n",
" # step of EMI/MI RNN\n",
" BAG_TEST = np.argmax(y_test[:, 0, :], axis=1)\n",
" BAG_TRAIN = np.argmax(y_train[:, 0, :], axis=1)\n",
" BAG_VAL = np.argmax(y_val[:, 0, :], axis=1)\n",
" NUM_SUBINSTANCE = x_train.shape[1]\n",
" print(\"x_train shape is:\", x_train.shape)\n",
" print(\"y_train shape is:\", y_train.shape)\n",
" print(\"x_test shape is:\", x_val.shape)\n",
" print(\"y_test shape is:\", y_val.shape)\n",
" \n",
" #----------------------END OF DATA LOADING------------------------------# \n",
" \n",
" #----------------------COMPUTATION GRAPH--------------------------------#\n",
" \n",
" # Define the linear secondary classifier\n",
" def createExtendedGraph(self, baseOutput, *args, **kwargs):\n",
" W1 = tf.Variable(np.random.normal(size=[NUM_HIDDEN, NUM_OUTPUT]).astype('float32'), name='W1')\n",
" B1 = tf.Variable(np.random.normal(size=[NUM_OUTPUT]).astype('float32'), name='B1')\n",
" y_cap = tf.add(tf.tensordot(baseOutput, W1, axes=1), B1, name='y_cap_tata')\n",
" self.output = y_cap\n",
" self.graphCreated = True\n",
"\n",
" def restoreExtendedGraph(self, graph, *args, **kwargs):\n",
" y_cap = graph.get_tensor_by_name('y_cap_tata:0')\n",
" self.output = y_cap\n",
" self.graphCreated = True\n",
"\n",
" def feedDictFunc(self, keep_prob=None, inference=False, **kwargs):\n",
" if inference is False:\n",
" feedDict = {self._emiGraph.keep_prob: keep_prob}\n",
" else:\n",
" feedDict = {self._emiGraph.keep_prob: 1.0}\n",
" return feedDict\n",
"\n",
" EMI_BasicLSTM._createExtendedGraph = createExtendedGraph\n",
" EMI_BasicLSTM._restoreExtendedGraph = restoreExtendedGraph\n",
"\n",
" if USE_DROPOUT is True:\n",
" EMI_Driver.feedDictFunc = feedDictFunc\n",
" \n",
" inputPipeline = EMI_DataPipeline(NUM_SUBINSTANCE, NUM_TIMESTEPS, NUM_FEATS, NUM_OUTPUT)\n",
" emiLSTM = EMI_BasicLSTM(NUM_SUBINSTANCE, NUM_HIDDEN, NUM_TIMESTEPS, NUM_FEATS,\n",
" forgetBias=FORGET_BIAS, useDropout=USE_DROPOUT)\n",
" emiTrainer = EMI_Trainer(NUM_TIMESTEPS, NUM_OUTPUT, lossType='xentropy',\n",
" stepSize=LEARNING_RATE)\n",
" \n",
" tf.reset_default_graph()\n",
" g1 = tf.Graph() \n",
" with g1.as_default():\n",
" # Obtain the iterators to each batch of the data\n",
" x_batch, y_batch = inputPipeline()\n",
" # Create the forward computation graph based on the iterators\n",
" y_cap = emiLSTM(x_batch)\n",
" # Create loss graphs and training routines\n",
" emiTrainer(y_cap, y_batch)\n",
" \n",
" #------------------------------END OF COMPUTATION GRAPH------------------------------#\n",
" \n",
" #-------------------------------------EMI DRIVER-------------------------------------#\n",
" \n",
" with g1.as_default():\n",
" emiDriver = EMI_Driver(inputPipeline, emiLSTM, emiTrainer)\n",
"\n",
" emiDriver.initializeSession(g1)\n",
" y_updated, modelStats = emiDriver.run(numClasses=NUM_OUTPUT, x_train=x_train,\n",
" y_train=y_train, bag_train=BAG_TRAIN,\n",
" x_val=x_val, y_val=y_val, bag_val=BAG_VAL,\n",
" numIter=NUM_ITER, keep_prob=KEEP_PROB,\n",
" numRounds=NUM_ROUNDS, batchSize=BATCH_SIZE,\n",
" numEpochs=NUM_EPOCHS, modelPrefix=MODEL_PREFIX,\n",
" fracEMI=0.5, updatePolicy='top-k', k=1)\n",
" \n",
" #-------------------------------END OF EMI DRIVER-------------------------------------#\n",
" \n",
" #-----------------------------------EARLY SAVINGS-------------------------------------#\n",
" \n",
" \"\"\"\n",
" Early Prediction Policy: We make an early prediction based on the predicted classes\n",
" probability. If the predicted class probability > minProb at some step, we make\n",
" a prediction at that step.\n",
" \"\"\"\n",
" def earlyPolicy_minProb(instanceOut, minProb, **kwargs):\n",
" assert instanceOut.ndim == 2\n",
" classes = np.argmax(instanceOut, axis=1)\n",
" prob = np.max(instanceOut, axis=1)\n",
" index = np.where(prob >= minProb)[0]\n",
" if len(index) == 0:\n",
" assert (len(instanceOut) - 1) == (len(classes) - 1)\n",
" return classes[-1], len(instanceOut) - 1\n",
" index = index[0]\n",
" return classes[index], index\n",
"\n",
" def getEarlySaving(predictionStep, numTimeSteps, returnTotal=False):\n",
" predictionStep = predictionStep + 1\n",
" predictionStep = np.reshape(predictionStep, -1)\n",
" totalSteps = np.sum(predictionStep)\n",
" maxSteps = len(predictionStep) * numTimeSteps\n",
" savings = 1.0 - (totalSteps / maxSteps)\n",
" if returnTotal:\n",
" return savings, totalSteps\n",
" return savings\n",
" \n",
" #--------------------------------END OF EARLY SAVINGS---------------------------------#\n",
" \n",
" #----------------------------------------BEST MODEL-----------------------------------#\n",
" \n",
" k = 2\n",
" predictions, predictionStep = emiDriver.getInstancePredictions(x_test, y_test, earlyPolicy_minProb,\n",
" minProb=0.99, keep_prob=1.0)\n",
" bagPredictions = emiDriver.getBagPredictions(predictions, minSubsequenceLen=k, numClass=NUM_OUTPUT)\n",
" print('Accuracy at k = %d: %f' % (k, np.mean((bagPredictions == BAG_TEST).astype(int))))\n",
" mi_savings = (1 - NUM_TIMESTEPS / ORIGINAL_NUM_TIMESTEPS)\n",
" emi_savings = getEarlySaving(predictionStep, NUM_TIMESTEPS)\n",
" total_savings = mi_savings + (1 - mi_savings) * emi_savings\n",
" print('Savings due to MI-RNN : %f' % mi_savings)\n",
" print('Savings due to Early prediction: %f' % emi_savings)\n",
" print('Total Savings: %f' % (total_savings))\n",
" \n",
" #Store in the dictionary.\n",
" lstm_dict[\"k\"] = k\n",
" lstm_dict[\"accuracy\"] = np.mean((bagPredictions == BAG_TEST).astype(int))\n",
" lstm_dict[\"total_savings\"] = total_savings\n",
" lstm_dict[\"y_test\"] = BAG_TEST\n",
" lstm_dict[\"y_pred\"] = bagPredictions\n",
" \n",
" # A slightly more detailed analysis method is provided. \n",
" df = emiDriver.analyseModel(predictions, BAG_TEST, NUM_SUBINSTANCE, NUM_OUTPUT)\n",
" print (tabulate(df, headers=list(df.columns), tablefmt='grid'))\n",
" \n",
" lstm_dict[\"detailed analysis\"] = df\n",
" #----------------------------------END OF BEST MODEL-----------------------------------#\n",
" \n",
" #----------------------------------PICKING THE BEST MODEL------------------------------#\n",
" \n",
" devnull = open(os.devnull, 'r')\n",
" for val in modelStats:\n",
" round_, acc, modelPrefix, globalStep = val\n",
" emiDriver.loadSavedGraphToNewSession(modelPrefix, globalStep, redirFile=devnull)\n",
" predictions, predictionStep = emiDriver.getInstancePredictions(x_test, y_test, earlyPolicy_minProb,\n",
" minProb=0.99, keep_prob=1.0)\n",
"\n",
" bagPredictions = emiDriver.getBagPredictions(predictions, minSubsequenceLen=k, numClass=NUM_OUTPUT)\n",
" print(\"Round: %2d, Validation accuracy: %.4f\" % (round_, acc), end='')\n",
" print(', Test Accuracy (k = %d): %f, ' % (k, np.mean((bagPredictions == BAG_TEST).astype(int))), end='')\n",
" print('Additional savings: %f' % getEarlySaving(predictionStep, NUM_TIMESTEPS)) \n",
" \n",
" \n",
" #-------------------------------END OF PICKING THE BEST MODEL--------------------------#\n",
"\n",
" return lstm_dict"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:43:51.798834Z",
"start_time": "2019-06-19T05:43:51.792938Z"
}
},
"outputs": [],
"source": [
"def experiment_generator(params, path, model = 'lstm'):\n",
" \n",
" \n",
" if (model == 'lstm'): return lstm_experiment_generator(params, path)\n",
" elif (model == 'fastgrnn'): return fastgrnn_experiment_generator(params, path)\n",
" elif (model == 'gru'): return gru_experiment_generator(params, path)\n",
" elif (model == 'baseline'): return baseline_experiment_generator(params, path)\n",
" \n",
" return "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'/home/sf/data/EdgeML/tf/examples/EMI-RNN'"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pwd"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"/home/sf/data/WESAD/88_30\n"
]
}
],
"source": [
"cd '/home/sf/data/WESAD/88_30/'"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T05:43:53.168413Z",
"start_time": "2019-06-19T05:43:53.164622Z"
}
},
"outputs": [],
"source": [
"import tensorflow as tf"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-19T08:16:13.770690Z",
"start_time": "2019-06-19T05:45:31.777404Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x_train shape is: (95450, 4, 88, 8)\n",
"y_train shape is: (95450, 4, 3)\n",
"x_test shape is: (10606, 4, 88, 8)\n",
"y_test shape is: (10606, 4, 3)\n",
"Update policy: top-k\n",
"Training with MI-RNN loss for 3 rounds\n",
"Round: 0\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00117 Acc 0.97000 | Val acc 0.97426 | Model saved to WESAD/model-lstm, global_step 1000\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00043 Acc 0.98857 | Val acc 0.98718 | Model saved to WESAD/model-lstm, global_step 1001\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00084 Acc 0.98000 | Val acc 0.99133 | Model saved to WESAD/model-lstm, global_step 1002\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00020 Acc 0.99429 | Val acc 0.98982 | Model saved to WESAD/model-lstm, global_step 1003\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1002\n",
"Round: 1\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00012 Acc 0.99714 | Val acc 0.99519 | Model saved to WESAD/model-lstm, global_step 1004\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00011 Acc 0.99571 | Val acc 0.99208 | Model saved to WESAD/model-lstm, global_step 1005\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00004 Acc 1.00000 | Val acc 0.98256 | Model saved to WESAD/model-lstm, global_step 1006\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00009 Acc 0.99857 | Val acc 0.97831 | Model saved to WESAD/model-lstm, global_step 1007\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1004\n",
"Round: 2\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00024 Acc 0.99143 | Val acc 0.99151 | Model saved to WESAD/model-lstm, global_step 1008\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00050 Acc 0.98857 | Val acc 0.98114 | Model saved to WESAD/model-lstm, global_step 1009\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00006 Acc 0.99857 | Val acc 0.98246 | Model saved to WESAD/model-lstm, global_step 1010\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00009 Acc 0.99714 | Val acc 0.97190 | Model saved to WESAD/model-lstm, global_step 1011\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1008\n",
"Round: 3\n",
"Switching to EMI-Loss function\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.07939 Acc 0.98714 | Val acc 0.96163 | Model saved to WESAD/model-lstm, global_step 1012\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.04099 Acc 0.99857 | Val acc 0.95710 | Model saved to WESAD/model-lstm, global_step 1013\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03362 Acc 1.00000 | Val acc 0.92646 | Model saved to WESAD/model-lstm, global_step 1014\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02628 Acc 1.00000 | Val acc 0.88356 | Model saved to WESAD/model-lstm, global_step 1015\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1012\n",
"Round: 4\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.04331 Acc 1.00000 | Val acc 0.96181 | Model saved to WESAD/model-lstm, global_step 1016\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03750 Acc 0.99857 | Val acc 0.93900 | Model saved to WESAD/model-lstm, global_step 1017\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02759 Acc 1.00000 | Val acc 0.89638 | Model saved to WESAD/model-lstm, global_step 1018\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02711 Acc 1.00000 | Val acc 0.90175 | Model saved to WESAD/model-lstm, global_step 1019\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1016\n",
"Round: 5\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03581 Acc 0.99857 | Val acc 0.93221 | Model saved to WESAD/model-lstm, global_step 1020\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02856 Acc 1.00000 | Val acc 0.89676 | Model saved to WESAD/model-lstm, global_step 1021\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02736 Acc 1.00000 | Val acc 0.88837 | Model saved to WESAD/model-lstm, global_step 1022\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02337 Acc 1.00000 | Val acc 0.85782 | Model saved to WESAD/model-lstm, global_step 1023\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1020\n",
"Accuracy at k = 2: 0.930867\n",
"Savings due to MI-RNN : 0.497143\n",
"Savings due to Early prediction: 0.875449\n",
"Total Savings: 0.937368\n",
" len acc macro-fsc macro-pre macro-rec micro-fsc micro-pre \\\n",
"0 1 0.922682 0.923355 0.917417 0.937050 0.922682 0.922682 \n",
"1 2 0.930867 0.930731 0.925969 0.941163 0.930867 0.930867 \n",
"2 3 0.932224 0.931445 0.929177 0.938015 0.932224 0.932224 \n",
"3 4 0.931357 0.929717 0.930093 0.933056 0.931357 0.931357 \n",
"\n",
" micro-rec \n",
"0 0.922682 \n",
"1 0.930867 \n",
"2 0.932224 \n",
"3 0.931357 \n",
"Max accuracy 0.932224 at subsequencelength 3\n",
"Max micro-f 0.932224 at subsequencelength 3\n",
"Micro-precision 0.932224 at subsequencelength 3\n",
"Micro-recall 0.932224 at subsequencelength 3\n",
"Max macro-f 0.931445 at subsequencelength 3\n",
"macro-precision 0.929177 at subsequencelength 3\n",
"macro-recall 0.938015 at subsequencelength 3\n",
"+----+-------+----------+-------------+-------------+-------------+-------------+-------------+-------------+\n",
"| | len | acc | macro-fsc | macro-pre | macro-rec | micro-fsc | micro-pre | micro-rec |\n",
"+====+=======+==========+=============+=============+=============+=============+=============+=============+\n",
"| 0 | 1 | 0.922682 | 0.923355 | 0.917417 | 0.93705 | 0.922682 | 0.922682 | 0.922682 |\n",
"+----+-------+----------+-------------+-------------+-------------+-------------+-------------+-------------+\n",
"| 1 | 2 | 0.930867 | 0.930731 | 0.925969 | 0.941163 | 0.930867 | 0.930867 | 0.930867 |\n",
"+----+-------+----------+-------------+-------------+-------------+-------------+-------------+-------------+\n",
"| 2 | 3 | 0.932224 | 0.931445 | 0.929177 | 0.938015 | 0.932224 | 0.932224 | 0.932224 |\n",
"+----+-------+----------+-------------+-------------+-------------+-------------+-------------+-------------+\n",
"| 3 | 4 | 0.931357 | 0.929717 | 0.930093 | 0.933056 | 0.931357 | 0.931357 | 0.931357 |\n",
"+----+-------+----------+-------------+-------------+-------------+-------------+-------------+-------------+\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1002\n",
"Round: 0, Validation accuracy: 0.9913, Test Accuracy (k = 2): 0.990118, Additional savings: 0.685851\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1004\n",
"Round: 1, Validation accuracy: 0.9952, Test Accuracy (k = 2): 0.993023, Additional savings: 0.716898\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1008\n",
"Round: 2, Validation accuracy: 0.9915, Test Accuracy (k = 2): 0.989477, Additional savings: 0.720437\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1012\n",
"Round: 3, Validation accuracy: 0.9616, Test Accuracy (k = 2): 0.958588, Additional savings: 0.863625\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1016\n",
"Round: 4, Validation accuracy: 0.9618, Test Accuracy (k = 2): 0.957155, Additional savings: 0.872818\n",
"INFO:tensorflow:Restoring parameters from WESAD/model-lstm-1020\n",
"Round: 5, Validation accuracy: 0.9322, Test Accuracy (k = 2): 0.930867, Additional savings: 0.875449\n"
]
},
{
"ename": "NameError",
"evalue": "name 'pathlib' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-14-64a6965ef0bf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m#Create the directory to store the results of this run.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0mdirname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"/home/sf/data/WESAD/lstm/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m \u001b[0mpathlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 35\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Results for this run have been saved at\"\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0mdirname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\".\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'pathlib' is not defined"
]
}
],
"source": [
"## Baseline EMI-LSTM\n",
"\n",
"dataset = 'WESAD'\n",
"path = '/home/sf/data/WESAD/88_30/'\n",
"\n",
"#Choose model from among [lstm, fastgrnn, gru]\n",
"model = 'lstm'\n",
"\n",
"# Dictionary to set the parameters.\n",
"params = {\n",
" \"NUM_HIDDEN\" : 128,\n",
" \"NUM_TIMESTEPS\" : 88, #subinstance length.\n",
" \"ORIGINAL_NUM_TIMESTEPS\" : 175,\n",
" \"NUM_FEATS\" : 8,\n",
" \"FORGET_BIAS\" : 1.0,\n",
" \"NUM_OUTPUT\" : 3,\n",
" \"USE_DROPOUT\" : 1, # '1' -> True. '0' -> False\n",
" \"KEEP_PROB\" : 0.75,\n",
" \"PREFETCH_NUM\" : 5,\n",
" \"BATCH_SIZE\" : 175,\n",
" \"NUM_EPOCHS\" : 2,\n",
" \"NUM_ITER\" : 4,\n",
" \"NUM_ROUNDS\" : 6,\n",
" \"LEARNING_RATE\" : 0.001,\n",
" \"FRAC_EMI\" : 0.5,\n",
" \"MODEL_PREFIX\" : dataset + '/model-' + str(model)\n",
"}\n",
"\n",
"#Preprocess data, and load the train,test and validation splits.\n",
"lstm_dict = lstm_experiment_generator(params, path)\n",
"\n",
"#Create the directory to store the results of this run.\n",
"dirname = \"/home/sf/data/WESAD/lstm/\"\n",
"pathlib.Path(dirname).mkdir(parents=True, exist_ok=True)\n",
"print (\"Results for this run have been saved at\" , dirname, \".\")\n",
"\n",
"now = datetime.datetime.now()\n",
"filename = list((str(now.year),\"-\",str(now.month),\"-\",str(now.day),\"|\",str(now.hour),\"-\",str(now.minute)))\n",
"filename = ''.join(filename)\n",
"\n",
"#Save the dictionary containing the params and the results.\n",
"pkl.dump(lstm_dict,open(dirname + \"/lstm_dict_\" + filename + \".pkl\",mode='wb'))"
]
}
],
"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.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}