Tensorflow - Beginners.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tensorflow - Beginners.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNBB3q3o58c/xEm/oLg0UX/",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sahug/ds-tensorflow-colab/blob/master/Tensorflow%20-%20Beginners.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tensorflow - Beginners**\n",
        "\n",
        "This short introduction uses **Keras** to:\n",
        "\n",
        "- Load a prebuilt dataset.\n",
        "- Build a neural network machine learning model that classifies images.\n",
        "- Train this neural network.\n",
        "- Evaluate the accuracy of the model."
      ],
      "metadata": {
        "id": "Hbqd40OTcrEq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "print(\"TF Version: \", tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y412xa9Ocxg3",
        "outputId": "84247b83-c6b2-4d70-d80e-4d328b344828"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TF Version:  2.8.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Load Dataset**\n",
        "\n",
        "Load and prepare the MNIST dataset. Convert the sample data **from integers to floating-point numbers:**"
      ],
      "metadata": {
        "id": "cM0CCRUec6x6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mnist = tf.keras.datasets.mnist\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "x_train, x_test = x_train / 255.0, x_test / 255.0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xkDgLoHVc8GS",
        "outputId": "c759e1db-a6dc-4533-ba62-09c1084d9eeb"
      },
      "execution_count": 42,
      "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",
      "source": [
        "**Build Model**\n",
        "\n",
        "Build a **tf.keras.Sequential** model by stacking layers."
      ],
      "metadata": {
        "id": "ZK6zhAeBdfD0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.models.Sequential([\n",
        "  tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
        "  tf.keras.layers.Dense(128, activation=\"relu\"),\n",
        "  tf.keras.layers.Dropout(0.2),\n",
        "  tf.keras.layers.Dense(10)                                   \n",
        "])"
      ],
      "metadata": {
        "id": "jM54gbxKdd4E"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pred = model(x_train[:1]).numpy()\n",
        "pred"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X9g3AQx3eCDA",
        "outputId": "a39c2f7a-413e-46b8-9072-920f0d762725"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  67.82232 ,    8.139023,  -52.911324,   12.07279 , -144.65675 ,\n",
              "         -60.28835 , -108.16102 ,  -41.340042,  -83.84029 ,  -17.13696 ]],\n",
              "      dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The **tf.nn.softmax** function converts these logits to **probabilities** for each class:"
      ],
      "metadata": {
        "id": "-aWhudfMeOXX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.nn.softmax(pred).numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4FRpnLT2ePqW",
        "outputId": "cd29bcc8-cb26-46ad-e616-cf3cf2c908ba"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.0000000e+00, 1.2019151e-26, 0.0000000e+00, 6.1416928e-25,\n",
              "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
              "        0.0000000e+00, 1.2666481e-37]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define a loss function for training using **losses.SparseCategoricalCrossentropy**, which takes **a vector of logits** and a **True** index and returns a scalar loss for each example."
      ],
      "metadata": {
        "id": "E3T1P6RUeg91"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)"
      ],
      "metadata": {
        "id": "OuucrHr_eYpa"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn(y_train[:1], pred).numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yz68nxK1elul",
        "outputId": "781f5c3e-2c5f-4b92-fc4b-39eb3a6ffb27"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128.11067"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Before you start **training, configure and compile** the model using **Keras Model.compile**. Set the **optimizer** class to **adam**, set the loss to the **loss_fn** function you defined earlier, and specify a **metric** to be evaluated for the model by setting the metrics parameter to accuracy."
      ],
      "metadata": {
        "id": "_pXNn4fVexi0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss=loss_fn,\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "dTBc1xqce-0b"
      },
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Train and evaluate your model**"
      ],
      "metadata": {
        "id": "efIO6sfGfBAJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(x_train, y_train, epochs=5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nFBtG9NRfCL1",
        "outputId": "9615ec84-0127-4b62-8960-ea3279d38915"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 2.7941 - accuracy: 0.7637\n",
            "Epoch 2/5\n",
            "1875/1875 [==============================] - 7s 4ms/step - loss: 0.6126 - accuracy: 0.8419\n",
            "Epoch 3/5\n",
            "1875/1875 [==============================] - 7s 4ms/step - loss: 0.4871 - accuracy: 0.8744\n",
            "Epoch 4/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4279 - accuracy: 0.8892\n",
            "Epoch 5/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3901 - accuracy: 0.9006\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f907f957f90>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.evaluate(x_test,  y_test, verbose=2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_VpEDVLfD9g",
        "outputId": "d2448320-c49e-4c5d-a549-5025e529d266"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 - 1s - loss: 0.3027 - accuracy: 0.9367 - 543ms/epoch - 2ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.30266073346138, 0.9366999864578247]"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "probability_model = tf.keras.Sequential([\n",
        "  model,\n",
        "  tf.keras.layers.Softmax()\n",
        "])"
      ],
      "metadata": {
        "id": "20vxbKypfFI1"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "probability_model(x_test[:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LAA0bC-TfGB6",
        "outputId": "a7acb270-3cd6-4d96-f6e8-3cbb76ee8538"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 10), dtype=float32, numpy=\n",
              "array([[0.0000000e+00, 2.7994615e-14, 6.4213706e-13, 1.1016904e-11,\n",
              "        3.8598513e-36, 0.0000000e+00, 0.0000000e+00, 1.0000000e+00,\n",
              "        4.4656190e-35, 7.6840086e-25],\n",
              "       [2.1219342e-17, 7.3594274e-06, 9.9940717e-01, 5.6410604e-04,\n",
              "        5.6817162e-15, 1.6693997e-05, 1.6074243e-10, 4.6962637e-06,\n",
              "        1.4478434e-08, 1.4938911e-23],\n",
              "       [1.9495880e-37, 1.0000000e+00, 1.2560970e-13, 1.1148642e-18,\n",
              "        2.8128529e-29, 3.0625129e-38, 7.6108092e-19, 9.8829405e-14,\n",
              "        4.7939470e-19, 1.5291782e-26],\n",
              "       [9.9999821e-01, 0.0000000e+00, 1.7893336e-06, 1.4121217e-18,\n",
              "        1.9870287e-14, 5.6151694e-11, 1.6451494e-08, 2.3311218e-08,\n",
              "        1.1222831e-17, 2.6266003e-12],\n",
              "       [3.2235274e-20, 8.9683370e-27, 1.0136967e-10, 9.1401834e-38,\n",
              "        9.9999988e-01, 3.1208673e-15, 7.3361863e-18, 1.2180392e-08,\n",
              "        0.0000000e+00, 1.5467936e-07]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    }
  ]
}