{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "view-in-github" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "obZEfolG4xHj" }, "source": [ "# Digit Classification with Neural Networks" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "4jtHr7EC4xHo" }, "source": [ "## About this project\n", "Our goal with this notebook is to build a neural network classifier in Keras to recognize hand-written digits. We will use the MNIST data set that consists of thousands of hand writtent numbers that span 0-9\n", "\n", "Similar to the process shown below:\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "9oLA4Heh4xHq" }, "source": [ "## Import Libraries\n", "\n", "Here we import the libraries that we will be using throughout the notebook.\n", "\n", "The libraries that we will be using include:
\n", "* [Numpy](https://www.numpy.org/)\n", "* [Keras](https://keras.io/)\n", "* [Matplotlib](https://matplotlib.org/) <-for plotting and visualizations" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 34 }, "colab_type": "code", "id": "HB6rnLAz4xHs", "outputId": "23a111f9-04d8-4279-e3b0-3767f6e6d73b", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using TensorFlow backend.\n" ] } ], "source": [ "from keras.datasets import mnist\n", "from keras.preprocessing.image import load_img, array_to_img\n", "from keras.utils.np_utils import to_categorical\n", "from keras.models import Sequential\n", "from keras.layers import Dense\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "MrFQgWRQ4xH7" }, "source": [ "## Load the data" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 50 }, "colab_type": "code", "id": "dH1okxfx4xH-", "outputId": "e9e9361c-464e-409f-840e-960741361605", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n", "11493376/11490434 [==============================] - 1s 0us/step\n" ] } ], "source": [ "(X_train, y_train), (X_test, y_test) = mnist.load_data()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 101 }, "colab_type": "code", "id": "ACVJd8884xIG", "outputId": "3b27fd04-95cb-41a0-c0af-696cdcb90ed8", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "(60000, 28, 28)\n", "(60000,)\n", "(10000, 28, 28)\n", "(10000,)\n" ] } ], "source": [ "print(type(X_train))\n", "print(X_train.shape)\n", "print(y_train.shape) #60k is the answers\n", "print(X_test.shape) #10K entries\n", "print(y_test.shape)\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "JS8ISwOt4xIR" }, "source": [ "## Understanding the image data format" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 302 }, "colab_type": "code", "id": "YEEJkppA4xIT", "outputId": "4e5b1aa8-12f7-4d9b-cc5b-e78dcb7c62e0", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(28, 28)\n", "The answer is 5\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "tags": [] }, "output_type": "display_data" } ], "source": [ "#Lets look at the data to see what it looks like\n", "print(X_train[0].shape) #Look at the size of the 1st entry\n", "\n", "#Plot it to see what it looks like\n", "\n", "plt.imshow(X_train[0])\n", "\n", "#Print the answer\n", "print(\"The answer is {}\".format(y_train[0]))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "tmiVKhIZ4xIa" }, "source": [ "## Preprocessing the image data" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "EwEqNtmn4xIj", "trusted": true }, "outputs": [], "source": [ "image_height, image_width =28, 28" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "rx5l1z4i4xIs", "trusted": true }, "outputs": [], "source": [ "#Lets reshape each image to be a single vector rather than a matrix\n", "\n", "#Have to flatten to plug into neural net\n", "\n", "X_train =X_train.reshape(60000,image_height*image_width)\n", "\n", "X_test =X_test.reshape(10000,image_height*image_width)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 50 }, "colab_type": "code", "id": "ea994ZPD4xIy", "outputId": "e69eeec2-2cf7-4963-95da-f0b8b85b29a0", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(60000, 784)\n", "(10000, 784)\n" ] } ], "source": [ "print(X_train.shape) #28X28 =784\n", "print(X_test.shape)\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 34 }, "colab_type": "code", "id": "8v8d5MaK4xI-", "outputId": "2d5ed22d-255e-43fb-a893-ba08bb8b34ea", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 255\n" ] } ], "source": [ "#Check to see if image is between 0-255\n", "print(min(X_train[0]), max(X_train[0])) #it is! so we need to normalize\n", "\n", "#We will convert data to float (insead of int) to scale the data betwn 0-1 (not 0-255)\n", "\n", "X_train = X_train.astype('float32') #Convert to float\n", "X_test = X_test.astype('float32') #Convert to float" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 34 }, "colab_type": "code", "id": "3AdSGgGB4xJO", "outputId": "912bf857-10ab-46c4-f8e4-20384c1a047a", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0 1.0\n" ] } ], "source": [ "#Normalize the data\n", "X_train /= 255.0\n", "X_test /= 255.0\n", "print(min(X_train[0]), max(X_train[0])) #Normalized" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 50 }, "colab_type": "code", "id": "7vySKtRV4xJV", "outputId": "0cb20ce6-93e9-49f2-8e6f-76a1849c8bdb", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(60000, 10)\n", "(10000, 10)\n" ] } ], "source": [ "# We want the output to be in one of 9 bins to rep each of the 0-9 numbers\n", "#In order to do this we can convert the answers to a categorical value\n", "#We do this using the 'to_categorical' method\n", "\n", "y_train =to_categorical(y_train, 10)\n", "y_test =to_categorical(y_test, 10)\n", "print(y_train.shape)\n", "print(y_test.shape)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 302 }, "colab_type": "code", "id": "wjkhT5Md4xJe", "outputId": "4c22e6ff-71ea-4b89-fabd-67d3b7b1f7ab", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": { "tags": [] }, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "tags": [] }, "output_type": "display_data" } ], "source": [ "print(y_test[0])\n", "plt.imshow(X_test[0].reshape(image_height, image_width))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "0VjFhj3X4xJk" }, "source": [ "## Build a model" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 87 }, "colab_type": "code", "id": "oIfONrHx4xJl", "outputId": "9557807b-2953-42ea-c74f-7f56a14c8262", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: Logging before flag parsing goes to stderr.\n", "W0820 07:17:37.393794 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", "\n" ] } ], "source": [ "#Assign the model type\n", "model = Sequential()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 104 }, "colab_type": "code", "id": "9A8JQZM04xJs", "outputId": "046e1a5e-f1ae-47eb-8b8d-4edf41d60ee5", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "W0820 07:17:37.444703 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", "\n", "W0820 07:17:37.461894 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", "\n" ] } ], "source": [ "#Add layers to the model\n", "\n", "model.add(Dense(512, activation='relu',input_shape=(784,)))\n", "model.add(Dense(512, activation='relu'))\n", "model.add(Dense(10, activation='softmax'))\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "LP-CsvKe4xJz" }, "source": [ "## Compile the model" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 104 }, "colab_type": "code", "id": "QvTFXg-u4xJ1", "outputId": "74847074-481e-40bc-c76e-53e1b25abfff", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "W0820 07:17:37.521929 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", "\n", "W0820 07:17:37.561933 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3295: The name tf.log is deprecated. Please use tf.math.log instead.\n", "\n" ] } ], "source": [ "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "colab_type": "code", "id": "PfKMO0ZG4xKJ", "outputId": "87f77004-dc1d-4c05-9474-065e647af177", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "dense_1 (Dense) (None, 512) 401920 \n", "_________________________________________________________________\n", "dense_2 (Dense) (None, 512) 262656 \n", "_________________________________________________________________\n", "dense_3 (Dense) (None, 10) 5130 \n", "=================================================================\n", "Total params: 669,706\n", "Trainable params: 669,706\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] } ], "source": [ "model.summary()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "VsUcGruk4xKT", "trusted": false }, "source": [ "## Calculating the number of parameters for each layer\n", "\n", "### *Layer 1*\n", "* After flattening each image we get:\n", " * 28 X 28=784\n", "* We then pass the 784 into 512 nodes in the model plus a bias layer 512 (zeros)\n", "* This gives:\n", " * 784(pixels) X 512(neurons) X 512(bias)=401920\n", "\n", "\n", "### *Layer 2*\n", "* We have 512 (output from previous), going into another 512 nodes (in new layer), plus another 512\n", "* This gives:\n", " * 512 (input) X 512 (this layer) X 512 =262656\n", "\n", "### *Layer 3*\n", "* We have 512 (incoming from last layer), going into 10 nodes (in this layer), 10 bias units\n", "* This gives:\n", " * 512 (last layer) X 10 (nodes in this layer) + 10 (bias) =5130" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "yv7z0XEy4xKV" }, "source": [ "## Train the model" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ADrfMYRt4xKa", "trusted": false }, "source": [ "Now we can train our model. \n", "To do this we have to pass:\n", "* Training data\n", "* Number of epochs (the number of times that model passes through the training data)\n", "* Validation data (testing data)\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 810 }, "colab_type": "code", "id": "4j7mV13_4xKf", "outputId": "9d619d22-ed7e-4a6f-e2bc-d40d36cb8b83", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "W0820 07:17:37.736055 140395328268160 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", "W0820 07:17:37.796303 140395328268160 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:986: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Train on 60000 samples, validate on 10000 samples\n", "Epoch 1/20\n", "60000/60000 [==============================] - 24s 394us/step - loss: 0.1828 - acc: 0.9440 - val_loss: 0.0929 - val_acc: 0.9705\n", "Epoch 2/20\n", "60000/60000 [==============================] - 23s 386us/step - loss: 0.0808 - acc: 0.9757 - val_loss: 0.0827 - val_acc: 0.9743\n", "Epoch 3/20\n", "60000/60000 [==============================] - 23s 389us/step - loss: 0.0565 - acc: 0.9828 - val_loss: 0.0695 - val_acc: 0.9786\n", "Epoch 4/20\n", "60000/60000 [==============================] - 23s 381us/step - loss: 0.0429 - acc: 0.9864 - val_loss: 0.0832 - val_acc: 0.9774\n", "Epoch 5/20\n", "60000/60000 [==============================] - 23s 386us/step - loss: 0.0353 - acc: 0.9887 - val_loss: 0.0921 - val_acc: 0.9745\n", "Epoch 6/20\n", "60000/60000 [==============================] - 23s 387us/step - loss: 0.0287 - acc: 0.9910 - val_loss: 0.0819 - val_acc: 0.9782\n", "Epoch 7/20\n", "60000/60000 [==============================] - 23s 387us/step - loss: 0.0272 - acc: 0.9914 - val_loss: 0.0807 - val_acc: 0.9802\n", "Epoch 8/20\n", "60000/60000 [==============================] - 24s 395us/step - loss: 0.0237 - acc: 0.9924 - val_loss: 0.1136 - val_acc: 0.9771\n", "Epoch 9/20\n", "60000/60000 [==============================] - 23s 390us/step - loss: 0.0201 - acc: 0.9938 - val_loss: 0.1083 - val_acc: 0.9800\n", "Epoch 10/20\n", "60000/60000 [==============================] - 23s 381us/step - loss: 0.0202 - acc: 0.9939 - val_loss: 0.1016 - val_acc: 0.9798\n", "Epoch 11/20\n", "60000/60000 [==============================] - 23s 390us/step - loss: 0.0170 - acc: 0.9951 - val_loss: 0.1167 - val_acc: 0.9783\n", "Epoch 12/20\n", "60000/60000 [==============================] - 23s 387us/step - loss: 0.0175 - acc: 0.9948 - val_loss: 0.1026 - val_acc: 0.9805\n", "Epoch 13/20\n", "60000/60000 [==============================] - 23s 381us/step - loss: 0.0179 - acc: 0.9950 - val_loss: 0.1039 - val_acc: 0.9811\n", "Epoch 14/20\n", "60000/60000 [==============================] - 23s 377us/step - loss: 0.0155 - acc: 0.9956 - val_loss: 0.1173 - val_acc: 0.9809\n", "Epoch 15/20\n", "60000/60000 [==============================] - 22s 374us/step - loss: 0.0179 - acc: 0.9947 - val_loss: 0.1135 - val_acc: 0.9801\n", "Epoch 16/20\n", "60000/60000 [==============================] - 25s 415us/step - loss: 0.0126 - acc: 0.9965 - val_loss: 0.1391 - val_acc: 0.9792\n", "Epoch 17/20\n", "60000/60000 [==============================] - 24s 397us/step - loss: 0.0151 - acc: 0.9964 - val_loss: 0.1211 - val_acc: 0.9819\n", "Epoch 18/20\n", "60000/60000 [==============================] - 24s 400us/step - loss: 0.0159 - acc: 0.9962 - val_loss: 0.1208 - val_acc: 0.9800\n", "Epoch 19/20\n", "60000/60000 [==============================] - 24s 403us/step - loss: 0.0166 - acc: 0.9960 - val_loss: 0.1309 - val_acc: 0.9808\n", "Epoch 20/20\n", "60000/60000 [==============================] - 24s 397us/step - loss: 0.0133 - acc: 0.9965 - val_loss: 0.1310 - val_acc: 0.9813\n" ] } ], "source": [ "history =model.fit(X_train, y_train, epochs =20, validation_data=(X_test, y_test))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "tcWxxJcE4xKl", "trusted": false }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "jGDWqxk44xKv" }, "source": [ "## What is the accuracy of the model?" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "eIkdo9jw4xKx" }, "source": [ "### Plot the accuracy of the training model" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "mAWogC6R4xK1", "outputId": "86cce339-8f00-4f65-c8ad-69255eef9c4f", "trusted": true }, "outputs": [ { "data": { "text/plain": [ "{'epoch': [0,\n", " 1,\n", " 2,\n", " 3,\n", " 4,\n", " 5,\n", " 6,\n", " 7,\n", " 8,\n", " 9,\n", " 10,\n", " 11,\n", " 12,\n", " 13,\n", " 14,\n", " 15,\n", " 16,\n", " 17,\n", " 18,\n", " 19],\n", " 'history': {'acc': [0.9439666666666666,\n", " 0.9757333333333333,\n", " 0.9827833333333333,\n", " 0.9864166666666667,\n", " 0.9886666666666667,\n", " 0.9910333333333333,\n", " 0.9914,\n", " 0.99245,\n", " 0.9938166666666667,\n", " 0.9939,\n", " 0.99515,\n", " 0.9948,\n", " 0.9950166666666667,\n", " 0.9956333333333334,\n", " 0.9947333333333334,\n", " 0.9965166666666667,\n", " 0.9963833333333333,\n", " 0.9962166666666666,\n", " 0.99595,\n", " 0.99645],\n", " 'loss': [0.1827596818920225,\n", " 0.08079896697839722,\n", " 0.05645396511411139,\n", " 0.04291815567353721,\n", " 0.03526910000597515,\n", " 0.02873079521368248,\n", " 0.02715607473684601,\n", " 0.023650182965393438,\n", " 0.020055528101623546,\n", " 0.02019607128013062,\n", " 0.016955279541049723,\n", " 0.017472221146037314,\n", " 0.017864977817751575,\n", " 0.015457480643335983,\n", " 0.017869793417473495,\n", " 0.012631182595215281,\n", " 0.015135916414613901,\n", " 0.015882995463786898,\n", " 0.016569432756344288,\n", " 0.013335457366452594],\n", " 'val_acc': [0.9705,\n", " 0.9743,\n", " 0.9786,\n", " 0.9774,\n", " 0.9745,\n", " 0.9782,\n", " 0.9802,\n", " 0.9771,\n", " 0.98,\n", " 0.9798,\n", " 0.9783,\n", " 0.9805,\n", " 0.9811,\n", " 0.9809,\n", " 0.9801,\n", " 0.9792,\n", " 0.9819,\n", " 0.98,\n", " 0.9808,\n", " 0.9813],\n", " 'val_loss': [0.09286645495379343,\n", " 0.08266143489209934,\n", " 0.069480553943431,\n", " 0.08320518101718044,\n", " 0.09206652115154429,\n", " 0.08190068501315655,\n", " 0.08067529291427782,\n", " 0.11358439496830543,\n", " 0.10833151409866154,\n", " 0.10160923933375093,\n", " 0.11671308373045626,\n", " 0.10255490619101375,\n", " 0.10387474813488247,\n", " 0.11728941089477675,\n", " 0.11347036018394005,\n", " 0.13906407877868832,\n", " 0.12108565404413693,\n", " 0.120797497302599,\n", " 0.1309188434239974,\n", " 0.13095201672244552]},\n", " 'model': ,\n", " 'params': {'batch_size': 32,\n", " 'do_validation': True,\n", " 'epochs': 20,\n", " 'metrics': ['loss', 'acc', 'val_loss', 'val_acc'],\n", " 'samples': 60000,\n", " 'steps': None,\n", " 'verbose': 1},\n", " 'validation_data': [array([[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]], dtype=float32),\n", " array([[0., 0., 0., ..., 1., 0., 0.],\n", " [0., 0., 1., ..., 0., 0., 0.],\n", " [0., 1., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]], dtype=float32),\n", " array([1., 1., 1., ..., 1., 1., 1.], dtype=float32)]}" ] }, "execution_count": 17, "metadata": { "tags": [] }, "output_type": "execute_result" } ], "source": [ "#Look at the attributes in the history object to find the accuracy\n", "history.__dict__" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 312 }, "colab_type": "code", "id": "4fuXN2Rq4xK6", "outputId": "e13ffeb1-9f2e-45dc-9ebe-764dc8c4375c", "trusted": true }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": { "tags": [] }, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "tags": [] }, "output_type": "display_data" } ], "source": [ "#Plot the accuracy \n", "plt.plot(history.history['acc'],label='train')\n", "plt.xlabel('Epoch Number')\n", "plt.ylabel('Accuracy')\n", "plt.title('Model Accuracy Over Epoch')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "hCCz4XZ64xLC" }, "source": [ "### Plot the accuracy of training and validation set" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 312 }, "colab_type": "code", "id": "wuGKI6To4xLF", "outputId": "a463ab6c-b3fd-48df-d238-454d83377d94", "trusted": true }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 24, "metadata": { "tags": [] }, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "tags": [] }, "output_type": "display_data" } ], "source": [ "#Plot the accuracy of training data and validation data\n", "plt.plot(history.history['acc'],label='train')\n", "plt.plot(history.history['val_acc'],label='val')\n", "plt.xlabel('Epoch Number')\n", "plt.ylabel('Accuracy')\n", "plt.title('Model Accuracy Over Epoch')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "V3XNjXN14xLQ" }, "source": [ "### Accuracy of training and validation with loss" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 312 }, "colab_type": "code", "id": "X2qLlzei4xLS", "outputId": "20dc2f33-ec3d-45f0-f72d-4e7f81df1516", "trusted": true }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 25, "metadata": { "tags": [] }, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "tags": [] }, "output_type": "display_data" } ], "source": [ "#Plot the accuracy of training data and validation data AND loss\n", "plt.plot(history.history['acc'],label='train')\n", "plt.plot(history.history['val_acc'],label='val')\n", "plt.plot(history.history['loss'],label='loss')\n", "plt.xlabel('Epoch Number')\n", "plt.ylabel('Accuracy')\n", "plt.title('Model Accuracy Over Epoch')\n", "plt.legend()\n", "# plt.yscale('log')" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "sRXDnLIw4xLZ" }, "source": [ "## Evaluating model" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 34 }, "colab_type": "code", "id": "xLxuJrSI4xLb", "outputId": "1a740989-b51b-4e2c-a08a-381f39e46af9", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10000/10000 [==============================] - 1s 84us/step\n" ] } ], "source": [ "score=model.evaluate(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 34 }, "colab_type": "code", "id": "JG3xVYdd4xLj", "outputId": "05586442-a066-4006-a87d-fc4c29c68426", "trusted": true }, "outputs": [ { "data": { "text/plain": [ "[0.13095201672244552, 0.9813]" ] }, "execution_count": 22, "metadata": { "tags": [] }, "output_type": "execute_result" } ], "source": [ "#We get score as a list\n", "#The second item in score gives us the accuracy of or model\n", "score" ] } ], "metadata": { "colab": { "include_colab_link": true, "name": "DeepLearning-DigitClassificationWithKeras.ipynb", "provenance": [], "version": "0.3.2" }, "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.5.4" } }, "nbformat": 4, "nbformat_minor": 0 }