Day 33 Getting Started with Neural Networks-III.ipynb

{
 "cells": [
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 3\n",
    "\n",
    "## 3.1 Anatomy of a neural network\n",
    "\n",
    "1. Layers\n",
    "2. Input data\n",
    "3. Loss Function\n",
    "4. Optimizer\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "(Image source: Deep Learning with Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import layers\n",
    "layer = layers.Dense(32, input_shape = (784, )) #  a dense layer with 32 output units\n",
    "\n",
    "# the above layer will only accept 2D tensor where the first dimension is 784 (axis 0, the batch dimension, is unspecified, and thus any value would be accepted)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During creating layers in Keras, you don't need to worry about the compatibility. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import models\n",
    "from keras import layers\n",
    "\n",
    "model = models.Sequential()\n",
    "\n",
    "model.add(layers.Dense(32, input_shape = (784,)))\n",
    "model.add(layers.Dense(32))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second layer didn't receive an input shape argument- instead, it automatically inferred its input shape as being the output shape of the layer that came before.\n",
    "\n",
    "## Loss functions and optimizers: keys to configuring the learning process\n",
    "\n",
    "Even after the network architecture is defined, you still have to choose two more things:\n",
    "1. Loss function(objective function): Quantity that will be minimized during training. It represents a measure of success for the task at hand.\n",
    "\n",
    "2. Optimizer: Determines how the network will be updated based on a single scaler loss value\n",
    "\n",
    "\n",
    "* A neural network that has multiple outputs may have multiple loss functions (one per output). But the gradient-descent process must be based on a single scaller loss valur; so, for multiloss networks, all losses are combined (via averaging) into a single scaler quantity. Choosing the right objective function for the right problem is extremely important: your network will take any shortcut it can, to minimize the loss; so if the objective doesn't fully correlate with success forthe task at hand, your network will end up doing things you may not have wanted. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Keras\n",
    "\n",
    "Key features of Keras:\n",
    "\n",
    "* It allows the same code to run seamlessly on CPU or GPU\n",
    "\n",
    "* It has a user-friendly API that makes it easy to quickly prototype deep-learning models\n",
    "\n",
    "* It has built-in support for convolutional networks (for computer vision), recurent networks (for sequence processing), and combination of both.\n",
    "\n",
    "* It support arbitrary network architectures.\n",
    "\n",
    "\n",
    "### Developing with Keras: a quick overview\n",
    "\n",
    "The typical Keras workflow looks like:\n",
    "\n",
    "1. Define your training data: input tensors and target tensors.\n",
    "\n",
    "2. Define a network of layers (or model) that maps your inputs to your targets.\n",
    "\n",
    "3. Configure the learning process by choosing a loss function, an optimizer, and some metrics to monitor.\n",
    "\n",
    "4. Iterate on your training data by calling the fit() method of your model.\n",
    "\n",
    "There are two ways to define a model: \n",
    "\n",
    "a. using the Sequential class (only for linear stacks of layers, which is the most common network archtitecture by far) \n",
    "\n",
    "b. functional API (for directed acyclic graphs of layers, which lets you build completely arbitarary architectures)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import models\n",
    "from keras import layers\n",
    "\n",
    "model = models.Sequential() # for linear stacks of layers\n",
    "model.add(layers.Dense(32, activation = 'relu', input_shape=(784, )))\n",
    "model.add(layers.Dense(10, activation = 'softmax')) # output layer; softmax gives probability\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using functional API\n",
    "input_tensor = layers.Input(shape = (784, ))\n",
    "x = layers.Dense(32, activation = 'relu')(input_tensor)\n",
    "output_tensor = layers.Dense(10, activation = 'softmax')(x)\n",
    "\n",
    "model = models.Model(inputs = input_tensor, outputs = output_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import optimizers\n",
    "\n",
    "model.compile(optimizer = optimizers.RMSprop(lr=0.001),\n",
    "              loss = 'mse', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(input_tensor, target_tensor, batch_size = 128, epochs= 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up a deep-learning workstation\n",
    "\n",
    "You will need GPU! Opps! That is hard part for me and I have to compromise it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classifying movie reviews: a binary classification example\n",
    "\n",
    "#### The IMDB dataset\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading the IMDB dataset; a set of 50, 000 highly popularized review from the Internet Movie Database\n",
    "from keras.datasets import imdb\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words = 10000) # num_words = 10000 means that you will only keep the top 10000 most frequently occuring words in the training data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 194,\n",
       " 1153,\n",
       " 194,\n",
       " 8255,\n",
       " 78,\n",
       " 228,\n",
       " 5,\n",
       " 6,\n",
       " 1463,\n",
       " 4369,\n",
       " 5012,\n",
       " 134,\n",
       " 26,\n",
       " 4,\n",
       " 715,\n",
       " 8,\n",
       " 118,\n",
       " 1634,\n",
       " 14,\n",
       " 394,\n",
       " 20,\n",
       " 13,\n",
       " 119,\n",
       " 954,\n",
       " 189,\n",
       " 102,\n",
       " 5,\n",
       " 207,\n",
       " 110,\n",
       " 3103,\n",
       " 21,\n",
       " 14,\n",
       " 69,\n",
       " 188,\n",
       " 8,\n",
       " 30,\n",
       " 23,\n",
       " 7,\n",
       " 4,\n",
       " 249,\n",
       " 126,\n",
       " 93,\n",
       " 4,\n",
       " 114,\n",
       " 9,\n",
       " 2300,\n",
       " 1523,\n",
       " 5,\n",
       " 647,\n",
       " 4,\n",
       " 116,\n",
       " 9,\n",
       " 35,\n",
       " 8163,\n",
       " 4,\n",
       " 229,\n",
       " 9,\n",
       " 340,\n",
       " 1322,\n",
       " 4,\n",
       " 118,\n",
       " 9,\n",
       " 4,\n",
       " 130,\n",
       " 4901,\n",
       " 19,\n",
       " 4,\n",
       " 1002,\n",
       " 5,\n",
       " 89,\n",
       " 29,\n",
       " 952,\n",
       " 46,\n",
       " 37,\n",
       " 4,\n",
       " 455,\n",
       " 9,\n",
       " 45,\n",
       " 43,\n",
       " 38,\n",
       " 1543,\n",
       " 1905,\n",
       " 398,\n",
       " 4,\n",
       " 1649,\n",
       " 26,\n",
       " 6853,\n",
       " 5,\n",
       " 163,\n",
       " 11,\n",
       " 3215,\n",
       " 2,\n",
       " 4,\n",
       " 1153,\n",
       " 9,\n",
       " 194,\n",
       " 775,\n",
       " 7,\n",
       " 8255,\n",
       " 2,\n",
       " 349,\n",
       " 2637,\n",
       " 148,\n",
       " 605,\n",
       " 2,\n",
       " 8003,\n",
       " 15,\n",
       " 123,\n",
       " 125,\n",
       " 68,\n",
       " 2,\n",
       " 6853,\n",
       " 15,\n",
       " 349,\n",
       " 165,\n",
       " 4362,\n",
       " 98,\n",
       " 5,\n",
       " 4,\n",
       " 228,\n",
       " 9,\n",
       " 43,\n",
       " 2,\n",
       " 1157,\n",
       " 15,\n",
       " 299,\n",
       " 120,\n",
       " 5,\n",
       " 120,\n",
       " 174,\n",
       " 11,\n",
       " 220,\n",
       " 175,\n",
       " 136,\n",
       " 50,\n",
       " 9,\n",
       " 4373,\n",
       " 228,\n",
       " 8255,\n",
       " 5,\n",
       " 2,\n",
       " 656,\n",
       " 245,\n",
       " 2350,\n",
       " 5,\n",
       " 4,\n",
       " 9837,\n",
       " 131,\n",
       " 152,\n",
       " 491,\n",
       " 18,\n",
       " 2,\n",
       " 32,\n",
       " 7464,\n",
       " 1212,\n",
       " 14,\n",
       " 9,\n",
       " 6,\n",
       " 371,\n",
       " 78,\n",
       " 22,\n",
       " 625,\n",
       " 64,\n",
       " 1382,\n",
       " 9,\n",
       " 8,\n",
       " 168,\n",
       " 145,\n",
       " 23,\n",
       " 4,\n",
       " 1690,\n",
       " 15,\n",
       " 16,\n",
       " 4,\n",
       " 1355,\n",
       " 5,\n",
       " 28,\n",
       " 6,\n",
       " 52,\n",
       " 154,\n",
       " 462,\n",
       " 33,\n",
       " 89,\n",
       " 78,\n",
       " 285,\n",
       " 16,\n",
       " 145,\n",
       " 95]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here 0 means negative and 1 means positive in the dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9999"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([max(sequence) for sequence in train_data])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we are restricting to the top 10, 000 most frequent words, no word index will exceed 10, 000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word_index is a dictionary mapping words to an integer index\n",
    "word_index = imdb.get_word_index()\n",
    "\n",
    "reverse_word_index = dict([(value, key) \n",
    "                           for (key, value) in word_index.items()])\n",
    "\n",
    "#reverse it, mapping integer indices to words.\n",
    "#decode the review. Note that the indices are offsets by 3 beacuse 0, 1, and 2 reversed indices for \"pading\", \"start of sequence\", and \"unknown.\"\n",
    "\n",
    "decoded_review = ' '.join([reverse_word_index.get(i-3, '?')\n",
    "                          for i in train_data[1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing the data\n",
    " You can't feed integers into a neural network. You have to turn your lists into tensors. Two ways for it:\n",
    " \n",
    " 1. Pad your lists so that they all have the same length, turn them into an integer tensor of shape(samples, word_indices), and then use as the first layer in your network a layer capable of handling such integer tensors (the embedding layer)\n",
    " \n",
    " 2. One-hot encode your lists to turn them into vectors of 0s and 1s. \n",
    " \n",
    " \n",
    " Details of one-hot encoder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def vectorize_sequences(sequences, dimension = 10000):\n",
    "    #creating an all-zero matrix of shape (len(sequences), dimension)\n",
    "    results = np.zeros((len(sequences), dimension))\n",
    "    \n",
    "    for i, sequence in enumerate(sequences):\n",
    "        results[i, sequence]=1. # sets specific indices of results[i] to 1s\n",
    "    return results\n",
    "\n",
    "x_train = vectorize_sequences(train_data) #vectorized training data\n",
    "\n",
    "x_test = vectorize_sequences(test_data) #vectorized test data\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 1., ..., 0., 0., 0.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train[0]\n"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}