3_training_miniVGGnet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "premium",
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "AIM: To train MiniVGGNet model from scratch."
      ],
      "metadata": {
        "id": "d9cc5Mn-WR2K"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TB7SxHDsUD2w"
      },
      "outputs": [],
      "source": [
        "# Note: Comment or delete the current code block if dataset is loaded from local disk.\n",
        "# loading dataset from kaggle\n",
        "# upload kaggle.json file\n",
        "! pip install -q kaggle\n",
        "from google.colab import files\n",
        "print(\"Upload 'kaggle.json' file...\")\n",
        "files.upload()\n",
        "\n",
        "# download the dataset(zipped folder) and unzip it\n",
        "! mkdir ~/.kaggle\n",
        "! cp kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json\n",
        "! kaggle datasets download alessiocorrado99/animals10\n",
        "! unzip animals10.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Note: Load the class files into current working directory.\n",
        "# importing required libraries\n",
        "from tensorflow.keras.utils import image_dataset_from_directory\n",
        "import tensorflow as tf\n",
        "\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "\n",
        "from imutils import paths\n",
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "\n",
        "import minivggnet # class file\n",
        "import helper_functions # class file"
      ],
      "metadata": {
        "id": "OTJGpCW0UKgb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# defining image size and batch size\n",
        "batch_size=64\n",
        "image_width=224\n",
        "image_height=224"
      ],
      "metadata": {
        "id": "jXiUug4QUvxi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# getting output class labels and calculating class weight\n",
        "class_labels = sorted(os.listdir('raw-img')) # get class labels\n",
        "print('\\nClass Labels: {}'.format(class_labels))\n",
        "num_classes = len(class_labels) # get number of output classes\n",
        "print('\\nNumber of Classes: {}'.format(num_classes))\n",
        "\n",
        "# calculating total elements in each class\n",
        "class_totals = [len(os.listdir('raw-img' + f\"/{label}\")) for label in class_labels]\n",
        "print(\"\\nTotal Elements in Each Class : {}\".format(class_totals))\n",
        "\n",
        "# calculate class weight\n",
        "class_weight = {i:round((max(class_totals) / class_total), 3) for i, class_total in enumerate(class_totals)}\n",
        "print('\\nClass Weight: {}'.format(class_weight))"
      ],
      "metadata": {
        "id": "S8lpw1wdQdwz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67764236-200a-41d7-c0f3-5d14304a372e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Class Labels: ['cane', 'cavallo', 'elefante', 'farfalla', 'gallina', 'gatto', 'mucca', 'pecora', 'ragno', 'scoiattolo']\n",
            "\n",
            "Number of Classes: 10\n",
            "\n",
            "Total Elements in Each Class : [4863, 2623, 1446, 2112, 3098, 1668, 1866, 1820, 4821, 1862]\n",
            "\n",
            "Class Weight: {0: 1.0, 1: 1.854, 2: 3.363, 3: 2.303, 4: 1.57, 5: 2.915, 6: 2.606, 7: 2.672, 8: 1.009, 9: 2.612}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get image paths and move them into train and validation directories\n",
        "imagePaths = list(paths.list_images(\"raw-img\")) # getting path to the directory of images\n",
        "print('Processing...')\n",
        "helper_functions.move_images(imagePaths=imagePaths) # calling function\n",
        "print('Completed...')"
      ],
      "metadata": {
        "id": "36HmMKLuVfDX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bc06080-e43e-4cd6-e5fc-1fc25cce68d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processing...\n",
            "Completed...\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get training dataset\n",
        "train_ds = image_dataset_from_directory(\n",
        "  \"train_dir/\", label_mode='categorical', seed=42, shuffle=True,\n",
        "  image_size=(image_height, image_width),\n",
        "  batch_size=batch_size)\n",
        "\n",
        "# get validation dataset\n",
        "val_ds = image_dataset_from_directory(\n",
        "  \"valid_dir/\", label_mode='categorical', seed=42, shuffle=True,\n",
        "  image_size=(image_height, image_width),\n",
        "  batch_size=batch_size)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5mnkH8bNUyNp",
        "outputId": "9cde4a36-3b68-4dea-e17b-7823564932b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 18325 files belonging to 10 classes.\n",
            "Found 7854 files belonging to 10 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# using buffered prefetching\n",
        "shuffle_size = len(train_ds) # shuffles entire train dataset at each epoch\n",
        "\n",
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "train_ds = train_ds.cache().shuffle(shuffle_size).prefetch(buffer_size=AUTOTUNE)\n",
        "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)"
      ],
      "metadata": {
        "id": "mpOT6QyjWZ_z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Model:**\n",
        "\n",
        "      INPUT => (CONV => RELU => CONV => RELU => POOL)*2 => FC => RELU => FC => SOFTMAX\n",
        "\n",
        "Observations:\n",
        "\n",
        "\n",
        "\n",
        "1.   Trainable parameters: 102,833,066.\n",
        "2.   Model is performing poorly on validation dataset.\n",
        "\n",
        "\n",
        "\n",
        "      "
      ],
      "metadata": {
        "id": "fz9dgInaYj3B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# defining model architecture, subsequent training, and plotting graphs\n",
        "# building the model\n",
        "model = minivggnet.MiniVGGNet.build(width=image_width, height=image_height, depth=3,\n",
        "                                classes=num_classes)\n",
        "\n",
        "# compiling and summarizing the model\n",
        "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),\n",
        "              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False),\n",
        "              metrics=['accuracy'])\n",
        "print('Model Summary...')\n",
        "model.summary()\n",
        "\n",
        "# defining callback - checkpoint\n",
        "checkpoint = ModelCheckpoint('Models/MiniVGGNet_Basic/minivggnet_basic_{epoch:02d}_{val_loss:.3f}.h5', monitor='val_loss', \n",
        "                             mode='min', verbose=0, save_freq='epoch')\n",
        "# total epochs\n",
        "epochs = 15 \n",
        "\n",
        "# training the model on defined parameters\n",
        "print('\\n\\nModel Training...')\n",
        "history = model.fit(\n",
        "  train_ds, validation_data=val_ds, class_weight=class_weight, epochs=epochs, verbose=1,\n",
        "  batch_size=batch_size, callbacks=[checkpoint] \n",
        ")\n",
        "\n",
        "# plot accuracy and loss graphs of the trained model\n",
        "print('\\n\\nModel Graphs...')\n",
        "fig = helper_functions.plot_graphs(history=history)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "1eZyrzZGWeEY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "c1704132-8b37-4945-fb98-a5f25c8e3897"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model Summary...\n",
            "Model: \"MiniVGGNet\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " rescaling (Rescaling)       (None, 224, 224, 3)       0         \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 224, 224, 32)      896       \n",
            "                                                                 \n",
            " activation (Activation)     (None, 224, 224, 32)      0         \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 224, 224, 32)     128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 224, 224, 32)      9248      \n",
            "                                                                 \n",
            " activation_1 (Activation)   (None, 224, 224, 32)      0         \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 224, 224, 32)     128       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 112, 112, 32)     0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 112, 112, 32)      0         \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 112, 112, 64)      18496     \n",
            "                                                                 \n",
            " activation_2 (Activation)   (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " batch_normalization_2 (Batc  (None, 112, 112, 64)     256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 112, 112, 64)      36928     \n",
            "                                                                 \n",
            " activation_3 (Activation)   (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " batch_normalization_3 (Batc  (None, 112, 112, 64)     256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 56, 56, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 56, 56, 64)        0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 200704)            0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               102760960 \n",
            "                                                                 \n",
            " activation_4 (Activation)   (None, 512)               0         \n",
            "                                                                 \n",
            " batch_normalization_4 (Batc  (None, 512)              2048      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_2 (Dropout)         (None, 512)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                5130      \n",
            "                                                                 \n",
            " activation_5 (Activation)   (None, 10)                0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 102,834,474\n",
            "Trainable params: 102,833,066\n",
            "Non-trainable params: 1,408\n",
            "_________________________________________________________________\n",
            "\n",
            "\n",
            "Model Training...\n",
            "Epoch 1/15\n",
            "287/287 [==============================] - 129s 352ms/step - loss: 4.1222 - accuracy: 0.3049 - val_loss: 2.6962 - val_accuracy: 0.2050\n",
            "Epoch 2/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 2.8406 - accuracy: 0.4726 - val_loss: 1.5566 - val_accuracy: 0.4859\n",
            "Epoch 3/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 2.3750 - accuracy: 0.5496 - val_loss: 1.4072 - val_accuracy: 0.5339\n",
            "Epoch 4/15\n",
            "287/287 [==============================] - 99s 346ms/step - loss: 1.8168 - accuracy: 0.6498 - val_loss: 3.3373 - val_accuracy: 0.3048\n",
            "Epoch 5/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 1.8280 - accuracy: 0.6480 - val_loss: 2.2276 - val_accuracy: 0.3397\n",
            "Epoch 6/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 1.3414 - accuracy: 0.7311 - val_loss: 2.6843 - val_accuracy: 0.3112\n",
            "Epoch 7/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.7462 - accuracy: 0.8498 - val_loss: 1.2917 - val_accuracy: 0.5987\n",
            "Epoch 8/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.4384 - accuracy: 0.9088 - val_loss: 2.3608 - val_accuracy: 0.3796\n",
            "Epoch 9/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.3285 - accuracy: 0.9335 - val_loss: 1.4270 - val_accuracy: 0.6155\n",
            "Epoch 10/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.2053 - accuracy: 0.9619 - val_loss: 1.5165 - val_accuracy: 0.6182\n",
            "Epoch 11/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.1264 - accuracy: 0.9778 - val_loss: 1.5903 - val_accuracy: 0.6059\n",
            "Epoch 12/15\n",
            "287/287 [==============================] - 99s 345ms/step - loss: 0.0820 - accuracy: 0.9871 - val_loss: 1.6281 - val_accuracy: 0.6282\n",
            "Epoch 13/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 0.0975 - accuracy: 0.9823 - val_loss: 1.7709 - val_accuracy: 0.5974\n",
            "Epoch 14/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 0.0944 - accuracy: 0.9825 - val_loss: 1.6278 - val_accuracy: 0.6128\n",
            "Epoch 15/15\n",
            "287/287 [==============================] - 99s 344ms/step - loss: 0.1167 - accuracy: 0.9768 - val_loss: 1.9489 - val_accuracy: 0.5924\n",
            "\n",
            "\n",
            "Model Graphs...\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Conclusion:**\n",
        "\n",
        "\n",
        "\n",
        "Training from scratch has its own challenges. \n",
        "\n",
        "*   Lot of tweaking of network will be required to arrive at a good result.\n",
        "*   Time and resource consumption is considerably higher compared to using transfer learning.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "STGPb1ehauyL"
      }
    }
  ]
}