sent_featuresets_netflix.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentiment Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "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\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": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data/netflix-train-pos', 'r') as f:\n",
    "    positive_train_txt = f.read()\n",
    "with open('./data/netflix-train-neg', 'r') as f:\n",
    "    negative_train_txt = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The positive data size: 16855330\n",
      "The negative data size: 16302491\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": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic/Benchmark Accuracy: 0.50833647965\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": 46,
   "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": "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": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: \t\t(25000,)\n",
      "Label shape: \t\t(25000, 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 # 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": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 88584 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": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Word Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "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": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null word embeddings: -1\n",
      "Found 60150\n",
      "Total: 88585\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": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6704d20650>"
      ]
     },
     "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": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max word sentence: 2493\n"
     ]
    }
   ],
   "source": [
    "print('Max word sentence: %d' % max_word_count_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some issues here. We seem to have one review with zero length. And, the maximum review length is way too many steps for our RNN. Let's truncate to 200 steps. For reviews shorter than 200, we'll pad with 0s. For reviews longer than 200, we can truncate them to the first 200 characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turns out its the final review that has zero length. But that might not always be the case, so let's make it more general.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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 200 elements long. For reviews shorter than 200 words, left pad with 0s. That is, if the review is ['best', 'movie', 'ever'], [117, 18, 128] as integers, the row will look like [0, 0, 0, ..., 0, 117, 18, 128]. For reviews longer than 200, use on the first 200 words as the feature vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_len = 100\n",
    "features = sequence.pad_sequences(train_ints, maxlen = seq_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One sample\n",
      "Text: \n",
      "I saw this movie originally in the theater, when I was 10. Even at that age the 'humor' was mildly insulting to my adolescent intelligence.<br /><br />In the past, whenever I would see Ed Begley Jr. or jeff Goldblum I would cringe and start to feel very uncomfortable and even slightly sad. Until I was reminded of the existence of this movie today, I was unsure why I felt that way. Apparently I blocked my memory of this movie yet my negative feelings towards two of the perpetrators remained. Apparently I forgot that I saw this movie but subconsciously mourned the pieces of my soul that had been stolen, nay EATEN by the creators of this inhuman work.<br /><br />I haven't been brave enough to try watching it as an adult. I imagine that as part of the healing process that I should probably look at confronting this childhood fear so that I can *truly* put it behind me. Some regression therapy and / or hypnosis might not be a bad idea either.\n",
      "Word sequence: \n",
      "[10, 216, 11, 17, 1816, 8, 1, 747, 51, 10, 13, 155, 57, 30, 12, 555, 1, 30568, 13, 2781, 3493, 5, 58, 5558, 1656, 7, 7, 8, 1, 498, 1938, 10, 59, 64, 1657, 20598, 1789, 39, 1802, 6627, 10, 59, 4010, 2, 377, 5, 231, 52, 3129, 2, 57, 1072, 614, 363, 10, 13, 1574, 4, 1, 2007, 4, 11, 17, 635, 10, 13, 6192, 135, 10, 417, 12, 93, 681, 10, 16116, 58, 1751, 4, 11, 17, 243, 58, 1559, 1414, 946, 104, 4, 1, 14896, 5171, 681, 10, 2736, 12, 10, 216, 11, 17, 18, 23379, 25242, 1, 1321, 4, 58, 1351, 12, 66, 74, 2576, 16117, 4676, 31, 1, 3657, 4, 11, 13885, 154, 7, 7, 10, 771, 74, 2502, 192, 5, 350, 146, 9, 14, 32, 1155, 10, 835, 12, 14, 170, 4, 1, 8926, 1768, 12, 10, 141, 239, 165, 30, 9259, 11, 1544, 1088, 35, 12, 10, 67, 368, 273, 9, 493, 69, 46, 34701, 7262, 2, 39, 16816, 235, 21, 27, 3, 75, 323, 342]\n",
      "Pad: \n",
      "[16116    58  1751     4    11    17   243    58  1559  1414   946   104\n",
      "     4     1 14896  5171   681    10  2736    12    10   216    11    17\n",
      "    18 23379 25242     1  1321     4    58  1351    12    66    74  2576\n",
      " 16117  4676    31     1  3657     4    11 13885   154     7     7    10\n",
      "   771    74  2502   192     5   350   146     9    14    32  1155    10\n",
      "   835    12    14   170     4     1  8926  1768    12    10   141   239\n",
      "   165    30  9259    11  1544  1088    35    12    10    67   368   273\n",
      "     9   493    69    46 34701  7262     2    39 16816   235    21    27\n",
      "     3    75   323   342]\n",
      "Label: \n",
      "['0' '1']\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": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\t\tFeature Shapes:\n",
      "Train set: \t\t(20000, 100)\n",
      "Validation set: \t(2500, 100)\n",
      "Test set: \t\t(2500, 100)\n",
      "Train lable: \t\t(20000, 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": [
    "## Create Sentiment Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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": 59,
   "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='softmax', 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": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Start learning model_200_embedded_drop_0_netflix_ALL at 1521742294\n",
      "Epochs: 5\n",
      "Batch size: 20\n",
      "Train on 20000 samples, validate on 2500 samples\n",
      "Epoch 1/5\n",
      "20000/20000 [==============================] - 299s 15ms/step - loss: 0.5201 - acc: 0.7304 - val_loss: 0.4236 - val_acc: 0.8028\n",
      "Epoch 2/5\n",
      "20000/20000 [==============================] - 310s 16ms/step - loss: 0.3805 - acc: 0.8257 - val_loss: 0.3641 - val_acc: 0.8380\n",
      "Epoch 3/5\n",
      "20000/20000 [==============================] - 277s 14ms/step - loss: 0.3341 - acc: 0.8544 - val_loss: 0.3712 - val_acc: 0.8336\n",
      "Epoch 4/5\n",
      "20000/20000 [==============================] - 272s 14ms/step - loss: 0.3007 - acc: 0.8693 - val_loss: 0.3562 - val_acc: 0.8472\n",
      "Epoch 5/5\n",
      "20000/20000 [==============================] - 219s 11ms/step - loss: 0.2682 - acc: 0.8856 - val_loss: 0.3557 - val_acc: 0.8468\n",
      "Time: 1380\n"
     ]
    }
   ],
   "source": [
    "batch_size = 20\n",
    "epochs = 5\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_200_embedded_drop_0_netflix_ALL'] = createEmbeddedModel(200, 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": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('model_100_embedded_drop_0_netflix_ALL.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2500/2500 [==============================] - 11s 4ms/step\n",
      "Model: model_200_embedded_drop_0_netflix_ALL\n",
      "  Test score: 0.305043537796\n",
      "  Test accuracy: 0.866400000095\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": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f670a575d50>"
      ]
     },
     "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.94268298  0.05731701]\n",
      " [ 0.99896383  0.00103612]\n",
      " [ 0.02653761  0.9734624 ]\n",
      " ..., \n",
      " [ 0.59167725  0.40832281]\n",
      " [ 0.99164683  0.00835326]\n",
      " [ 0.1524141   0.84758586]]\n"
     ]
    }
   ],
   "source": [
    "for name, model in models.items():\n",
    "    classes = model.predict(test_x, batch_size=20)\n",
    "    \n",
    "print(classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "positive matched 1090\n",
      "negative matched 1076\n",
      "positive total 1260\n",
      "negative total 1240\n"
     ]
    }
   ],
   "source": [
    "predicted = np.argmax(classes, axis=1)\n",
    "real = np.argmax(test_y, axis=1)\n",
    "\n",
    "#print(predicted)\n",
    "#print(real)\n",
    "\n",
    "pos = 0\n",
    "neg = 0\n",
    "\n",
    "for i in xrange(len(predicted)):\n",
    "    if predicted[i] == real[i]:\n",
    "        if predicted[i] == 1:\n",
    "            pos += 1\n",
    "        else:\n",
    "            neg += 1\n",
    "            \n",
    "print(\"positive matched \" + str(pos))\n",
    "print(\"negative matched \" + str(neg))\n",
    "\n",
    "#(predicted == real).all()\n",
    "\n",
    "len(classes)\n",
    "\n",
    "total_pos = 0\n",
    "total_neg = 0\n",
    "\n",
    "for i in xrange(len(predicted)):\n",
    "    if predicted[i] == 1:\n",
    "        total_pos += 1\n",
    "    else:\n",
    "        total_neg += 1\n",
    "        \n",
    "print(\"positive total \" + str(total_pos))\n",
    "print(\"negative total \" + str(total_neg))"
   ]
  },
  {
   "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
}