Tensorflow - 2D CNN CIFAC10 Image Classifier.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sahug/ds-tensorflow-colab/blob/master/Tensorflow%20-%202D%20CNN%20CIFAC10%20Image%20Classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PgPyKVeA4XZT"
      },
      "source": [
        "**Tensorflow - 2D CNN CIFAC10 Image Classifier**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jlHm3AMa4bIX"
      },
      "source": [
        "**What is CNN**\n",
        "\n",
        "A **Convolutional Neural Network (ConvNet/CNN)** is a Deep Learning algorithm which can take in an input image, assign importance (learnable weights and biases) to various aspects/objects in the image and be able to differentiate one from the other. The pre-processing required in a ConvNet is much lower as compared to other classification algorithms. While in primitive methods filters are hand-engineered, with enough training, ConvNets have the ability to learn these filters/characteristics\n",
        "\n",
        "**Important Terms of CNN**\n",
        "\n",
        "- Convolutional Layer\n",
        "- Activation Function\n",
        "- Filter Size (Each filter extract different part of the image)\n",
        "- Stride Size\n",
        "- Max pooling\n",
        "- Flattening and Dense LayerWhat is CNN\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sgBT0GeS4pf6"
      },
      "source": [
        "**Download Data and Model Building**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "zEPiCzpL4t_B"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "Wuvc7Z944vgA"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.8.0\n"
          ]
        }
      ],
      "source": [
        "print(tf.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Approach 1**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Load Dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {},
      "outputs": [],
      "source": [
        "import tensorflow_datasets as tfds\n",
        "\n",
        "(ds_train, ds_test), ds_info = tfds.load(\"cifar10\",\n",
        "                                        split=[\"train\", \"test\"],\n",
        "                                        shuffle_files=True,\n",
        "                                        # True, the returned tf.data.Dataset will have a 2-tuple structure (input, label)\n",
        "                                        # False, the default, the returned tf.data.Dataset will have a dictionary with all the features.\n",
        "                                        as_supervised=True,\n",
        "                                        with_info=True)                                        "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Dataset Info**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tfds.core.DatasetInfo(\n",
              "    name='cifar10',\n",
              "    full_name='cifar10/3.0.2',\n",
              "    description=\"\"\"\n",
              "    The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images.\n",
              "    \"\"\",\n",
              "    homepage='https://www.cs.toronto.edu/~kriz/cifar.html',\n",
              "    data_path='C:\\\\Users\\\\sahug\\\\tensorflow_datasets\\\\cifar10\\\\3.0.2',\n",
              "    download_size=162.17 MiB,\n",
              "    dataset_size=132.40 MiB,\n",
              "    features=FeaturesDict({\n",
              "        'id': Text(shape=(), dtype=tf.string),\n",
              "        'image': Image(shape=(32, 32, 3), dtype=tf.uint8),\n",
              "        'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=10),\n",
              "    }),\n",
              "    supervised_keys=('image', 'label'),\n",
              "    disable_shuffling=False,\n",
              "    splits={\n",
              "        'test': <SplitInfo num_examples=10000, num_shards=1>,\n",
              "        'train': <SplitInfo num_examples=50000, num_shards=1>,\n",
              "    },\n",
              "    citation=\"\"\"@TECHREPORT{Krizhevsky09learningmultiple,\n",
              "        author = {Alex Krizhevsky},\n",
              "        title = {Learning multiple layers of features from tiny images},\n",
              "        institution = {},\n",
              "        year = {2009}\n",
              "    }\"\"\",\n",
              ")"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ds_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "()\n",
            "<dtype: 'string'>\n",
            "\n",
            "\n",
            "(32, 32, 3)\n",
            "<dtype: 'uint8'>\n",
            "\n",
            "\n",
            "()\n",
            "<dtype: 'int64'>\n",
            "10\n",
            "['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n"
          ]
        }
      ],
      "source": [
        "# id \n",
        "print(ds_info.features[\"id\"].shape)\n",
        "print(ds_info.features[\"id\"].dtype)\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "# image\n",
        "print(ds_info.features[\"image\"].shape)\n",
        "print(ds_info.features[\"image\"].dtype)\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "# label\n",
        "print(ds_info.features[\"label\"].shape)\n",
        "print(ds_info.features[\"label\"].dtype)\n",
        "print(ds_info.features[\"label\"].num_classes)\n",
        "print(ds_info.features[\"label\"].names)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Train and Test Dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['train', 'test']\n",
            "\n",
            "\n",
            "50000\n",
            "['cifar10-train.tfrecord-00000-of-00001']\n",
            "1\n",
            "\n",
            "\n",
            "10000\n",
            "['cifar10-test.tfrecord-00000-of-00001']\n",
            "1\n"
          ]
        }
      ],
      "source": [
        "print(list(ds_info.splits.keys()))\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "# Train DS\n",
        "print(ds_info.splits[\"train\"].num_examples)\n",
        "print(ds_info.splits[\"train\"].filenames)\n",
        "print(ds_info.splits[\"train\"].num_shards)\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "# Test DS\n",
        "print(ds_info.splits[\"test\"].num_examples)\n",
        "print(ds_info.splits[\"test\"].filenames)\n",
        "print(ds_info.splits[\"test\"].num_shards)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Visualize**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x432 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig = tfds.show_examples(ds_train, ds_info, rows=2, cols=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Data Pipeline**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [],
      "source": [
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "BATCH = 64\n",
        "EPOCHS = 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(64, 32, 32, 3)\n",
            "(64,)\n"
          ]
        }
      ],
      "source": [
        "for image_batch, labels_batch in ds_train:\n",
        "  print(image_batch.shape)\n",
        "  print(labels_batch.shape)\n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {},
      "outputs": [],
      "source": [
        "# This will save some operations (like file opening and data reading) from being executed during each epoch.\n",
        "ds_train = ds_train.cache()\n",
        "\n",
        "# Fills a buffer with buffer size elements, then randomly samples elements from this buffer, \n",
        "# replacing the selected elements with new elements. For perfect shuffling, \n",
        "# a buffer size greater than or equal to the full size of the dataset is required.\n",
        "ds_train = ds_train.shuffle(ds_info.splits['train'].num_examples)\n",
        "\n",
        "# Pulls data in batches rather than all at once.\n",
        "ds_train = ds_train.batch(BATCH)\n",
        "\n",
        "# While the model is executing training step s, the input pipeline is reading the data for step s+1.\n",
        "# AUTOTUNE will automatically decide the value. \n",
        "ds_train = ds_train.prefetch(AUTOTUNE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {},
      "outputs": [],
      "source": [
        "ds_test = ds_test.batch(BATCH)\n",
        "ds_test = ds_test.cache()\n",
        "ds_test = ds_test.prefetch(AUTOTUNE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Input Shape**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(32, 32, 3)"
            ]
          },
          "execution_count": 75,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "input_shape = ds_info.features['image'].shape\n",
        "input_shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {},
      "outputs": [],
      "source": [
        "from keras import layers, activations\n",
        "\n",
        "# Input Layer\n",
        "inputs = keras.Input(shape=(input_shape))\n",
        "\n",
        "# Normalization Layer\n",
        "x = layers.Rescaling(1.0/255.0)(inputs)\n",
        "\n",
        "# CONV2D layer.\n",
        "# padding=same keeps the original data padding\n",
        "x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", activation=activations.relu)(x)\n",
        "x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", activation=activations.relu)(x)\n",
        "\n",
        "# Maxpool Layer\n",
        "# padding=valid tries to reduce the dimension\n",
        "x = layers.MaxPool2D(pool_size=(2, 2), strides=2, padding=\"valid\")(x)\n",
        "\n",
        "# Dropout Layer\n",
        "x = layers.Dropout(0.5)(x)\n",
        "\n",
        "# Flatten Layer\n",
        "x = layers.Flatten()(x)\n",
        "\n",
        "# Dense Layer\n",
        "x = layers.Dense(units=128, activation=activations.relu)(x)\n",
        "\n",
        "# Output Layer\n",
        "outputs = layers.Dense(units=10, activation=activations.softmax)(x)\n",
        "\n",
        "model = keras.Model(inputs=inputs, outputs=[outputs], name=\"cifar10_model\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Summary**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"cifar10_model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_7 (InputLayer)        [(None, 32, 32, 3)]       0         \n",
            "                                                                 \n",
            " rescaling_6 (Rescaling)     (None, 32, 32, 3)         0         \n",
            "                                                                 \n",
            " conv2d_14 (Conv2D)          (None, 32, 32, 32)        896       \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 32, 32, 32)        9248      \n",
            "                                                                 \n",
            " max_pooling2d_7 (MaxPooling  (None, 16, 16, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_7 (Dropout)         (None, 16, 16, 32)        0         \n",
            "                                                                 \n",
            " flatten_7 (Flatten)         (None, 8192)              0         \n",
            "                                                                 \n",
            " dense_14 (Dense)            (None, 128)               1048704   \n",
            "                                                                 \n",
            " dense_15 (Dense)            (None, 10)                1290      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,060,138\n",
            "Trainable params: 1,060,138\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Compile**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "c:\\Users\\sahug\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizer_v2\\adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(Adam, self).__init__(name, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "losses = keras.losses.SparseCategoricalCrossentropy(from_logits=False)\n",
        "optim = keras.optimizers.Adam(lr=0.001)\n",
        "metrics = [keras.metrics.SparseCategoricalAccuracy()]\n",
        "\n",
        "model.compile(loss=losses, optimizer=optim, metrics=metrics)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Tensorboard**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The tensorboard extension is already loaded. To reload it, use:\n",
            "  %reload_ext tensorboard\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Invalid switch - \"logs\".\n"
          ]
        }
      ],
      "source": [
        "%load_ext tensorboard\n",
        "import datetime\n",
        "\n",
        "# Clear any logs from previous runs\n",
        "!del -ff ./logs/cifar10/\n",
        "\n",
        "# Log Dir\n",
        "log_dir = \"logs/cifar10/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "\n",
        "# Callbacks\n",
        "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Train**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "782/782 [==============================] - 135s 170ms/step - loss: 1.4596 - sparse_categorical_accuracy: 0.4749 - val_loss: 1.2646 - val_sparse_categorical_accuracy: 0.5644\n",
            "Epoch 2/5\n",
            "782/782 [==============================] - 152s 194ms/step - loss: 1.1199 - sparse_categorical_accuracy: 0.6040 - val_loss: 1.0351 - val_sparse_categorical_accuracy: 0.6367\n",
            "Epoch 3/5\n",
            "782/782 [==============================] - 135s 172ms/step - loss: 0.9861 - sparse_categorical_accuracy: 0.6546 - val_loss: 0.9792 - val_sparse_categorical_accuracy: 0.6571\n",
            "Epoch 4/5\n",
            "782/782 [==============================] - 120s 153ms/step - loss: 0.8943 - sparse_categorical_accuracy: 0.6856 - val_loss: 0.8939 - val_sparse_categorical_accuracy: 0.6871\n",
            "Epoch 5/5\n",
            "782/782 [==============================] - 110s 141ms/step - loss: 0.8305 - sparse_categorical_accuracy: 0.7078 - val_loss: 0.8931 - val_sparse_categorical_accuracy: 0.6885\n"
          ]
        }
      ],
      "source": [
        "history = model.fit(ds_train,\n",
        "                        epochs=EPOCHS,\n",
        "                        batch_size=64, \n",
        "                        validation_data=ds_test, \n",
        "                        verbose=1, \n",
        "                        callbacks=[tensorboard_callback])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**View Tensorboard**\n",
        "\n",
        "http://localhost:6006/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "      <iframe id=\"tensorboard-frame-74fa312d64a7f2f9\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
              "      </iframe>\n",
              "      <script>\n",
              "        (function() {\n",
              "          const frame = document.getElementById(\"tensorboard-frame-74fa312d64a7f2f9\");\n",
              "          const url = new URL(\"/\", window.location);\n",
              "          const port = 6006;\n",
              "          if (port) {\n",
              "            url.port = port;\n",
              "          }\n",
              "          frame.src = url;\n",
              "        })();\n",
              "      </script>\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "%tensorboard --logdir logs/fit/cifar10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Learning Visualiization**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {},
      "outputs": [],
      "source": [
        "epoch_range = range(1, 6)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot training and validation accuracy values\n",
        "# sparse_categorical_accuracy vs val_sparse_categorical_accuracy\n",
        "plt.plot(epoch_range, history.history[\"sparse_categorical_accuracy\"])\n",
        "plt.plot(epoch_range, history.history[\"val_sparse_categorical_accuracy\"])\n",
        "plt.title(\"Model Accuracy\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.legend([\"Train\", \"Val\"], loc=\"upper left\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot training and validation loss values\n",
        "# Loss vs Val_Loss\n",
        "plt.plot(epoch_range, history.history[\"loss\"])\n",
        "plt.plot(epoch_range, history.history[\"val_loss\"])\n",
        "plt.title(\"Model Loss\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.legend([\"Train\", \"Val\"], loc=\"upper left\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Approach 2**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pZJpjqOh4w5a"
      },
      "outputs": [],
      "source": [
        "from keras.datasets import cifar10\n",
        "from keras import Sequential\n",
        "from keras.layers import Flatten, Dense, Conv2D, MaxPool2D, Dropout\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib\n",
        "%matplotlib inline\n",
        "\n",
        "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
        "\n",
        "classes_name = [\"Airplane\", \"Automobile\", \"Bird\", \"Cat\", \"Deer\", \"Dog\", \"Frog\", \"Horse\", \"Ship\", \"Truck\"]\n",
        "\n",
        "# Since Neural Network understand the data between **0 to 1**. Brininging our data in the range **0 to 1**. \n",
        "# To do this we will simply divide the given data with the maximum value.\n",
        "x_train = x_train/x_train.max()\n",
        "x_test = x_test/x_train.max()\n",
        "\n",
        "x_train.shape, x_test.shape\n",
        "\n",
        "# x_train gives (50000, 32, 32, 3) - 50000 data, 32 x 32 bits, height and width, 3 is rgb, color.\n",
        "# x_test gives (10000, 32, 32, 3) - 10000 data, 32 x 32 bits, height and width, 3 is rgb, color.\n",
        "\n",
        "plt.imshow(x_test[0].astype(\"uint8\")) \n",
        "\n",
        "model = Sequential()\n",
        "\n",
        "# Only first layer needs input size\n",
        "model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", activation=\"relu\", input_shape=[32, 32, 3])) # Same keeps the original data padding\n",
        "\n",
        "model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n",
        "\n",
        "model.add(MaxPool2D(pool_size=(2, 2), strides=2, padding=\"valid\")) # Valid tries to reduce the dimension\n",
        "\n",
        "# Dropout helps to avid the overfitting of the mode. Here we are dropping 50% of the input at this layer.\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "model.add(Flatten())\n",
        "\n",
        "model.add(Dense(units=128, activation=\"relu\"))\n",
        "\n",
        "# Output layer. Unit is the size of the different output. Here we have 10 different outcomes.\n",
        "model.add(Dense(units=10, activation=\"softmax\"))\n",
        "\n",
        "model.compile(optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"sparse_categorical_accuracy\"])\n",
        "\n",
        "history = model.fit(x_train, y_train, batch_size=10, epochs=10, verbose=1, validation_data=(x_test, y_test))\n",
        "\n",
        "# In the above training we can see the validation accuracy is lesser than the accuracy. \n",
        "# This means our model is **overfitting**. Also, if the validation accuracy is higher than the accuracy its \n",
        "# called **underfitting**. So lets look at the point where it started overfillting by plotting the graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot training and validation accuracy values\n",
        "# sparse_categorical_accuracy vs val_sparse_categorical_accuracy\n",
        "epoch_range = range(1, 11) # No of Epochs used to train. 11 - 1 = 10\n",
        "plt.plot(epoch_range, history.history[\"sparse_categorical_accuracy\"])\n",
        "plt.plot(epoch_range, history.history[\"val_sparse_categorical_accuracy\"])\n",
        "plt.title(\"Model Accuracy\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.legend([\"Train\", \"Val\"], loc=\"upper left\")\n",
        "plt.show()\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot training and validation loss values\n",
        "# Loss vs Val_Loss\n",
        "plt.plot(epoch_range, history.history[\"loss\"])\n",
        "plt.plot(epoch_range, history.history[\"val_loss\"])\n",
        "plt.title(\"Model Loss\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.legend([\"Train\", \"Val\"], loc=\"upper left\")\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyOdTgFp8LQ0oQc2oHvCvUIf",
      "include_colab_link": true,
      "name": "Tensorflow - 2D CNN CIFAC10 Image Classifier.ipynb",
      "provenance": []
    },
    "interpreter": {
      "hash": "0d7fd96aeadd740978789f2880dd43822d8681a39e327029c33ff72656207c4b"
    },
    "kernelspec": {
      "display_name": "Python 3.10.4 64-bit",
      "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.10.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}