MNIST-Keras-Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning in Python\n",
    "\n",
    "## SIGN-IN HERE: [tinyurl.com/deltahacksinstitute](tinyurl.com/deltahacksinstitute)\n",
    "\n",
    "## What is Machine Learning\n",
    "Machine Learning:\n",
    "* Computer learns by itself\n",
    "* Requires lots of data that the computer can learn from\n",
    "\n",
    "Today's activity, Image Classification:\n",
    "* Data will be various digits\n",
    "* End goal: computer can classify digits in images\n",
    "\n",
    "Neural Netowork:\n",
    "* Hot-topic in today's world\n",
    "* Models a human-brain and the way we learn things\n",
    "* Has layers\n",
    "  * Input layer: Data\n",
    "  * Hidden layers\n",
    "  * Output layer: Result\n",
    "* Can be trained with data\n",
    "\n",
    "## Convolutional Neural Network (CNN)\n",
    "* Special type of neural network, specifically for images\n",
    "* Layers\n",
    "  * Input layer: Image is fed, pixel by pixel\n",
    "  * Hidden layers\n",
    "  * Output layer: Probability associated with all the classes\n",
    "  * Different types of Layers\n",
    "* Data\n",
    "  * Called MNIST (Modified National Institute of Standards and Technology database)\n",
    "  * 60,000 training images and 10,000 testing images\n",
    "\n",
    "![Diagram](img/diagram.png)\n",
    "\n",
    "## Keras\n",
    "* Machine Learning package\n",
    "* Useful for quick prototyping of a lot of things, such as CNNs\n",
    "* Uses tensorflow in the backend\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Statements\n",
    "``` from __future__ import print_function ```: ensures interpreter doesn't round when printing values\n",
    "\n",
    "``` import keras ```: imports the keras package\n",
    "\n",
    "``` from keras.datasets import mnist ```: imports the MNIST dataset\n",
    "\n",
    "``` from keras.models import Sequential ```: imports the Sequential Model, a model which allows us to add layers on top of each other and makes it easy to create CNNs\n",
    "\n",
    "``` from keras.layers import Dense, Dropout, Flatten ```, ``` from keras.layers import Conv2D, MaxPooling2D ```: imports the different types of layers needed for CNNs\n",
    "\n",
    "``` from keras import backend as K ```: imports the backend (we will be using tensorflow)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import keras\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras import backend as K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constants\n",
    "``` batch_size = 128 ```: a batch is how many images you would like to train your network with at once. After each batch, the network updates the weights in each layer.\n",
    "\n",
    "``` num_classes = 10 ```: how many possible outputs we have (10 for 10 different digits)\n",
    "\n",
    "``` epochs = 12 ```: how many times we are going to go through the data and feed it in the network\n",
    "\n",
    "``` img_rows, img_cols = 28, 28 ```: size of the data, in pixels. 28 x 28 is default for MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "num_classes = 10\n",
    "epochs = 5 #12 is ideal, but will take more time\n",
    "\n",
    "# input image dimensions\n",
    "img_rows, img_cols = 28, 28"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocesing Data\n",
    "``` (x_train, y_train), (x_test, y_test) = mnist.load_data() ```: \"x\" refers to the images, while \"y\" refers to the label for each image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n",
      "11493376/11490434 [==============================] - 5s 0us/step\n"
     ]
    }
   ],
   "source": [
    "# the data, split between train and test sets\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input Format\n",
    "We check the type of backend that is being used and accordingly shape our input data. \n",
    "\n",
    "``` reshape(x_train.shape[0], 1, img_rows, img_cols) ```: (# of imgs, # colors, # of rows, # of cols)\n",
    "\n",
    "``` input_shape = (1, img_rows, img_cols) ```: (# colors, # of rows, # of cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "if K.image_data_format() == 'channels_first':\n",
    "    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n",
    "    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n",
    "    input_shape = (1, img_rows, img_cols)\n",
    "else:\n",
    "    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
    "    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
    "    input_shape = (img_rows, img_cols, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing Data\n",
    "``` astype('float32') ```: describes the precision we want for each pixel value. We use 32 so that when we divide each pixel value in the next step, we can still preserve the precision.\n",
    "\n",
    "``` /= 255 ```: each pixel value has a range from 0 - 255. Dividing the value by 255 results in a new range from 0 - 1 which is the type of input the Neural Network requires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28, 1)\n",
      "60000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "x_train = x_train.astype('float32')\n",
    "x_test = x_test.astype('float32')\n",
    "x_train /= 255\n",
    "x_test /= 255\n",
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_test.shape[0], 'test samples')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing Labels\n",
    "``` to_categorical(y_train, num_classes) ```: converts the labels to class matrices, which have values between 0 - 1 as per the requirements of the Neural Network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert class vectors to binary class matrices\n",
    "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
    "y_test = keras.utils.to_categorical(y_test, num_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the model\n",
    "``` model = Sequential() ```: creates the sequential model\n",
    "``` model.add() ```: adds a layer on top of the existing model\n",
    "The important layers are ``` Conv2D ``` and ``` MaxPooling2D ```. These layers break the image into smaller pieces before doing the math on them. \n",
    "\n",
    "![Conv2D](img/conv2d_diagram.png)\n",
    "\n",
    "The layers following help combine the data from these layers into one output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(Conv2D(32, kernel_size=(3, 3),\n",
    "                 activation='relu',\n",
    "                 input_shape=input_shape))\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(num_classes, activation='softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compiling the Model\n",
    "``` model.compile() ```: allows us to set parameters on how the model should be trained\n",
    "\n",
    "``` loss=keras.losses.categorical_crossentropy ```: specifies the loss function. The loss function is the function which the algorithm best tries to achieve. It is a way of measuring how good/bad the network is performing.\n",
    "\n",
    "``` optimizer=keras.optimizers.Adadelta() ```: specify the type of \n",
    "mathematical algorithm we would like to use to train the CNN\n",
    "\n",
    "``` metrics=['accuracy'] ```: specify what information while training the CNN should be outputed to the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "              optimizer=keras.optimizers.Adadelta(),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model\n",
    "``` model.fit() ```: tells the model to use the parameters and fit the weights of the layers so that the loss function is maximized. It returns an object that has the information of how the model was performing in each epoch.\n",
    "\n",
    "``` verbose=1 ```: specifies how the output should be displayed during the training.\n",
    "\n",
    "``` validation_data=(x_test, y_test) ```: specifies which set of data is meant for validation data. Validation data is data which we branch of the original dataset in order to see how the network's accuracy is. This allows for an un-biased evaluation of a network.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/12\n",
      "60000/60000 [==============================] - 65s 1ms/step - loss: 0.2769 - acc: 0.9142 - val_loss: 0.0578 - val_acc: 0.9815\n",
      "Epoch 2/12\n",
      "60000/60000 [==============================] - 56s 936us/step - loss: 0.0931 - acc: 0.9721 - val_loss: 0.0435 - val_acc: 0.9857\n",
      "Epoch 3/12\n",
      "60000/60000 [==============================] - 66s 1ms/step - loss: 0.0689 - acc: 0.9794 - val_loss: 0.0357 - val_acc: 0.9879\n",
      "Epoch 4/12\n",
      "60000/60000 [==============================] - 67s 1ms/step - loss: 0.0550 - acc: 0.9833 - val_loss: 0.0301 - val_acc: 0.9899\n",
      "Epoch 5/12\n",
      "60000/60000 [==============================] - 68s 1ms/step - loss: 0.0492 - acc: 0.9854 - val_loss: 0.0319 - val_acc: 0.9887\n",
      "Epoch 6/12\n",
      "60000/60000 [==============================] - 70s 1ms/step - loss: 0.0453 - acc: 0.9866 - val_loss: 0.0303 - val_acc: 0.9905\n",
      "Epoch 7/12\n",
      "60000/60000 [==============================] - 73s 1ms/step - loss: 0.0394 - acc: 0.9879 - val_loss: 0.0263 - val_acc: 0.9921\n",
      "Epoch 8/12\n",
      "60000/60000 [==============================] - 73s 1ms/step - loss: 0.0369 - acc: 0.9887 - val_loss: 0.0288 - val_acc: 0.9911\n",
      "Epoch 9/12\n",
      "60000/60000 [==============================] - 62s 1ms/step - loss: 0.0336 - acc: 0.9897 - val_loss: 0.0266 - val_acc: 0.9918\n",
      "Epoch 10/12\n",
      "60000/60000 [==============================] - 65s 1ms/step - loss: 0.0320 - acc: 0.9902 - val_loss: 0.0259 - val_acc: 0.9918\n",
      "Epoch 11/12\n",
      "60000/60000 [==============================] - 69s 1ms/step - loss: 0.0300 - acc: 0.9907 - val_loss: 0.0272 - val_acc: 0.9913\n",
      "Epoch 12/12\n",
      "60000/60000 [==============================] - 76s 1ms/step - loss: 0.0273 - acc: 0.9917 - val_loss: 0.0273 - val_acc: 0.9916\n",
      "Test loss: 0.02733025009893945\n",
      "Test accuracy: 0.9916\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))\n",
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyzing the Model\n",
    "The following code uses the history object we created above when the neural network completed. We can use this data to graph the accuracy of our network over each epoch. Don't worry too much about the code, it simply formats the data using a package called matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['val_loss', 'val_acc', 'loss', 'acc'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "print(history.history.keys())\n",
    "# summarize history for accuracy\n",
    "plt.plot(history.history['acc'])\n",
    "plt.plot(history.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "# summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}