VGG_example_on_custom_model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM3lN7JiqMcpBCrkzjfCDPu",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Khaled-Mohammed-Abdelgaber/deep-learning-projects-/blob/main/VGG_example_on_custom_model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Libraries importing"
      ],
      "metadata": {
        "id": "0_L8YpBA1oAW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from keras.layers import *\n",
        "from keras.models import Model\n",
        "import tensorflow_datasets as tfds"
      ],
      "metadata": {
        "id": "BfWezwj1QT4q"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Checking tensorflow version"
      ],
      "metadata": {
        "id": "vsOKpoNv1yc1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4psOYKXwDlIi",
        "outputId": "ff821fc3-f985-4084-ee4e-e73c313b3f84"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab only includes TensorFlow 2.x; %tensorflow_version has no effect.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Building Block class\n",
        "**vars()** its a built in funtion that enable us to access class attributs in form of string and create it also in form of string.\n",
        "this thing will help us to use for loop to make repeated layers without need to excplicity declear it"
      ],
      "metadata": {
        "id": "WcZxBnON14Zk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Block(Model):\n",
        "  def __init__(self, filters, kernel_size, repetition, pool_size=2, strides=2,padding='same'):\n",
        "    super(Block ,self).__init__()\n",
        "\n",
        "    #attributes of class\n",
        "    self.filters = filters\n",
        "    self.repetition = repetition\n",
        "    self.pool_size = pool_size\n",
        "    self.kernel_size = kernel_size\n",
        "    self.strides = strides\n",
        "    self.padding = padding\n",
        "    #convolution layers\n",
        "    for i in range(self.repetition):\n",
        "      vars(self)[f\"Conv2D{i}\"] = Conv2D(self.filters,self.kernel_size,padding=self.padding ,activation = 'relu')\n",
        "\n",
        "    #maxpooling layer\n",
        "    self.max_pooling = MaxPooling2D(pool_size = self.pool_size,strides=self.strides)\n",
        "    \n",
        "\n",
        "  def call(self , input_tensor):\n",
        "    # access the class's conv2D_0 layer\n",
        "    conv0 = vars(self)['Conv2D0']\n",
        "    x = conv0(input_tensor)\n",
        "    for i in range(1,self.repetition):\n",
        "      x = vars(self)[f\"Conv2D{i}\"](x)\n",
        "    max_pooling = self.max_pooling (x)\n",
        "\n",
        "    return max_pooling\n",
        "\n"
      ],
      "metadata": {
        "id": "-Khhd9oZb1wo"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Building VGG model:\n",
        "this model will consist of multiple layers some of them will be **Block** class instance.\n",
        "**Notes:**\n",
        "\n",
        "\n",
        "*   if we want to classify multiple classes we will use **softmax** as activation function of last **Dense** layer and loss function will be **sparse_categorical_crossentropy** \n",
        "*   if we want to classify one class yes or no activation function of last layer should be **sigmoid** and loss function should be **binary_crossentropy** \n",
        "\n"
      ],
      "metadata": {
        "id": "iq0RejSH2qhV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class VGG(Model):\n",
        "  def __init__(self,num_classes):\n",
        "    super(VGG,self).__init__()\n",
        "    self.num_classes = num_classes\n",
        "    self.block_a = Block(64,3,2)\n",
        "    self.block_b = Block(128,3,3)\n",
        "    self.block_c = Block(256,3,3)\n",
        "    self.block_d = Block(512,3,3)\n",
        "    self.block_e = Block(512,3,3)\n",
        "    self.flatten = Flatten()\n",
        "    self.fc = Dense(256,activation = 'relu')\n",
        "    self.classifier = Dense(self.num_classes,activation = 'softmax')\n",
        "  def call(self,input_tensor):\n",
        "    x = self.block_a(input_tensor)\n",
        "    x = self.block_b(x)\n",
        "    x = self.block_c(x)\n",
        "    x = self.block_d(x)\n",
        "    x = self.block_e(x)\n",
        "    x = self.flatten(x)\n",
        "    x = self.fc(x)\n",
        "    return self.classifier(x)\n",
        "\n"
      ],
      "metadata": {
        "id": "-LzeKIKgxrJZ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Datasets loading:\n",
        "this function will be used to load datasets.\n",
        "\n",
        "\n",
        "*   **tf.cast** work as casting of int() or float() but work with tensors. its inputs are\n",
        "*   **map** work as well known map which apply function to datasets\n",
        "*   **.batch()** change the shape\n"
      ],
      "metadata": {
        "id": "H-Uhlpld4ChV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset = tfds.load('cats_vs_dogs', split=tfds.Split.TRAIN, data_dir='data/')\n",
        "def preprocess(features):\n",
        "    # Resize and normalize\n",
        "    image = tf.image.resize(features['image'], (224, 224))\n",
        "    return tf.cast(image, tf.float32) / 255., features['label']\n",
        "dataset = dataset.map(preprocess).batch(32)\n"
      ],
      "metadata": {
        "id": "HdFnHxINnK-8"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dataset"
      ],
      "metadata": {
        "id": "cWgyLmS18MaS",
        "outputId": "6b1df256-ac42-4225-b7fd-797921bb922a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<BatchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dataset"
      ],
      "metadata": {
        "id": "53SIVzFV8GgZ",
        "outputId": "2ac652f7-81f6-4ee5-a132-3b2e36fdd66e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<BatchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = VGG(2)\n",
        "model.compile(optimizer = 'Adam' ,loss = 'sparse_categorical_crossentropy' ,metrics = ['accuracy'])"
      ],
      "metadata": {
        "id": "JWZn87g0xrMR"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(dataset ,epochs = 5)"
      ],
      "metadata": {
        "id": "gh8yYvYrxrPf",
        "outputId": "38d99457-bc54-4961-9ee2-17c4545e7a64",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "727/727 [==============================] - 135s 185ms/step - loss: 0.6610 - accuracy: 0.6186\n",
            "Epoch 2/5\n",
            "727/727 [==============================] - 134s 184ms/step - loss: 0.6377 - accuracy: 0.6417\n",
            "Epoch 3/5\n",
            "727/727 [==============================] - 134s 184ms/step - loss: 0.6211 - accuracy: 0.6588\n",
            "Epoch 4/5\n",
            "727/727 [==============================] - 134s 184ms/step - loss: 0.6092 - accuracy: 0.6674\n",
            "Epoch 5/5\n",
            "727/727 [==============================] - 133s 183ms/step - loss: 0.6000 - accuracy: 0.6750\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f4c3b02b590>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AA3ECySmhWhw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}