Datasets
Models
Downloads: 1
586 lines (585 with data), 22.2 kB
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# WESAD GRU"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"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\n",
"import pathlib"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:17:51.796585Z",
"start_time": "2018-12-14T14:17:49.648375Z"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Using TensorFlow backend.\n"
]
}
],
"source": [
"from __future__ import print_function\n",
"import os\n",
"import sys\n",
"import tensorflow as tf\n",
"import numpy as np\n",
"# Making sure edgeml is part of python path\n",
"sys.path.insert(0, '../../')\n",
"#For processing on CPU.\n",
"os.environ['CUDA_VISIBLE_DEVICES'] ='0'\n",
"\n",
"np.random.seed(42)\n",
"tf.set_random_seed(42)\n",
"\n",
"# MI-RNN and EMI-RNN imports\n",
"from edgeml.graph.rnn import EMI_DataPipeline\n",
"from edgeml.graph.rnn import EMI_GRU\n",
"from edgeml.trainer.emirnnTrainer import EMI_Trainer, EMI_Driver\n",
"import edgeml.utils\n",
"\n",
"import keras.backend as K\n",
"cfg = K.tf.ConfigProto()\n",
"cfg.gpu_options.allow_growth = True\n",
"K.set_session(K.tf.Session(config=cfg))"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:17:51.803381Z",
"start_time": "2018-12-14T14:17:51.798799Z"
}
},
"outputs": [],
"source": [
"# Network parameters for our LSTM + FC Layer\n",
"NUM_HIDDEN = 128\n",
"NUM_TIMESTEPS = 88\n",
"ORIGINAL_NUM_TIMESTEPS = 175\n",
"NUM_FEATS = 8\n",
"FORGET_BIAS = 1.0\n",
"NUM_OUTPUT = 3\n",
"USE_DROPOUT = True\n",
"KEEP_PROB = 0.75\n",
"\n",
"# For dataset API\n",
"PREFETCH_NUM = 5\n",
"BATCH_SIZE = 175\n",
"\n",
"# Number of epochs in *one iteration*\n",
"NUM_EPOCHS = 2\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 = 4\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 = 6\n",
"LEARNING_RATE=0.001\n",
"\n",
"# A staging direcory to store models\n",
"MODEL_PREFIX = '/home/sf/data/WESAD/GRU/88_30/models/model-gru'"
]
},
{
"cell_type": "markdown",
"metadata": {
"heading_collapsed": true
},
"source": [
"# Loading Data"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:17:52.040352Z",
"start_time": "2018-12-14T14:17:51.805319Z"
},
"hidden": 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"
]
}
],
"source": [
"# Loading the data\n",
"x_train, y_train = np.load('/home/sf/data/WESAD/88_30/x_train.npy'), np.load('/home/sf/data/WESAD/88_30/y_train.npy')\n",
"x_test, y_test = np.load('/home/sf/data/WESAD/88_30/x_test.npy'), np.load('/home/sf/data/WESAD/88_30/y_test.npy')\n",
"x_val, y_val = np.load('/home/sf/data/WESAD/88_30/x_val.npy'), np.load('/home/sf/data/WESAD/88_30/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)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Computation Graph"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:17:52.053161Z",
"start_time": "2018-12-14T14:17:52.042928Z"
}
},
"outputs": [],
"source": [
"# 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_GRU._createExtendedGraph = createExtendedGraph\n",
"EMI_GRU._restoreExtendedGraph = restoreExtendedGraph\n",
"\n",
"if USE_DROPOUT is True:\n",
" EMI_Driver.feedDictFunc = feedDictFunc"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:17:52.335299Z",
"start_time": "2018-12-14T14:17:52.055483Z"
}
},
"outputs": [],
"source": [
"inputPipeline = EMI_DataPipeline(NUM_SUBINSTANCE, NUM_TIMESTEPS, NUM_FEATS, NUM_OUTPUT)\n",
"emiGRU = EMI_GRU(NUM_SUBINSTANCE, NUM_HIDDEN, NUM_TIMESTEPS, NUM_FEATS,\n",
" useDropout=USE_DROPOUT)\n",
"emiTrainer = EMI_Trainer(NUM_TIMESTEPS, NUM_OUTPUT, lossType='xentropy',\n",
" stepSize=LEARNING_RATE)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:18:05.031382Z",
"start_time": "2018-12-14T14:17:52.338750Z"
}
},
"outputs": [],
"source": [
"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 = emiGRU(x_batch)\n",
" # Create loss graphs and training routines\n",
" emiTrainer(y_cap, y_batch)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# EMI Driver"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:35:15.209910Z",
"start_time": "2018-12-14T14:18:05.034359Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Update policy: top-k\n",
"Training with MI-RNN loss for 3 rounds\n",
"Round: 0\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00133 Acc 0.96000 | Val acc 0.97869 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1000\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00082 Acc 0.97143 | Val acc 0.98190 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1001\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00024 Acc 0.99429 | Val acc 0.97134 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1002\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00020 Acc 0.99143 | Val acc 0.97596 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1003\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1001\n",
"Round: 1\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00008 Acc 1.00000 | Val acc 0.98435 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1004\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00033 Acc 0.99143 | Val acc 0.96361 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1005\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00009 Acc 0.99571 | Val acc 0.96134 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1006\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00026 Acc 0.99286 | Val acc 0.95418 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1007\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1004\n",
"Round: 2\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00008 Acc 0.99714 | Val acc 0.97237 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1008\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00007 Acc 0.99714 | Val acc 0.95616 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1009\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00004 Acc 0.99857 | Val acc 0.95418 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1010\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.00007 Acc 0.99857 | Val acc 0.95587 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1011\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1008\n",
"Round: 3\n",
"Switching to EMI-Loss function\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.07520 Acc 0.99286 | Val acc 0.93485 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1012\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03711 Acc 1.00000 | Val acc 0.89421 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1013\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03318 Acc 1.00000 | Val acc 0.85998 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1014\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03119 Acc 1.00000 | Val acc 0.81897 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1015\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1012\n",
"Round: 4\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.04101 Acc 1.00000 | Val acc 0.90958 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1016\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03496 Acc 1.00000 | Val acc 0.84546 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1017\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03953 Acc 0.99571 | Val acc 0.82500 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1018\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03629 Acc 0.99857 | Val acc 0.79370 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1019\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1016\n",
"Round: 5\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03494 Acc 1.00000 | Val acc 0.82302 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1020\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.03172 Acc 0.99857 | Val acc 0.85122 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1021\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02683 Acc 1.00000 | Val acc 0.80200 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1022\n",
"Epoch 1 Batch 534 ( 1080) Loss 0.02836 Acc 1.00000 | Val acc 0.78682 | Model saved to /home/sf/data/WESAD/GRU/88_30/models/model-gru, global_step 1023\n",
"INFO:tensorflow:Restoring parameters from /home/sf/data/WESAD/GRU/88_30/models/model-gru-1021\n"
]
}
],
"source": [
"with g1.as_default():\n",
" emiDriver = EMI_Driver(inputPipeline, emiGRU, 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)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Evaluating the trained model"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:35:15.218040Z",
"start_time": "2018-12-14T14:35:15.211771Z"
}
},
"outputs": [],
"source": [
"# 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",
"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"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:35:16.257489Z",
"start_time": "2018-12-14T14:35:15.221029Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy at k = 2: 0.852908\n",
"Savings due to MI-RNN : 0.497143\n",
"Savings due to Early prediction: 0.826181\n",
"Total Savings: 0.912594\n"
]
}
],
"source": [
"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))"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:35:17.044115Z",
"start_time": "2018-12-14T14:35:16.259280Z"
},
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" len acc macro-fsc macro-pre macro-rec micro-fsc micro-pre \\\n",
"0 1 0.844648 0.835791 0.838901 0.850929 0.844648 0.844648 \n",
"1 2 0.852908 0.842272 0.845445 0.853562 0.852908 0.852908 \n",
"2 3 0.855397 0.843846 0.848683 0.851069 0.855397 0.855397 \n",
"3 4 0.852757 0.837862 0.847351 0.840189 0.852757 0.852757 \n",
"\n",
" micro-rec \n",
"0 0.844648 \n",
"1 0.852908 \n",
"2 0.855397 \n",
"3 0.852757 \n",
"Max accuracy 0.855397 at subsequencelength 3\n",
"Max micro-f 0.855397 at subsequencelength 3\n",
"Micro-precision 0.855397 at subsequencelength 3\n",
"Micro-recall 0.855397 at subsequencelength 3\n",
"Max macro-f 0.843846 at subsequencelength 3\n",
"macro-precision 0.848683 at subsequencelength 3\n",
"macro-recall 0.851069 at subsequencelength 3\n"
]
}
],
"source": [
"# A slightly more detailed analysis method is provided. \n",
"df = emiDriver.analyseModel(predictions, BAG_TEST, NUM_SUBINSTANCE, NUM_OUTPUT)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Picking the best model"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2018-12-14T14:35:54.899340Z",
"start_time": "2018-12-14T14:35:17.047464Z"
}
},
"outputs": [],
"source": [
"devnulldevnull = 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",
" 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(\"Total Savings: %f\" % total_savings)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"params = {\n",
" \"NUM_HIDDEN\" : 128,\n",
" \"NUM_TIMESTEPS\" : 64, #subinstance length.\n",
" \"ORIGINAL_NUM_TIMESTEPS\" : 128,\n",
" \"NUM_FEATS\" : 16,\n",
" \"FORGET_BIAS\" : 1.0,\n",
" \"NUM_OUTPUT\" : 5,\n",
" \"USE_DROPOUT\" : 1, # '1' -> True. '0' -> False\n",
" \"KEEP_PROB\" : 0.75,\n",
" \"PREFETCH_NUM\" : 5,\n",
" \"BATCH_SIZE\" : 32,\n",
" \"NUM_EPOCHS\" : 2,\n",
" \"NUM_ITER\" : 4,\n",
" \"NUM_ROUNDS\" : 10,\n",
" \"LEARNING_RATE\" : 0.001,\n",
" \"MODEL_PREFIX\" : '/home/sf/data/DREAMER/Dominance/model-gru'\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"gru_dict = {**params}\n",
"gru_dict[\"k\"] = k\n",
"gru_dict[\"accuracy\"] = np.mean((bagPredictions == BAG_TEST).astype(int))\n",
"gru_dict[\"total_savings\"] = total_savings\n",
"gru_dict[\"y_test\"] = BAG_TEST\n",
"gru_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'))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"dirname = \"/home/sf/data/WESAD/GRU/\"\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(gru_dict,open(dirname + filename + \".pkl\",mode='wb'))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"dirname+filename+'.pkl'"
]
}
],
"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"
},
"latex_envs": {
"LaTeX_envs_menu_present": true,
"autoclose": false,
"autocomplete": true,
"bibliofile": "biblio.bib",
"cite_by": "apalike",
"current_citInitial": 1,
"eqLabelWithNumbers": true,
"eqNumInitial": 1,
"hotkeys": {
"equation": "Ctrl-E",
"itemize": "Ctrl-I"
},
"labels_anchors": false,
"latex_user_defs": false,
"report_style_numbering": false,
"user_envs_cfg": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}