010_A_first_look_at_a_neural_network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.5.2"
    },
    "colab": {
      "name": "2.1-a-first-look-at-a-neural-network.ipynb",
      "provenance": []
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsA2hL7wlZz6"
      },
      "source": [
        "# A first look at a neural network\n",
        "\n",
        "**Author:** [FarrokhKarimi](https://github.com/farrokhkarimi)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UTzFYpN-LUvP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "0107991f-d58d-4514-c866-54283a5e65f1"
      },
      "source": [
        "import keras\n",
        "keras.__version__"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.8.0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QRsrH0wALUvk"
      },
      "source": [
        "The MNIST dataset comes pre-loaded in Keras, in the form of a set of four Numpy arrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ejtSuu4LUvq",
        "outputId": "ac5a22e1-877c-48fb-805b-e8f963b8c4fa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "from keras.datasets import mnist\n",
        "\n",
        "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n",
            "11501568/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNYuS4DeLUv2"
      },
      "source": [
        "`train_images` and `train_labels` form the \"training set\", the data that the model will learn from. The model will then be tested on the \n",
        "\"test set\", `test_images` and `test_labels`. Our images are encoded as Numpy arrays, and the labels are simply an array of digits, ranging \n",
        "from 0 to 9. There is a one-to-one correspondence between the images and the labels.\n",
        "\n",
        "Let's have a look at the training data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r_V3tbzZLUv4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "47094986-51a9-4960-9782-8c9e0bd842ed"
      },
      "source": [
        "train_images.shape"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(60000, 28, 28)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N3ZnMNbgLUwC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ace3bc7-5477-4cb5-827a-36a5d0d025e9"
      },
      "source": [
        "len(train_labels)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "60000"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S3zdFy32LUwN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6aeb4328-c8ff-44be-8d59-59e167641591"
      },
      "source": [
        "train_labels"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QG7hdD4zLUwX"
      },
      "source": [
        "Let's have a look at the test data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uRkHdVHaLUwY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25b004d5-278f-46eb-fb51-6e3c61259147"
      },
      "source": [
        "test_images.shape"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10000, 28, 28)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "isDBnRYELUwg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f2d5ecb-01b1-4674-d0a4-655575e69d25"
      },
      "source": [
        "len(test_labels)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10000"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uQgGjjFOLUwn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3c1f8075-0e9f-4124-9132-948962f077d8"
      },
      "source": [
        "test_labels"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDREbADRLUwv"
      },
      "source": [
        "Our workflow will be as follow: first we will present our neural network with the training data, `train_images` and `train_labels`. The \n",
        "network will then learn to associate images and labels. Finally, we will ask the network to produce predictions for `test_images`, and we \n",
        "will verify if these predictions match the labels from `test_labels`.\n",
        "\n",
        "Let's build our network -- again, remember that you aren't supposed to understand everything about this example just yet."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5rKp8a1LUwx"
      },
      "source": [
        "from keras import models\n",
        "from keras import layers\n",
        "\n",
        "network = models.Sequential()\n",
        "network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))\n",
        "network.add(layers.Dense(10, activation='softmax'))"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jj5fVtM_LUw6"
      },
      "source": [
        "\n",
        "The core building block of neural networks is the \"layer\", a data-processing module which you can conceive as a \"filter\" for data. Some \n",
        "data comes in, and comes out in a more useful form. Precisely, layers extract _representations_ out of the data fed into them -- hopefully \n",
        "representations that are more meaningful for the problem at hand. Most of deep learning really consists of chaining together simple layers \n",
        "which will implement a form of progressive \"data distillation\". A deep learning model is like a sieve for data processing, made of a \n",
        "succession of increasingly refined data filters -- the \"layers\".\n",
        "\n",
        "Here our network consists of a sequence of two `Dense` layers, which are densely-connected (also called \"fully-connected\") neural layers. \n",
        "The second (and last) layer is a 10-way \"softmax\" layer, which means it will return an array of 10 probability scores (summing to 1). Each \n",
        "score will be the probability that the current digit image belongs to one of our 10 digit classes.\n",
        "\n",
        "To make our network ready for training, we need to pick three more things, as part of \"compilation\" step:\n",
        "\n",
        "* A loss function: the is how the network will be able to measure how good a job it is doing on its training data, and thus how it will be \n",
        "able to steer itself in the right direction.\n",
        "* An optimizer: this is the mechanism through which the network will update itself based on the data it sees and its loss function.\n",
        "* Metrics to monitor during training and testing. Here we will only care about accuracy (the fraction of the images that were correctly \n",
        "classified).\n",
        "\n",
        "The exact purpose of the loss function and the optimizer will be made clear throughout the next two sections."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zBqlO25TLUw7"
      },
      "source": [
        "network.compile(optimizer='rmsprop',\n",
        "                loss='categorical_crossentropy',\n",
        "                metrics=['accuracy'])"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2xB9_X0LUxE"
      },
      "source": [
        "\n",
        "Before training, we will preprocess our data by reshaping it into the shape that the network expects, and scaling it so that all values are in \n",
        "the `[0, 1]` interval. Previously, our training images for instance were stored in an array of shape `(60000, 28, 28)` of type `uint8` with \n",
        "values in the `[0, 255]` interval. We transform it into a `float32` array of shape `(60000, 28 * 28)` with values between 0 and 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BCqxA38_LUxG"
      },
      "source": [
        "train_images = train_images.reshape((60000, 28 * 28))\n",
        "train_images = train_images.astype('float32') / 255\n",
        "\n",
        "test_images = test_images.reshape((10000, 28 * 28))\n",
        "test_images = test_images.astype('float32') / 255"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J6znzZbfLUxT"
      },
      "source": [
        "We also need to categorically encode the labels:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "85S2IyeOLUxV"
      },
      "source": [
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "train_labels = to_categorical(train_labels)\n",
        "test_labels = to_categorical(test_labels)"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cE4gF-_LLUxe"
      },
      "source": [
        "We are now ready to train our network, which in Keras is done via a call to the `fit` method of the network: \n",
        "we \"fit\" the model to its training data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nOJpXTbKLUxf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4419890e-7ebc-42b0-a5b2-0393465a95c6"
      },
      "source": [
        "network.fit(train_images, train_labels, epochs=5, batch_size=128)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "469/469 [==============================] - 4s 3ms/step - loss: 0.2564 - accuracy: 0.9255\n",
            "Epoch 2/5\n",
            "469/469 [==============================] - 1s 3ms/step - loss: 0.1038 - accuracy: 0.9692\n",
            "Epoch 3/5\n",
            "469/469 [==============================] - 1s 3ms/step - loss: 0.0687 - accuracy: 0.9790\n",
            "Epoch 4/5\n",
            "469/469 [==============================] - 1s 3ms/step - loss: 0.0501 - accuracy: 0.9844\n",
            "Epoch 5/5\n",
            "469/469 [==============================] - 1s 3ms/step - loss: 0.0374 - accuracy: 0.9885\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f0a767b0050>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGf23dl5LUxt"
      },
      "source": [
        "Two quantities are being displayed during training: the \"loss\" of the network over the training data, and the accuracy of the network over \n",
        "the training data.\n",
        "\n",
        "We quickly reach an accuracy of 0.989 (i.e. 98.9%) on the training data. Now let's check that our model performs well on the test set too:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnMd7U-MLUxu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6380674c-0937-484b-fcb1-797b7abd2102"
      },
      "source": [
        "test_loss, test_acc = network.evaluate(test_images, test_labels)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 2ms/step - loss: 0.0686 - accuracy: 0.9787\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "374tt9ctLUx3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0283422-fc80-4ea0-b0dc-11d9689c38b0"
      },
      "source": [
        "print('test_acc:', test_acc)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "test_acc: 0.9786999821662903\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dhbmSuCpLUyA"
      },
      "source": [
        "\n",
        "Our test set accuracy turns out to be 97.8% -- that's quite a bit lower than the training set accuracy. \n",
        "This gap between training accuracy and test accuracy is an example of \"overfitting\", \n",
        "the fact that machine learning models tend to perform worse on new data than on their training data. \n",
        "\n",
        "This concludes our very first example -- you just saw how we could build and a train a neural network to classify handwritten digits, in \n",
        "less than 20 lines of Python code. In the next section, we will go in detail over every moving piece we just previewed, and clarify what is really \n",
        "going on behind the scenes. You will learn about \"tensors\", the data-storing objects going into the network, about tensor operations, which \n",
        "layers are made of, and about gradient descent, which allows our network to learn from its training examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFZ2EcxTrGC2"
      },
      "source": [
        "**Contact** : [FarrokhKarimi](https://zil.ink/farrokhkarimi)  \n",
        "**Reference** : [tensorflow.com](https://www.tensorflow.org/)  \n",
        "Special thanks to [François Chollet](https://fchollet.com/)"
      ]
    }
  ]
}