Hello_World_to_Deep_Learning_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Hello World to Deep Learning .ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZASJFY52oVX6"
      },
      "source": [
        "# **Importing TensorFlow**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iG_1rP0qo6Lk"
      },
      "source": [
        "TensorFlow is a free and open-source software library for machine learning. It can be used across a range of tasks but has a particular focus on training and inference of deep neural networks. Tensorflow is a symbolic math library based on dataflow and differentiable programming."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VPeLxXviosqD",
        "outputId": "cda81454-0d56-4256-ce95-358c5a8171c7"
      },
      "source": [
        "import tensorflow as tf\n",
        "print(\"You are using TensorFlow version\", tf.__version__)\n",
        "if len(tf.config.list_physical_devices('GPU')) > 0:\n",
        "  print(\"You have a GPU enabled.\")\n",
        "else:\n",
        "  print(\"Enable a GPU before running this notebook.\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You are using TensorFlow version 2.4.1\n",
            "Enable a GPU before running this notebook.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EugCc4jOpI8e"
      },
      "source": [
        "We will use Keras: TensorFlow's user-friendly API to define neural networks. Let's import Keras now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZU6WgB2ZpB8L"
      },
      "source": [
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t-1y-Ir-prnF"
      },
      "source": [
        "# **Download the MNIST dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dF9nCTFlpvLr",
        "outputId": "890058bc-0318-45dd-f01a-b7ad4a0d9d0e"
      },
      "source": [
        "dataset = keras.datasets.mnist\n",
        "(train_images, train_labels), (test_images, test_labels) = dataset.load_data()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "geMEdryOqCja",
        "outputId": "d330f11d-c85e-45e5-8fca-894a13cb74f1"
      },
      "source": [
        "print(\"There are \",train_images.shape , \" training images.\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are  (60000, 28, 28)  training images.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BB1BcMczqr2i",
        "outputId": "eff38440-2c56-4eef-9cb3-5fe8d91e40fa"
      },
      "source": [
        "print(\"There are \", test_images.shape , \"testing images\" )"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are  (10000, 28, 28) testing images\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4fUSK2VNq3bm",
        "outputId": "91446270-187a-4f2d-99db-d160206b8bce"
      },
      "source": [
        "print(train_labels,) #Each label is an integer between 0-9:"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 0 4 ... 5 6 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zi8x6Tx-rQvY"
      },
      "source": [
        "# **Preprocess the data**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-UQ4I856rb5j"
      },
      "source": [
        "The pixel values in the images range between 0 and 255. Let's normalize the values 0 and 1 by dividing all the images by 255. It's important that the training set and the testing set are preprocessed in the same way."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JOGgNvLfraK3"
      },
      "source": [
        "train_images = train_images / 255.0\n",
        "test_images = test_images / 255.0"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eJ65IfIxrmNy"
      },
      "source": [
        "# *Display first 25 images*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 589
        },
        "id": "LUuz3rf8rMZ8",
        "outputId": "6aeaa5d9-63a7-473b-c541-0028fe2d8974"
      },
      "source": [
        "plt.figure(figsize=(10,10))\n",
        "for i in range(25):\n",
        "    plt.subplot(5,5,i+1)  #The subplots() function takes three arguments that describes the layout of the figure.\n",
        "                          #The layout is organized in rows and columns, which are represented by the first and second argument.\n",
        "                          #The third argument represents the index of the current plot.\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.grid(False)\n",
        "    plt.imshow(train_images[i] , cmap=plt.cm.binary)\n",
        "    plt.xlabel(train_labels[i])\n",
        "plt.show()"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 25 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CpV-jlWjvqwL"
      },
      "source": [
        "# **Creating Layers**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JFRwedmFv49r"
      },
      "source": [
        "Neural networks are made up of layers. \n",
        "The \"Deep\" in \"Deep Learning\" refers to the depth of the network. Deeper networks can learn increasingly abstract patterns. Roughly, the width of a layer (in terms of the number of neurons) refers to the number of patterns it can learn of each type.\n",
        "Most of deep learning consists of chaining together simple layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4CUhxFyzvw4M"
      },
      "source": [
        "# A linear model\n",
        "model = keras.Sequential([\n",
        "    keras.layers.Flatten(input_shape=(28, 28)),\n",
        "    keras.layers.Dense(10, activation='softmax')\n",
        "])"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F839YqKBwiqp"
      },
      "source": [
        "# **Compile the model**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "khGSDlsZwywm"
      },
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss='sparse_categorical_crossentropy',\n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FS5hCX_TwwYH"
      },
      "source": [
        "Loss function — This measures how accurate the model is during training. You want to minimize this function to \"steer\" the model in the right direction.\n",
        "\n",
        "Optimizer — This is how the model is updated based on the data it sees and its loss function.\n",
        "\n",
        "Metrics — Used to monitor the training and testing steps. The following example uses accuracy, the fraction of the images that are correctly classified."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ays9BzGAw9RJ"
      },
      "source": [
        "# **Train the model**\n",
        "Training the neural network model requires the following steps:\n",
        "\n",
        "Feed the training data to the model. In this example, the training data is in the train_images and train_labels arrays.\n",
        "\n",
        "The model learns to associate images and labels.\n",
        "\n",
        "You ask the model to make predictions about a test set—in this example, the test_images array.\n",
        "\n",
        "Verify that the predictions match the labels from the test_labels array.\n",
        "\n",
        "To begin training, call the model.fit method — so called because it \"fits\" the model to the training data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tx0W3_b-wmtr",
        "outputId": "2eef4be9-134c-4ed6-b73d-baf23bfcab98"
      },
      "source": [
        "EPOCHS=10\n",
        "model.fit(train_images, train_labels, epochs=EPOCHS)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.7262 - accuracy: 0.8101\n",
            "Epoch 2/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.3104 - accuracy: 0.9128\n",
            "Epoch 3/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.2890 - accuracy: 0.9188\n",
            "Epoch 4/10\n",
            "1875/1875 [==============================] - 2s 1ms/step - loss: 0.2702 - accuracy: 0.9253\n",
            "Epoch 5/10\n",
            "1875/1875 [==============================] - 2s 1ms/step - loss: 0.2669 - accuracy: 0.9257\n",
            "Epoch 6/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.2539 - accuracy: 0.9297\n",
            "Epoch 7/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.2611 - accuracy: 0.9268\n",
            "Epoch 8/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.2510 - accuracy: 0.9306\n",
            "Epoch 9/10\n",
            "1875/1875 [==============================] - 3s 1ms/step - loss: 0.2550 - accuracy: 0.9304\n",
            "Epoch 10/10\n",
            "1875/1875 [==============================] - 2s 1ms/step - loss: 0.2494 - accuracy: 0.9316\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7f8b0c7408d0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-rPRb4pTxWFS"
      },
      "source": [
        "# **Evaluate Accuracy**\n",
        "Next, compare how the model performs on the test dataset:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o7hjpAJqxatF",
        "outputId": "d9338f15-e274-4949-af14-766a26f58987"
      },
      "source": [
        "test_loss, test_acc = model.evaluate(test_images, test_labels)\n",
        "print('\\nTest accuracy:', test_acc)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 1s 1ms/step - loss: 0.2683 - accuracy: 0.9274\n",
            "\n",
            "Test accuracy: 0.9273999929428101\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D2XfEWNExzH8"
      },
      "source": [
        "# **Make predictions**\n",
        "With the model trained, you can use it to make predictions about some images."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GCsRHl0Hx2GK"
      },
      "source": [
        "predictions = model.predict(test_images)"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jzme7Xix-v-"
      },
      "source": [
        "Here, the model has predicted the label for each image in the testing set. Let's take a look at the first prediction:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 630
        },
        "id": "VaFbV7dCyE_J",
        "outputId": "748b55c8-01e7-48dc-ff14-92f2e0c2d489"
      },
      "source": [
        "print(predictions[0])\n",
        "plt.figure(figsize=(10,10))\n",
        "plt.xticks([])\n",
        "plt.yticks([])\n",
        "plt.grid(False)\n",
        "plt.imshow(test_images[0], cmap=plt.cm.binary)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9.5434245e-07 4.7694869e-12 3.3126371e-06 5.5690971e-03 1.9266365e-07\n",
            " 3.9639304e-05 5.6438049e-12 9.9386615e-01 1.8763931e-05 5.0188741e-04]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f8b0d3f26d0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ZbP0mjnyQnS"
      },
      "source": [
        "A prediction is an array of 10 numbers. They represent the model's \"confidence\" that the image corresponds to each of the 10 digits. You can see which label has the highest confidence value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Anwer35lyu14",
        "outputId": "931da009-b565-4a3e-d88c-1dba71969035"
      },
      "source": [
        "print(tf.argmax(predictions[0]))"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor(7, shape=(), dtype=int64)\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}