C1W4_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GC7zSrbOWiz0"
   },
   "source": [
    "# Week 4 Assignment: Create a VGG network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, you will build a class that implements a [VGG network](https://towardsdatascience.com/vgg-neural-networks-the-next-step-after-alexnet-3f91fa9ffe2c) that can be trained to classify images. The model will look something like this:\n",
    "\n",
    "<img src='VGG.png'>\n",
    "\n",
    "It is primarily made up of a series of Conv2D layers followed by a softmax activated layers to classify the image. As you can see, this will be a handful and the code will look huge if you specify each layer individually. As shown in the lectures, you can instead use model subclassing to build complex architectures. You can encapsulate repeating parts of a network then reuse that code when building the final model. You will get to practice that in this exercise. Let's get started!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Z01I5nj0NAOu"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "import utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create named-variables dynamically\n",
    "\n",
    "In this assignment, you will see the use of the Python function `vars()`.  This will allow you to use a for loop to define and set multiple variables with a similar name, such as var1, var2, var3.  \n",
    "\n",
    "Please go through the following examples to get familiar with `vars()`, as you will use it when building the VGG model.\n",
    "- You'll start by defining a class `MyClass`\n",
    "- It contains one variable `var1`.  \n",
    "- Create an object of type `MyClass`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a small class MyClass\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        # One class variable 'a' is set to 1\n",
    "        self.var1 = 1\n",
    "\n",
    "# Create an object of type MyClass()\n",
    "my_obj = MyClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python classes have an attribute called `__dict__`.\n",
    "- `__dict__` is a Python dictionary that contains the object's instance variables and values as key value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_obj.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you call `vars()` and pass in an object, it will call the object's `__dict__` attribute, which is a Python dictionary containing the object's instance variables and their values as ke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(my_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may be familiar with adding new variable like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1, 'var2': 2}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add a new instance variable and give it a value\n",
    "my_obj.var2 = 2\n",
    "\n",
    "# Calls vars() again to see the object's instance variables\n",
    "vars(my_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another way that you can add an instance variable to an object, using `vars()`.\n",
    "- Retrieve the Python dictionary `__dict__` of the object using vars(my_obj).\n",
    "- Modify this `__dict__` dictionary using square bracket notation and passing in the variable's name as a string: `['var3'] = 3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1, 'var2': 2, 'var3': 3}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call vars, passing in the object.  Then access the __dict__ dictionary using square brackets\n",
    "vars(my_obj)['var3'] = 3\n",
    "\n",
    "# Call vars() to see the object's instance variables\n",
    "vars(my_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Why this is helpful!\n",
    "You may be wondering why you would need another way to access an object's instance variables.  \n",
    "- Notice that when using `vars()`, you can now pass in the name of the variable `var3` as a string.\n",
    "- What if you plan to use several variables that are similarly named (`var4`, `var5` ... `var9`) and wanted a convenient way to access them by incrementing a number?\n",
    "\n",
    "Try this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1,\n",
       " 'var2': 2,\n",
       " 'var3': 3,\n",
       " 'var4': 0,\n",
       " 'var5': 0,\n",
       " 'var6': 0,\n",
       " 'var7': 0,\n",
       " 'var8': 0,\n",
       " 'var9': 0}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use a for loop to increment the index 'i'\n",
    "for i in range(4,10):\n",
    "    # Format a string that is var\n",
    "    vars(my_obj)[f'var{i}'] = 0\n",
    "    \n",
    "# View the object's instance variables!\n",
    "vars(my_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are couple equivalent ways in Python to format a string.  Here are two of those ways:\n",
    "- f-string: f\"var{i}\"\n",
    "- .format: \"var{}\".format(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1\n",
      "var2\n"
     ]
    }
   ],
   "source": [
    "# Format a string using f-string notation\n",
    "i=1\n",
    "print(f\"var{i}\")\n",
    "\n",
    "# Format a string using .format notation\n",
    "i=2\n",
    "print(\"var{}\".format(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the variables of a class inside the class definition using `vars(self)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'var1': 1}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a small class MyClass\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        # Use vars(self) to access the class's dictionary of variables\n",
    "        vars(self)['var1'] = 1\n",
    "\n",
    "# Create an object of type MyClass()\n",
    "my_obj = MyClass()\n",
    "vars(my_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll see this in the upcoming code.  Now you'll start building the VGG network!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k1T1UMw5YAkp"
   },
   "source": [
    "## Create a generic VGG block (TODO)\n",
    "\n",
    "The VGG Network has blocks of layers, where each block has a varied number of layers.\n",
    "- In order to create blocks of layers that have a customizable number of conv2D layers, you'll define a class `Block`, which can generate a customizable block of layers \n",
    "\n",
    "\n",
    "### `__init__`\n",
    "In the constructor `__init__`, store the conv2D parameters and also define the number of conv2D layers using the parameters passed into `__init__`.\n",
    "- Store the filters, kernel_size, and repetitions as class variables so that they can be used later in the `call` function.\n",
    "- Using a for loop, define a number of Conv2D [Conv2D](https://keras.io/api/layers/convolution_layers/convolution2d/) layers, based on the number of `repetitions` desired for this block.\n",
    "    - You can define each conv2D layer using `vars` and string formatting to create conv2D_0, conv2D_1, conv2D_3 etc.\n",
    "    - Set these four parameters of Conv2D:\n",
    "        - filters\n",
    "        - kernel_size\n",
    "        - activation: set this to 'relu'\n",
    "        - padding: set this to 'same' (default pading is 'valid').\n",
    "        \n",
    "- Define the [MaxPool2D](https://keras.io/api/layers/pooling_layers/max_pooling2d/) layer that follows these Conv2D layers. \n",
    "    - Set the following parameters for MaxPool2D:\n",
    "        - pool_size: this will be a tuple with two values.\n",
    "        - strides: this will also be a tuple with two values.\n",
    "\n",
    "### `call`\n",
    "In `call`, you will connect the layers together.\n",
    "- The 0-th conv2D layer, `conv2D_0`, immediately follows the `inputs`.\n",
    "- For conv2D layers 1,2 and onward, you can use a for loop to connect conv2D_1 to conv2D_0, and connect conv2D_2 to conv2D_1, and so on.\n",
    "- After connecting all of the conv2D_i layers, add connect the max_pool layer and return the max_pool layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='VGG.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "WGJGaxVjM00W",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7f19295d8925e1d2e60eefd42a6b4dd8",
     "grade": false,
     "grade_id": "cell-1449db9892707876",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "## Please uncomment all lines in this cell and replace those marked with `# YOUR CODE HERE`.\n",
    "## You can select all lines in this code cell with Ctrl+A (Windows/Linux) or Cmd+A (Mac), then press Ctrl+/ (Windows/Linux) or Cmd+/ (Mac) to uncomment.\n",
    "\n",
    "class Block(tf.keras.Model):\n",
    "    def __init__(self, filters, kernel_size, repetitions, pool_size=2, strides=2):\n",
    "        super(Block, self).__init__()\n",
    "        self.filters = filters\n",
    "        self.kernel_size = kernel_size\n",
    "        self.repetitions = repetitions\n",
    "        \n",
    "        # Define a conv2D_0, conv2D_1, etc based on the number of repetitions\n",
    "        for i in range(self.repetitions):        \n",
    "            # Define a Conv2D layer, specifying filters, kernel_size, activation and padding.\n",
    "            vars(self)[f'conv2D_{i}'] = tf.keras.layers.Conv2D(\n",
    "                                                        filters= self.filters,\n",
    "                                                        kernel_size = self.kernel_size,\n",
    "                                                        padding= 'same',\n",
    "                                                        activation='relu')\n",
    "        \n",
    "        # Define the max pool layer that will be added after the Conv2D blocks\n",
    "        self.max_pool = tf.keras.layers.MaxPooling2D(\n",
    "            pool_size= pool_size , strides =strides ) # can be integers \n",
    "  \n",
    "    def call(self, inputs):\n",
    "        # access the class's conv2D_0 layer\n",
    "        conv2D_0 =  vars(self)['conv2D_0']\n",
    "        \n",
    "        # Connect the conv2D_0 layer to inputs\n",
    "        x = conv2D_0(inputs)\n",
    "\n",
    "        # for the remaining conv2D_i layers from 1 to `repetitions` they will be connected to the previous layer\n",
    "        for i in range(1,self.repetitions):\n",
    "            # access conv2D_i by formatting the integer `i`. (hint: check how these were saved using `vars()` earlier)\n",
    "            conv2D_i = vars(self)[f'conv2D_{i}']\n",
    "            \n",
    "            # Use the conv2D_i and connect it to the previous layer\n",
    "            x = conv2D_i(x)\n",
    "\n",
    "        # Finally, add the max_pool layer\n",
    "        max_pool = self.max_pool(x)\n",
    "        \n",
    "        return max_pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4027611c9615b1f518a95d76a81bc8d1",
     "grade": true,
     "grade_id": "cell-2911e521bce8793b",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All public tests passed\n"
     ]
    }
   ],
   "source": [
    "utils.test_block_class(Block)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "peM2GP6uYT0U"
   },
   "source": [
    "## Create the Custom VGG network (TODO)\n",
    "This model stack has a series of VGG blocks, which can be created using the `Block` class that you defined earlier.\n",
    "\n",
    "### `__init__`\n",
    "- Recall that the `__init__` constructor of `Block` takes several function parameters, \n",
    "    - filters, kernel_size, repetitions: you'll set these.\n",
    "    - kernel_size and strides: you can use the default values.\n",
    "- For blocks a through e, build the blocks according to the following specifications:\n",
    "- block_a: 64  filters, kernel_size 3, repetitions 2\n",
    "- block_b: 128 filters, kernel_size 3, repetitions 2\n",
    "- block_c: 256 filters, kernel_size 3, repetitions 3\n",
    "- block_d: 512 filters, kernel_size 3, repetitions 3\n",
    "- block_e: 512 filters, kernel_size 3, repetitions 3\n",
    "\n",
    "After block 'e', add the following layers:\n",
    "- flatten: use [Flatten](https://keras.io/api/layers/reshaping_layers/flatten/).\n",
    "- fc: create a fully connected layer using [Dense](https://keras.io/api/layers/core_layers/dense/).  Give this 256 units, and a `'relu'` activation.\n",
    "- classifier: create the classifier using a Dense layer.  The number of units equals the number of classes.  For multi-class classification, use a `'softmax'` activation.\n",
    "\n",
    "### `call`\n",
    "Connect these layers together using the functional API syntax:\n",
    "- inputs\n",
    "- block_a\n",
    "- block_b\n",
    "- block_c\n",
    "- block_d\n",
    "- block_e\n",
    "- flatten\n",
    "- fc\n",
    "- classifier\n",
    "\n",
    "Return the classifier layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "yD-paeGiNGvz",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "523346a38f53bc31e080114e98e8eca6",
     "grade": false,
     "grade_id": "cell-d9e90af0898eb47f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "## Please uncomment all lines in this cell and replace those marked with `# YOUR CODE HERE`.\n",
    "## You can select all lines in this code cell with Ctrl+A (Windows/Linux) or Cmd+A (Mac), then press Ctrl+/ (Windows/Linux) or Cmd+/ (Mac) to uncomment.\n",
    "\n",
    "\n",
    "\n",
    "class MyVGG(tf.keras.Model):\n",
    "\n",
    "    def __init__(self, num_classes):\n",
    "        super(MyVGG, self).__init__()\n",
    "\n",
    "        # Creating blocks of VGG with the following \n",
    "        # (filters, kernel_size, repetitions) configurations\n",
    "        self.block_a = Block( filters = 64, kernel_size=3, repetitions=2)\n",
    "        self.block_b = Block( filters = 128, kernel_size=3, repetitions=2)\n",
    "        self.block_c = Block( filters = 256, kernel_size=3, repetitions=3)\n",
    "        self.block_d = Block( filters = 512, kernel_size=3, repetitions=3)\n",
    "        self.block_e = Block( filters = 512, kernel_size=3, repetitions=3)\n",
    "\n",
    "        # Classification head\n",
    "        # Define a Flatten layer\n",
    "        self.flatten = tf.keras.layers.Flatten()\n",
    "        # Create a Dense layer with 256 units and ReLU as the activation function\n",
    "        self.fc = tf.keras.layers.Dense(units=256, activation='relu')\n",
    "        # Finally add the softmax classifier using a Dense layer\n",
    "        self.classifier = tf.keras.layers.Dense(units=num_classes, activation='softmax')\n",
    "\n",
    "    def call(self, inputs):\n",
    "        # Chain all the layers one after the other\n",
    "        x = self.block_a(inputs)\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",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c72733dcd5baccf2728b5b2460caf515",
     "grade": true,
     "grade_id": "cell-559ac19437f4f2b2",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All public tests passed\n"
     ]
    }
   ],
   "source": [
    "utils.test_myvgg_class(MyVGG, Block)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load data and train the VGG network (Optional)\n",
    "\n",
    "If you passed all tests above, then you've successfully built the model for your image classifier. Congratulations! The next steps in the pipeline will be loading the dataset and training your VGG network.\n",
    "\n",
    "- The code is shown below but it is only for reference and is **not required to complete the assignment**.\n",
    "- You can submit your work before starting the training.\n",
    "\n",
    "We did not enable an accelerator in this lab environment so training will run slow. If you want to make it quicker, one way is to download your notebook (`File -> Download As -> Notebook`), then upload to [Colab](https://colab.research.google.com). From there, you can use a GPU runtime (`Runtime -> Change Runtime type`) prior to running the cells. Just make sure to comment out the imports and calls to `utils.py` so you don't get `File Not Found` errors. Again, this part is only for reference and is not required for grading. For this lab, we will only grade how you built your model using subclassing. You will get to training and evaluating your models in the next courses of this Specialization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MaF763OKNJxU"
   },
   "outputs": [],
   "source": [
    "dataset = tfds.load('cats_vs_dogs', split=tfds.Split.TRAIN, data_dir='data/')\n",
    "\n",
    "# Initialize VGG with the number of classes \n",
    "vgg = MyVGG(num_classes=2)\n",
    "\n",
    "# Compile with losses and metrics\n",
    "vgg.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "# Define preprocessing function\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",
    "\n",
    "# Apply transformations to dataset\n",
    "dataset = dataset.map(preprocess).batch(32)\n",
    "\n",
    "# Train the custom VGG model\n",
    "# vgg.fit(dataset, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    }
   ],
   "source": [
    "# Train the custom VGG model\n",
    "vgg.fit(dataset, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "ExerciseAnswer.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}