SentimentClassification_RNNs_IMDB_Glove.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import collections\n",
    "import re\n",
    "import os\n",
    "import tarfile\n",
    "import random\n",
    "from six.moves import urllib\n",
    "\n",
    "import matplotlib as mp\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.3\n",
      "2.1.1\n",
      "1.4.1\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "print(mp.__version__)\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "DOWNLOADED_FILENAME = 'ImdbReviews.tar.gz'\n",
    "\n",
    "def download_file(url_path):\n",
    "    if not os.path.exists(DOWNLOADED_FILENAME):\n",
    "        filename, _ = urllib.request.urlretrieve(url_path, DOWNLOADED_FILENAME)\n",
    "    print('Found and verified file from this path', url_path)\n",
    "    print('Downloaded file: ', DOWNLOADED_FILENAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "TOKEN_REGEX = re.compile(\"[^A-Za-z0-9 ]+\")\n",
    "\n",
    "def get_reviews(dirname, positive=True):\n",
    "    label = 1 if positive else 0\n",
    "    \n",
    "    reviews = []\n",
    "    labels = []\n",
    "    for filename in os.listdir(dirname):\n",
    "        if filename.endswith('.txt'):\n",
    "            \n",
    "            for review in open(dirname + filename, 'r+', encoding='utf-8'):\n",
    "                review = review.lower().replace('<br />', ' ')\n",
    "                review = re.sub(TOKEN_REGEX, '', review)\n",
    "                \n",
    "                reviews.append(review)\n",
    "                labels.append(label)\n",
    "                \n",
    "    return reviews, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_labels_data():\n",
    "    # If the file has not already been extracted\n",
    "    if not os.path.exists('aclImdb'):\n",
    "        with tarfile.open(DOWNLOADED_FILENAME) as tar:\n",
    "            tar.extractall()\n",
    "            tar.close()\n",
    "            \n",
    "    positive_reviews, positive_labels = get_reviews('aclImdb/train/pos/', positive=True)\n",
    "    negative_reviews, negative_labels = get_reviews('aclImdb/train/neg/', positive=False)\n",
    "    \n",
    "    data = positive_reviews + negative_reviews\n",
    "    labels = positive_labels + negative_labels\n",
    "    \n",
    "    return labels, data\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found and verified file from this path http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\n",
      "Downloaded file:  ImdbReviews.tar.gz\n"
     ]
    }
   ],
   "source": [
    "URL_PATH = 'http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz'\n",
    "download_file(URL_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels, data = extract_labels_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['for a movie that gets no respect there sure are a lot of memorable quotes listed for this gem imagine a movie where joe piscopo is actually funny maureen stapleton is a scene stealer the moroni character is an absolute scream watch for alan the skipper hale jr as a police sgt',\n",
       " 'bizarre horror movie filled with famous faces but stolen by cristina raines later of tvs flamingo road as a pretty but somewhat unstable model with a gummy smile who is slated to pay for her attempted suicides by guarding the gateway to hell the scenes with raines modeling are very well captured the mood music is perfect deborah raffin is charming as cristinas pal but when raines moves into a creepy brooklyn heights brownstone inhabited by a blind priest on the top floor things really start cooking the neighbors including a fantastically wicked burgess meredith and kinky couple sylvia miles  beverly dangelo are a diabolical lot and eli wallach is great fun as a wily police detective the movie is nearly a crosspollination of rosemarys baby and the exorcistbut what a combination based on the bestseller by jeffrey konvitz the sentinel is entertainingly spooky full of shocks brought off well by director michael winner who mounts a thoughtfully downbeat ending with skill 12 from ',\n",
       " 'a solid if unremarkable film matthau as einstein was wonderful my favorite part and the only thing that would make me go out of my way to see this again was the wonderful scene with the physicists playing badmitton i loved the sweaters and the conversation while they waited for robbins to retrieve the birdie',\n",
       " 'its a strange feeling to sit alone in a theater occupied by parents and their rollicking kids i felt like instead of a movie ticket i should have been given a nambla membership  based upon thomas rockwells respected book how to eat fried worms starts like any childrens story moving to a new town the new kid fifth grader billy forrester was once popular but has to start anew making friends is never easy especially when the only prospect is poindexter adam or erica who at 4 12 feet is a giant  further complicating things is joe the bully his freckled face and sleeveless shirts are daunting he antagonizes kids with the death ring a crackerjack ring that is rumored to kill you if youre punched with it but not immediately no the death ring unleashes a poison that kills you in the eight grade  joe and his axis of evil welcome billy by smuggling a handful of slimy worms into his thermos once discovered billy plays it cool swearing that he eats worms all the time then he throws them at joes face ewww to win them over billy reluctantly bets that he can eat 10 worms fried boiled marinated in hot sauce squashed and spread on a peanut butter sandwich each meal is dubbed an exotic name like the radioactive slime delight in which the kids finally live out their dream of microwaving a living organism  if youve ever met me youll know that i have an uncontrollably hearty laugh i felt like a creep erupting at a toddler whining that his dilly dick hurts but fried worms is wonderfully disgusting like a grated farrelly brothers film it is both vomitous and delightful  writerdirector bob dolman is also a savvy storyteller to raise the stakes the worms must be consumed by 7 pm in addition billy holds a dark secret he has an ultrasensitive stomach  dolman also has a keen sense of perspective with such accuracy he draws on childrens insecurities and tendency to exaggerate mundane dilemmas  if you were to hyperbolize this movie the way kids do their quandaries you will see that it is essentially about war freedomfighter and freedomhater use pubescent boys as pawns in proxy wars only to learn a valuable lesson in unity international leaders can learn a thing or two about global peacekeeping from fried worms  at the end of the film i was comforted when two chaperoning mothers behind me looked at each other with befuddlement and agreed that was a great movie great now i wont have to register myself in any lawful databases',\n",
       " 'you probably all already know this by now but 5 additional episodes never aired can be viewed on abccom ive watched a lot of television over the years and this is possibly my favorite show ever its a crime that this beautifully written and acted show was canceled the actors that played laura whit carlos mae damian anya and omg steven caseman  are all incredible and so natural in those roles even the kids are great wonderful show so sad that its gone of course i wonder about the reasons it was canceled there is no way ill let myself believe that ms moynahans pregnancy had anything to do with it it was in the perfect time slot in this market ive watched all the episodes again on abccom  i hope they all come out on dvd some day thanks for reading']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000, 25000)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(labels), len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2470\n"
     ]
    }
   ],
   "source": [
    "max_document_length = max([len(x.split(' ')) for x in data])\n",
    "print(max_document_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The number of words to consider in each review - pad shorter reviews, truncate longer reviews.\n",
    "MAX_SEQUENCE_LENGTH = 250\n",
    "\n",
    "# SPECIFIC TO IMDB, average lenght of a review, plot it on graph and find the lenght, which include a majority of files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = np.load('wordsList.npy', encoding = 'latin1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([b'0', b',', b'.', b'of', b'to'],\n",
       "       dtype='|S68'), 400000)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words[:5], len(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_word_index_dictionary(words):\n",
    "    dictionary = {}\n",
    "    \n",
    "    index = 0\n",
    "    for word in words:\n",
    "        dictionary[word.decode('utf-8')] = index\n",
    "        index += 1\n",
    "    return dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionary = get_word_index_dictionary(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictionary[\"and\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "review_ids = []\n",
    "\n",
    "def convert_reviews_to_ids(data, words):\n",
    "    words_list = words.tolist()\n",
    "    \n",
    "    progress = 0\n",
    "    for review in data:\n",
    "        \n",
    "        review_id = []\n",
    "        index = 0\n",
    "\n",
    "        for word in review:\n",
    "            if index >= MAX_SEQUENCE_LENGTH:\n",
    "                break;\n",
    "\n",
    "            try: \n",
    "                review_id.append(dictionary[word])\n",
    "            except KeyError:\n",
    "                review_id.append(0)\n",
    "\n",
    "            index += 1\n",
    "\n",
    "        if len(review_id) < MAX_SEQUENCE_LENGTH:\n",
    "            review_id = np.pad(review_id, (0, MAX_SEQUENCE_LENGTH - index), 'constant')\n",
    "\n",
    "        review_ids.append(np.array(review_id))\n",
    "        progress += 1\n",
    "\n",
    "        if progress % 1000 == 0:\n",
    "            print(\"Completed: \", progress)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed:  1000\n",
      "Completed:  2000\n",
      "Completed:  3000\n",
      "Completed:  4000\n",
      "Completed:  5000\n",
      "Completed:  6000\n",
      "Completed:  7000\n",
      "Completed:  8000\n",
      "Completed:  9000\n",
      "Completed:  10000\n",
      "Completed:  11000\n",
      "Completed:  12000\n",
      "Completed:  13000\n",
      "Completed:  14000\n",
      "Completed:  15000\n",
      "Completed:  16000\n",
      "Completed:  17000\n",
      "Completed:  18000\n",
      "Completed:  19000\n",
      "Completed:  20000\n",
      "Completed:  21000\n",
      "Completed:  22000\n",
      "Completed:  23000\n",
      "Completed:  24000\n",
      "Completed:  25000\n"
     ]
    }
   ],
   "source": [
    "convert_reviews_to_ids(data, words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2159, 5918,   41, 1534,    0, 2159, 2404,    0, 3880,   41, 5025,\n",
       "       1993,    0, 2159, 1110, 5025, 5025, 1534,    0, 2159, 5918, 1110,\n",
       "          0, 1534, 2159, 4868, 1911, 3524,    0, 4868, 3880,    0, 1110,\n",
       "       1585, 2159, 1911, 4868, 2404, 1110, 1911, 2159,    0, 3880, 1911,\n",
       "          7, 3814, 3814,   41, 1110,    0, 1534, 6479, 1968, 1968, 1110,\n",
       "       3814, 5025, 3524,    0, 1911, 1110, 2159, 6479, 1911, 3814,   41,\n",
       "       3814, 3410,    0, 2159, 4868,    0, 1534,   41, 5025, 4652,    0,\n",
       "       5918, 4868, 3420, 1110,    0, 2159, 4868,    0, 2404,   41, 1534,\n",
       "         41, 2159,    0, 3880, 1911,   41, 1110, 3814, 1968, 1534,    0,\n",
       "          7, 3814, 1968,    0, 3880,    7, 1993,   41, 5025, 3524,    0,\n",
       "       1556, 6479, 2159,    0, 6479, 3814,    7, 5140,    7, 1911, 1110,\n",
       "          0, 4868, 3880,    0, 5918, 1110, 1911,    0, 1993, 4868, 2159,\n",
       "       5918, 1110, 1911, 1534,    0, 1968, 1110,    7, 2159, 5918,    0,\n",
       "       5918, 1110, 1911,    0, 1534,   41, 1534, 2159, 1110, 1911,    0,\n",
       "       1911, 6479, 3814, 1534,    0, 2159, 5918, 1110,    0, 3880,    7,\n",
       "       1993,   41, 5025, 3524,    0, 5918, 4868, 1993, 1110,    0, 1556,\n",
       "       6479, 2159,    0,   41, 1534,    0,   41, 3814, 2159, 1110, 3814,\n",
       "       1968,   41, 3814, 3410,    0, 2159, 4868,    0, 1534, 1110, 5025,\n",
       "       5025,    0,   41, 2159,    0,    7, 3814, 1968,    0, 1993, 4868,\n",
       "       2404, 1110,    0,    7, 5140,    7, 3524,    0, 5140,   41, 2159,\n",
       "       5918,    0, 5918, 1110, 1911,    0, 3814, 1110, 5140,    0, 5918,\n",
       "       6479, 1534, 1556,    7, 3814, 1968,    0, 3880, 1911,    7, 3814,\n",
       "       3814,   41, 1110,    0, 1534, 2159, 1911, 4868])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "review_ids[19825]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "review_ids = np.load('idsMatrix.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000, 250)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "review_ids.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_data = review_ids\n",
    "y_output = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400000\n"
     ]
    }
   ],
   "source": [
    "vocabulary_size = len(words)\n",
    "print(vocabulary_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(22)\n",
    "shuffle_indices = np.random.permutation(np.arange(len(x_data)))\n",
    "x_shuffled = x_data[shuffle_indices]\n",
    "y_shuffled = y_output[shuffle_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_DATA = 5000\n",
    "TOTAL_DATA = 6000\n",
    "\n",
    "train_data = x_shuffled[:TRAIN_DATA]\n",
    "train_target = y_shuffled[:TRAIN_DATA]\n",
    "\n",
    "test_data = x_shuffled[TRAIN_DATA:TOTAL_DATA]\n",
    "test_target = y_shuffled[TRAIN_DATA:TOTAL_DATA]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "x = tf.placeholder(tf.int32, [None, MAX_SEQUENCE_LENGTH])\n",
    "y = tf.placeholder(tf.int32, [None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 20\n",
    "batch_size = 25\n",
    "embedding_size = 50\n",
    "max_label = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "saved_embeddings = np.load('wordVectors.npy')\n",
    "\n",
    "embeddings = tf.nn.embedding_lookup(saved_embedings, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400000, 50)"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saved_embeddings.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'embedding_lookup:0' shape=(?, 250, 50) dtype=float32>"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embeddings\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstmCell = tf.contrib.rnn.BasicLSTMCell(embedding_size)\n",
    "\n",
    "# prevent overiftting the model to the input text.  Performs well on training data but poor on test data\n",
    "# keep probability during the training process the neuron in that layer is that it should have a 0.75 prob of being turned on \n",
    "lstmCell = tf.contrib.rnn.DropoutWrapper(cell=lstmCell, output_keep_prob=0.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output, (final_state, other_state_info)\n",
    "# dynamically unrolls the RNN through time\n",
    "# really interested in encoding (put into softmax)\n",
    "_, (encoding, _) = tf.nn.dynamic_rnn(lstmCell, embeddings, dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'rnn/while/Exit_2:0' shape=(?, 50) dtype=float32>"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = tf.layers.dense(encoding, max_label, activation=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)\n",
    "\n",
    "loss = tf.reduce_mean(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "# highest probability output\n",
    "# the prediction is accurate if it is equal to actual label\n",
    "prediction = tf.equal(tf.argmax(logits, 1), tf.cast(y, tf.int64))\n",
    "\n",
    "accuracy = tf.reduce_mean(tf.cast(prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(0.01)\n",
    "train_step = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Test Loss: 0.7, Test Acc: 0.502\n",
      "Epoch: 2, Test Loss: 0.69, Test Acc: 0.504\n",
      "Epoch: 3, Test Loss: 0.7, Test Acc: 0.517\n",
      "Epoch: 4, Test Loss: 0.78, Test Acc: 0.607\n",
      "Epoch: 5, Test Loss: 0.61, Test Acc: 0.711\n",
      "Epoch: 6, Test Loss: 0.69, Test Acc: 0.588\n",
      "Epoch: 7, Test Loss: 0.54, Test Acc: 0.717\n",
      "Epoch: 8, Test Loss: 0.5, Test Acc: 0.761\n",
      "Epoch: 9, Test Loss: 0.52, Test Acc: 0.76\n",
      "Epoch: 10, Test Loss: 0.55, Test Acc: 0.749\n",
      "Epoch: 11, Test Loss: 0.57, Test Acc: 0.747\n",
      "Epoch: 12, Test Loss: 0.63, Test Acc: 0.756\n",
      "Epoch: 13, Test Loss: 0.65, Test Acc: 0.739\n",
      "Epoch: 14, Test Loss: 0.69, Test Acc: 0.759\n",
      "Epoch: 15, Test Loss: 0.78, Test Acc: 0.758\n",
      "Epoch: 16, Test Loss: 0.75, Test Acc: 0.763\n",
      "Epoch: 17, Test Loss: 0.8, Test Acc: 0.766\n",
      "Epoch: 18, Test Loss: 0.88, Test Acc: 0.758\n",
      "Epoch: 19, Test Loss: 0.96, Test Acc: 0.75\n",
      "Epoch: 20, Test Loss: 1.0, Test Acc: 0.748\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as session:\n",
    "    init.run()\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        num_batches = int(len(train_data) // batch_size) + 1\n",
    "        \n",
    "        for i in range(num_batches):\n",
    "            \n",
    "            min_ix = i * batch_size\n",
    "            max_ix = np.min([len(train_data), ((i+1) * batch_size)])\n",
    "            \n",
    "            x_train_batch = train_data[min_ix:max_ix]\n",
    "            y_train_batch = train_target[min_ix:max_ix]\n",
    "            \n",
    "            train_dict = { x: x_train_batch, y: y_train_batch }\n",
    "            session.run(train_step, feed_dict=train_dict)\n",
    "            \n",
    "            train_loss, train_acc = session.run([loss, accuracy], feed_dict=train_dict)\n",
    "        test_dict = {x: test_data, y: test_target }\n",
    "        \n",
    "        test_loss, test_acc = session.run([loss, accuracy], feed_dict=test_dict)\n",
    "        print('Epoch: {}, Test Loss: {:.2}, Test Acc: {:.5}'.format(epoch + 1, test_loss, test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}