sent_featuresets_twitter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentiment Analysis - Twitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python2.7/dist-packages/ggplot/utils.py:81: FutureWarning: pandas.tslib is deprecated and will be removed in a future version.\n",
      "You can access Timestamp as pandas.Timestamp\n",
      "  pd.tslib.Timestamp,\n",
      "/usr/local/lib/python2.7/dist-packages/ggplot/stats/smoothers.py:4: FutureWarning: The pandas.lib module is deprecated and will be removed in a future version. These are private functions and can be accessed from pandas._libs.lib instead\n",
      "  from pandas.lib import Timestamp\n",
      "/usr/local/lib/python2.7/dist-packages/statsmodels/compat/pandas.py:56: FutureWarning: The pandas.core.datetools module is deprecated and will be removed in a future version. Please use the pandas.tseries module instead.\n",
      "  from pandas.core import datetools\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "%matplotlib inline\n",
    "\n",
    "from IPython.display import Image, display\n",
    "from io import BytesIO\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#import nltk\n",
    "#from nltk.tokenize import word_tokenize\n",
    "#from nltk.stem import WordNetLemmatizer\n",
    "\n",
    "#import numpy as numpy\n",
    "import random\n",
    "#import pickle\n",
    "from collections import Counter\n",
    "import codecs\n",
    "import tensorflow as tf\n",
    "import np\n",
    "import time\n",
    "\n",
    "import os\n",
    "from os.path import join, exists\n",
    "\n",
    "import pandas as pd\n",
    "import pydot_ng as pydot\n",
    "import graphviz\n",
    "from ggplot import *\n",
    "\n",
    "from keras.utils.data_utils import get_file\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing import sequence\n",
    "from keras.models import Sequential, load_model\n",
    "from keras.layers import Dense, Embedding, Dropout, Flatten, LSTM\n",
    "from keras.optimizers import RMSprop, Adam, SGD, Adagrad\n",
    "\n",
    "#nltk.download('punkt')\n",
    "#nltk.download('wordnet')\n",
    "#totalLinesToRead = 100\n",
    "#lemmatizer = WordNetLemmatizer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data load\n",
    "\n",
    "The first step when building machine learning model is getting your data into the proper form to feed into the model. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data/twitter-train-pos', 'r') as f:\n",
    "    positive_train_txt = f.read()\n",
    "with open('./data/twitter-train-neg', 'r') as f:\n",
    "    negative_train_txt = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The positive data size: 22403729\n",
      "The negative data size: 22157551\n"
     ]
    }
   ],
   "source": [
    "print(\"The positive data size: {}\".format(len(positive_train_txt)))\n",
    "print(\"The negative data size: {}\".format(len(negative_train_txt)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic prediction\n",
    "Let's assume we will say to all data positive.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic/Benchmark Accuracy: 0.502762241121\n"
     ]
    }
   ],
   "source": [
    "print(\"Basic/Benchmark Accuracy: \" + str(float(len(positive_train_txt)) / (len(positive_train_txt) + len(negative_train_txt))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download GloVe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extract ./datasets/glove.6B.300d.txt\n",
      "Embeddings size: 400000\n"
     ]
    }
   ],
   "source": [
    "data_folder = './datasets'\n",
    "glove = 'glove.6B'\n",
    "glove_filename = glove + '.zip'\n",
    "glove_url = 'http://nlp.stanford.edu/data/' + glove_filename\n",
    "embedding_dim = 300\n",
    "glove_loc = join(data_folder, glove_filename)\n",
    "\n",
    "if not exists(glove_loc):\n",
    "    print('Download %s' % glove_filename)\n",
    "    get_file(glove_filename, glove_url, cache_dir='.', extract=True)\n",
    "\n",
    "glove_filename = os.path.join(data_folder, glove + '.' + str(embedding_dim) + 'd.txt')\n",
    "\n",
    "embeddings = {}\n",
    "\n",
    "print('Extract %s' % glove_filename)\n",
    "with open(glove_filename, 'r') as f:\n",
    "    for line in f:\n",
    "        values = line.split(' ')\n",
    "        word = values[0]\n",
    "        embedding = np.asarray(values[1:], dtype='float32')\n",
    "        embeddings[word] = embedding\n",
    "        \n",
    "print('Embeddings size: %d' % len(embeddings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data preprocessing\n",
    "\n",
    "First, let's remove all punctuation. Then get all the text without the newlines and split it into individual words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: \t\t(20000,)\n",
      "Label shape: \t\t(20000, 2)\n"
     ]
    }
   ],
   "source": [
    "from string import punctuation\n",
    "\n",
    "def get_reviews(text):\n",
    "    #all_text = ''.join([c for c in text if c not in punctuation])\n",
    "    reviews = text.split('\\n')\n",
    "    return reviews[:10000] # TAKE first 1000 to make it fast\n",
    "\n",
    "positive_train = get_reviews(positive_train_txt)\n",
    "negative_train = get_reviews(negative_train_txt)\n",
    "\n",
    "positive_label = np.full((len(positive_train), 2), [1, 0])\n",
    "negative_label = np.full((len(negative_train), 2), [0, 1])\n",
    "\n",
    "train = np.concatenate((positive_train, negative_train), axis=0)\n",
    "labels = np.concatenate((positive_label, negative_label), axis=0)\n",
    "\n",
    "# shuffle\n",
    "c = np.c_[train.reshape(len(train), -1), labels.reshape(len(labels), -1)]\n",
    "np.random.shuffle(c)\n",
    "\n",
    "train = c[:, :train.size//len(train)].reshape(train.shape)\n",
    "labels = c[:, train.size//len(train):].reshape(labels.shape)\n",
    "\n",
    "del c\n",
    "del positive_label\n",
    "del negative_label\n",
    "\n",
    "print(\"Train shape: \\t\\t{}\".format(train.shape))\n",
    "print(\"Label shape: \\t\\t{}\".format(labels.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoding the words\n",
    "Create dictinaries that map the words in the vocaulary to integers. Then we can convert each of our reviews into integers sos they can be passed into the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 31166 unique tokens.\n"
     ]
    }
   ],
   "source": [
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(train)\n",
    "train_ints = tokenizer.texts_to_sequences(train)\n",
    "word_index = tokenizer.word_index\n",
    "\n",
    "print('Found %s unique tokens.' % len(word_index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word_index['dog']\n",
    "#embeddings['dog']\n",
    "\n",
    "#embedding_vector[876]\n",
    "#[-1.1043e-01,  8\n",
    " \n",
    "#print(tokenizer.texts_to_sequences(\"once upon a time once\"))\n",
    "#train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Word Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "NUM_WORDS = len(embeddings)\n",
    "words_len = min(NUM_WORDS, len(word_index))\n",
    "word_embedding_matrix = np.random.random((words_len + 1, embedding_dim))\n",
    "k = 0\n",
    "for word, i in word_index.items():\n",
    "    if i >= NUM_WORDS:\n",
    "        continue\n",
    "    embedding_vector = embeddings.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        word_embedding_matrix[i] = embedding_vector\n",
    "        k += 1\n",
    "        \n",
    "del embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null word embeddings: -1\n",
      "Found 16114\n",
      "Total: 31167\n"
     ]
    }
   ],
   "source": [
    "print('Null word embeddings: %d' % (np.sum(np.sum(word_embedding_matrix, axis=1) == 0) - 1))\n",
    "print('Found %d' % k)\n",
    "print('Total: %d' % len(word_embedding_matrix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentence length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f05746909d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "max_word_count_text = 0\n",
    "text_count = defaultdict(int)\n",
    "for sentence in train_ints:\n",
    "    max_word_count_text = max(max_word_count_text, len(sentence))\n",
    "    text_count[len(sentence)] += 1\n",
    "    \n",
    "mpl_fig = plt.figure()\n",
    "ax = mpl_fig.add_subplot(111)\n",
    "\n",
    "ax.bar(range(len(text_count)), text_count.values())\n",
    "\n",
    "plt.title(\"Sentence Length Distribution\")\n",
    "plt.xlabel(\"Length\")\n",
    "plt.ylabel(\"Frequency\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max word sentence: 34\n"
     ]
    }
   ],
   "source": [
    "print('Max word sentence: %d' % max_word_count_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some issues here. We seem to have one tweet with zero length. And, the maximum tweet length is way too many steps for our RNN. Let's truncate to 15 steps. For tweets shorter than 15, we'll pad with 0s. For tweets longer than 15, we can truncate them to the first 15 characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train_ints = [train_ints[ii] for ii in non_zero_idx]\n",
    "#labels = np.array([labels[ii] for ii in non_zero_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, create an array features that contains the data we'll pass to the network. The data should come from review_ints, since we want to feed integers to the network. Each row should be 15 elements long. For reviews shorter than 15 words, left pad with 0s. For tweet longer than 15, use on the first 15 words as the feature vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_len = 15\n",
    "features = sequence.pad_sequences(train_ints, maxlen = seq_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One sample\n",
      "Text: \n",
      "Im enjoying my day off...drinking Earle Gray tea and watching American Psycho!\n",
      "Word sequence: \n",
      "[53, 617, 6, 30, 81, 861, 9247, 9248, 761, 5, 150, 1286, 3915]\n",
      "Pad: \n",
      "[   0    0   53  617    6   30   81  861 9247 9248  761    5  150 1286 3915]\n",
      "Label: \n",
      "['1' '0']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print('One sample')\n",
    "\n",
    "print('Text: ')\n",
    "print( train[1] )\n",
    "\n",
    "print('Word sequence: ')\n",
    "print( train_ints[1] )\n",
    "\n",
    "print('Pad: ')\n",
    "print( features[1] )\n",
    "\n",
    "print('Label: ')\n",
    "print( labels[1] )\n",
    "\n",
    "del train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training, Validation, Test\n",
    "\n",
    "With our data in nice shape, we'll split it into training, validation, and test sets. Do not foget to shuffle it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\t\tFeature Shapes:\n",
      "Train set: \t\t(16000, 15)\n",
      "Validation set: \t(2000, 15)\n",
      "Test set: \t\t(2000, 15)\n",
      "Train lable: \t\t(16000, 2)\n"
     ]
    }
   ],
   "source": [
    "split_idx = int(len(features)*0.8)\n",
    "train_x, val_x = features[:split_idx], features[split_idx:]\n",
    "train_y, val_y = labels[:split_idx], labels[split_idx:]\n",
    "\n",
    "test_idx = int(len(val_x)*0.5)\n",
    "val_x, test_x = val_x[:test_idx], val_x[test_idx:]\n",
    "val_y, test_y = val_y[:test_idx], val_y[test_idx:]\n",
    "\n",
    "print(\"\\t\\t\\tFeature Shapes:\")\n",
    "print(\"Train set: \\t\\t{}\".format(train_x.shape)) \n",
    "print(\"Validation set: \\t{}\".format(val_x.shape))\n",
    "print(\"Test set: \\t\\t{}\".format(test_x.shape))\n",
    "\n",
    "print(\"Train lable: \\t\\t{}\".format(train_y.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate Lemmas "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Sentiment Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createModel(hidden_size, drop_size, output_activation):\n",
    "    model = Sequential()\n",
    "\n",
    "    model.add(Dense(hidden_size, activation='relu', input_dim = seq_len))\n",
    "    \n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "\n",
    "    model.add(Dense(hidden_size, activation='relu'))\n",
    "\n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "\n",
    "    model.add(Dense(hidden_size, activation='relu'))\n",
    "\n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "\n",
    "    model.add(Dense(2, activation=output_activation))\n",
    "\n",
    "    optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)\n",
    "\n",
    "    model.compile(loss = 'binary_crossentropy',\n",
    "                  optimizer = optimizer,\n",
    "                  metrics = ['accuracy'])\n",
    "    return model\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createEmbeddedModel(hidden_size, drop_size):\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(Embedding(words_len + 1,\n",
    "                     embedding_dim,\n",
    "                     weights = [word_embedding_matrix],\n",
    "                     input_length = seq_len,\n",
    "                     trainable = False,\n",
    "                     name = 'embedding'))\n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "        \n",
    "    model.add(LSTM(seq_len, dropout=0.2, recurrent_dropout=0.2))\n",
    "    \n",
    "    model.add(Dense(hidden_size, activation='relu', input_dim = seq_len, name=\"hidden_1\"))\n",
    "    \n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "\n",
    "    model.add(Dense(hidden_size, activation='relu', name=\"hidden_2\"))\n",
    "\n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "\n",
    "    model.add(Dense(hidden_size, activation='relu', name=\"hidden_3\"))\n",
    "\n",
    "    if drop_size > 0.0:\n",
    "        model.add(Dropout(drop_size))\n",
    "        \n",
    "    #model.add(Flatten())  # [[ [1, 2], [2, 2] ], ....]  -> [[ 1, 2, 2, 2], ....]\n",
    "\n",
    "    model.add(Dense(2, activation='sigmoid', name=\"output\"))\n",
    "\n",
    "    optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)\n",
    "\n",
    "    model.compile(loss = 'binary_crossentropy',\n",
    "                  optimizer = optimizer,\n",
    "                  metrics = ['accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Start learning model_15_embedded_drop_0.1_twitter_small_5epochs at 1522885582\n",
      "Epochs: 5\n",
      "Batch size: 20\n",
      "Train on 16000 samples, validate on 2000 samples\n",
      "Epoch 1/5\n",
      "16000/16000 [==============================] - 26s 2ms/step - loss: 0.6177 - acc: 0.6472 - val_loss: 0.5869 - val_acc: 0.6802\n",
      "Epoch 2/5\n",
      "16000/16000 [==============================] - 19s 1ms/step - loss: 0.5488 - acc: 0.7204 - val_loss: 0.5504 - val_acc: 0.7115\n",
      "Epoch 3/5\n",
      "16000/16000 [==============================] - 17s 1ms/step - loss: 0.5238 - acc: 0.7390 - val_loss: 0.5412 - val_acc: 0.7295\n",
      "Epoch 4/5\n",
      "16000/16000 [==============================] - 16s 990us/step - loss: 0.5049 - acc: 0.7502 - val_loss: 0.5486 - val_acc: 0.7280\n",
      "Epoch 5/5\n",
      "16000/16000 [==============================] - 15s 951us/step - loss: 0.4870 - acc: 0.7638 - val_loss: 0.5336 - val_acc: 0.7288\n",
      "Time: 95\n"
     ]
    }
   ],
   "source": [
    "batch_size = 20\n",
    "epochs = 5\n",
    "\n",
    "# 16000 -> 100, 100, 100\n",
    "\n",
    "models = {}\n",
    "\n",
    "#models['model_200_drop_0.1_softmax'] = createModel(200, 0.1, 'softmax')\n",
    "#models['model_200_drop_0.1_sigmoid'] = createModel(200, 0.1, 'sigmoid')\n",
    "\n",
    "#models['model_400_drop_0.1'] = createModel(400, 0.1)\n",
    "#models['model_600_drop_0.1'] = createModel(600, 0.1)\n",
    "#models['model_200_no_drop'] = createModel(200, 0)\n",
    "#models['model_400_no_drop'] = createModel(400, 0)\n",
    "#models['model_600_no_drop'] = createModel(600, 0)\n",
    "\n",
    "models['model_15_embedded_drop_0.1_twitter_small_5epochs'] = createEmbeddedModel(15, 0)\n",
    "\n",
    "results = []\n",
    "for name, model in models.items():  \n",
    "    start_time = time.time()\n",
    "    print('')\n",
    "    print('Start learning %s at %d' % (name, start_time))\n",
    "    print('Epochs: %d' % epochs)\n",
    "    print('Batch size: %d' % batch_size)\n",
    "\n",
    "    history = model.fit(train_x, train_y,\n",
    "              batch_size = batch_size,\n",
    "              epochs = epochs,\n",
    "              validation_data=(val_x, val_y))\n",
    "\n",
    "    end_time = time.time()\n",
    "    average_time_per_epoch = (end_time - start_time) / epochs\n",
    "    results.append((history, average_time_per_epoch))\n",
    "    print('Time: %d' % (end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000/2000 [==============================] - 1s 256us/step\n",
      "Model: model_15_embedded_drop_0.1_twitter_small_5epochs\n",
      "  Test score: 0.501969339252\n",
      "  Test accuracy: 0.759250001907\n"
     ]
    }
   ],
   "source": [
    "for name, model in models.items():  \n",
    "    \n",
    "    score, acc = model.evaluate(test_x, test_y,\n",
    "                                batch_size=batch_size)\n",
    "    print('Model:', name)\n",
    "    print('  Test score:', score)\n",
    "    print('  Test accuracy:', acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0567c4a110>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.style.use('ggplot')\n",
    "plt.figure(figsize=(14, 10))#, dpi=100)\n",
    "\n",
    "ax1 = plt.subplot2grid((3, 2), (0, 0))\n",
    "ax1.set_title('Training Accuracy')\n",
    "ax1.set_ylabel('Accuracy')\n",
    "ax1.set_xlabel('Epochs')\n",
    "\n",
    "ax2 = plt.subplot2grid((3, 2), (1, 0))\n",
    "ax2.set_title('Training Loss')\n",
    "ax2.set_ylabel('Loss')\n",
    "ax2.set_xlabel('Epochs')\n",
    "\n",
    "ax3 = plt.subplot2grid((3, 2), (0, 1))\n",
    "ax3.set_title('Validation Accuracy')\n",
    "ax3.set_ylabel('Accuracy')\n",
    "ax3.set_xlabel('Epochs')\n",
    "\n",
    "ax4 = plt.subplot2grid((3, 2), (1, 1))\n",
    "ax4.set_title('Validation Loss')\n",
    "ax4.set_ylabel('Loss')\n",
    "ax4.set_xlabel('Epochs')\n",
    "\n",
    "ax5 = plt.subplot2grid((3, 2), (2, 0), rowspan=1, colspan=2)\n",
    "ax5.set_title('Time')\n",
    "ax5.set_ylabel('Seconds')\n",
    "\n",
    "for mode, result in zip(models, results):\n",
    "    ax1.plot(result[0].epoch, result[0].history['acc'], label=mode)\n",
    "    ax2.plot(result[0].epoch, result[0].history['loss'], label=mode)\n",
    "    ax3.plot(result[0].epoch, result[0].history['val_acc'], label=mode)\n",
    "    ax4.plot(result[0].epoch, result[0].history['val_loss'], label=mode)\n",
    "    \n",
    "ax1.legend()\n",
    "ax2.legend()\n",
    "\n",
    "ax3.legend()\n",
    "ax4.legend()\n",
    "\n",
    "ax5.bar(np.arange(len(results)), [x[1] for x in results], tick_label = models.keys(), align='center')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}