Lab7_ConvNet_Architectures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab7_ConvNet_Architectures.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9_efjnXBr7kN"
      },
      "source": [
        "# ConvNet Architectures\n",
        "The purpose of this lab is to teach to design your own ConvNets from scratch (and implement other people's architectures from research papers).\n",
        "\n",
        "If you instead feel like catching up on transfer learning, you can revisit one of the following:\n",
        "- [Lab2](https://github.com/aivclab/dlcourse/blob/master/Lab2_Solution.ipynb), Task 11 (Keras)\n",
        "- [Lab 4 - part 3](https://github.com/aivclab/dlcourse/blob/master/Lab_4_(part3)_PyTorch_Transfer_Learning.ipynb) (PyTorch).\n",
        "\n",
        "**Remember to enable GPU**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jWsWu8S_zCpw"
      },
      "source": [
        "**NOTE:** In case you have trouble running Keras/TensorFlow in Colab, try one of the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pm72GSu1yb6Q"
      },
      "source": [
        "# Try this\n",
        "#!pip install --upgrade tensorflow==1.8.0\n",
        "\n",
        "# ... or this\n",
        "#%tensorflow_version 1.x\n",
        "\n",
        "# Check TensorFlow version\n",
        "#import tensorflow as tf\n",
        "#print(tf.__version__)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FPS1O-4hsuPO"
      },
      "source": [
        "## 1. Download data and train simple ConvNet with Keras\n",
        "First download the CIFAR10 dataset:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nDPpCY5nr6vs"
      },
      "source": [
        "from __future__ import print_function\n",
        "import keras\n",
        "from keras.layers import Input, Conv2D, MaxPooling2D, Dropout, Dense, Flatten\n",
        "from keras.models import Model\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras.datasets import cifar10\n",
        "from keras.optimizers import Adam\n",
        "import numpy as np\n",
        "\n",
        "num_classes = 10\n",
        "\n",
        "# Load the CIFAR10 data.\n",
        "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
        "\n",
        "# Input image dimensions.\n",
        "input_shape = x_train.shape[1:]\n",
        "\n",
        "# Normalize data.\n",
        "x_train = x_train.astype('float32') / 255\n",
        "x_test = x_test.astype('float32') / 255\n",
        "\n",
        "# Subtract pixel mean (zero-center)\n",
        "x_train_mean = np.mean(x_train, axis=0)\n",
        "x_train -= x_train_mean\n",
        "x_test -= x_train_mean\n",
        "\n",
        "print('x_train shape:', x_train.shape)\n",
        "print(x_train.shape[0], 'train samples')\n",
        "print(x_test.shape[0], 'test samples')\n",
        "print('y_train shape:', y_train.shape)\n",
        "\n",
        "# Convert class vectors to binary class matrices.\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0n0Ihg9xOBu"
      },
      "source": [
        "Set up simple ConvNet:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q43HWFfavN3J"
      },
      "source": [
        "inputs = Input(shape=input_shape)\n",
        "\n",
        "# Encoder (convolutional base)\n",
        "x = Conv2D(8, kernel_size=(3, 3), activation='relu')(inputs)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(16, kernel_size=(3, 3), activation='relu')(x)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(32, kernel_size=(3, 3), activation='relu')(x)\n",
        "encoded = Flatten()(x)\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=Adam(),\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cHovxkaWxVeJ"
      },
      "source": [
        "... and train (while training you may want to read ahead on Task 1):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PVc45dFixT-b"
      },
      "source": [
        "batch_size = 32\n",
        "epochs = 4\n",
        "\n",
        "# This will do preprocessing and realtime data augmentation:\n",
        "datagen = ImageDataGenerator(\n",
        "    # set input mean to 0 over the dataset\n",
        "    featurewise_center=False,\n",
        "    # set each sample mean to 0\n",
        "    samplewise_center=False,\n",
        "    # divide inputs by std of dataset\n",
        "    featurewise_std_normalization=False,\n",
        "    # divide each input by its std\n",
        "    samplewise_std_normalization=False,\n",
        "    # apply ZCA whitening\n",
        "    zca_whitening=False,\n",
        "    # epsilon for ZCA whitening\n",
        "    zca_epsilon=1e-06,\n",
        "    # randomly rotate images in the range (deg 0 to 180)\n",
        "    rotation_range=0,\n",
        "    # randomly shift images horizontally\n",
        "    width_shift_range=0.1,\n",
        "    # randomly shift images vertically\n",
        "    height_shift_range=0.1,\n",
        "    # set range for random shear\n",
        "    shear_range=0.,\n",
        "    # set range for random zoom\n",
        "    zoom_range=0.,\n",
        "    # set range for random channel shifts\n",
        "    channel_shift_range=0.,\n",
        "    # set mode for filling points outside the input boundaries\n",
        "    fill_mode='nearest',\n",
        "    # value used for fill_mode = \"constant\"\n",
        "    cval=0.,\n",
        "    # randomly flip images\n",
        "    horizontal_flip=True,\n",
        "    # randomly flip images\n",
        "    vertical_flip=False,\n",
        "    # set rescaling factor (applied before any other transformation)\n",
        "    rescale=None,\n",
        "    # set function that will be applied on each input\n",
        "    preprocessing_function=None,\n",
        "    # image data format, either \"channels_first\" or \"channels_last\"\n",
        "    data_format=None,\n",
        "    # fraction of images reserved for validation (strictly between 0 and 1)\n",
        "    validation_split=0.0)\n",
        "\n",
        "# Compute quantities required for featurewise normalization\n",
        "# (std, mean, and principal components if ZCA whitening is applied).\n",
        "datagen.fit(x_train)\n",
        "\n",
        "# Fit the model on the batches generated by datagen.flow().\n",
        "history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),\n",
        "                    validation_data=(x_test, y_test),\n",
        "                    epochs=epochs, verbose=1, workers=4,shuffle=True)\n",
        "\n",
        "# Score trained model.\n",
        "scores = model.evaluate(x_test, y_test, verbose=1)\n",
        "print('Test loss:', scores[0])\n",
        "print('Test accuracy:', scores[1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ou1ry0kg3B8-"
      },
      "source": [
        "Plot loss and accuracy curves"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gHvYQsFjyRP3"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def show_history(history):\n",
        "  plt.figure(figsize=(20,6))\n",
        "\n",
        "  # summarize history for accuracy\n",
        "  plt.subplot(121)\n",
        "  plt.plot(history.history['accuracy'])\n",
        "  plt.plot(history.history['val_accuracy'])\n",
        "  plt.title('model accuracy')\n",
        "  plt.ylabel('accuracy')\n",
        "  plt.xlabel('epoch')\n",
        "  plt.legend(['train', 'test'], loc='upper left')\n",
        "\n",
        "  # summarize history for loss\n",
        "  plt.subplot(122)\n",
        "  plt.plot(history.history['loss'])\n",
        "  plt.plot(history.history['val_loss'])\n",
        "  plt.title('model loss')\n",
        "  plt.ylabel('loss')\n",
        "  plt.xlabel('epoch')\n",
        "  plt.legend(['train', 'test'], loc='upper left')\n",
        "  plt.show()\n",
        "\n",
        "show_history(history)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0svLoKzu47CK"
      },
      "source": [
        "###Bonus question (not related to today's topic):\n",
        "- Has this network finished training? Why? Why not?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FfZDz-Gy3n-b"
      },
      "source": [
        "##2. Task 1: Write down the network architecture\n",
        "The architecture of AlexNet (including output shapes) can be written in this format (see lecture 7 slides):\n",
        "\n",
        "```\n",
        "[227x227x3] INPUT\n",
        "[55x55x96] CONV1: 96 11x11 filters at stride 4, pad 0\n",
        "[27x27x96] MAX POOL1: 3x3 filters at stride 2\n",
        "[27x27x96] NORM1: Normalization layer\n",
        "[27x27x256] CONV2: 256 5x5 filters at stride 1, pad 2\n",
        "[13x13x256] MAX POOL2: 3x3 filters at stride 2\n",
        "[13x13x256] NORM2: Normalization layer\n",
        "[13x13x384] CONV3: 384 3x3 filters at stride 1, pad 1\n",
        "[13x13x384] CONV4: 384 3x3 filters at stride 1, pad 1\n",
        "[13x13x256] CONV5: 256 3x3 filters at stride 1, pad 1\n",
        "[6x6x256] MAX POOL3: 3x3 filters at stride 2\n",
        "[4096] FC6: 4096 neurons\n",
        "[4096] FC7: 4096 neurons\n",
        "[1000] FC8: 1000 neurons (class scores)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jUOx8lIK4SL5"
      },
      "source": [
        "Using the same format, write down the architecture of the network you just trained (you also need to specify stride and pad):"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CAcSObtv4jNW"
      },
      "source": [
        "\n",
        "```\n",
        "[???] INPUT\n",
        "[???]\n",
        "...\n",
        "```\n",
        "\n",
        "**Need help?**\n",
        "Run this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xr-VVTTEIkRx"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DK7wIOp7mzP"
      },
      "source": [
        "##3. Task 2: Implement simple network architectures\n",
        "###Task 2.1 Padding for preserving shape\n",
        "Padding (or zero-padding) is mostly used when we want the output of a convolution layer to have the same shape is the input.\n",
        "\n",
        "Keras' Conv2D layer does not allow you to specify the padding directly (as an integer). Rather you can chose between `'valid'` and `'same'`. Check the [documentation](https://keras.io/api/layers/convolution_layers/convolution2d/) to see what the difference is. By changing the padding only, modify our model to have the following architecture. \n",
        "\n",
        "Also fill in the `???` (i.e., what is the pad size?):\n",
        "```\n",
        "[32x32x3] INPUT\n",
        "[32x32x8] CONV1: 8 3x3 filters at stride 1, pad 1\n",
        "[16x16x8] MAX POOL1: 2x2 filters at stride 2\n",
        "[16x16x16] CONV2: 16 3x3 filters at stride 1, pad 1\n",
        "[8x8x16] MAX POOL2: 2x2 filters at stride 2\n",
        "[8x8x32] CONV3: 32 3x3 filters at stride 1, pad 1\n",
        "[64] FC1: 64 neurons\n",
        "[10] FC2: 10 neurons (class scores)\n",
        "```\n",
        "Note that the shape is the same before and after each convolution layer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qI6kUuV_8Mhw"
      },
      "source": [
        "# Encoder (convolutional base)\n",
        "x = Conv2D(8, kernel_size=(3, 3), padding=???, activation='relu')(inputs)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(16, kernel_size=(3, 3), padding=???, activation='relu')(x)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(32, kernel_size=(3, 3), padding=???, activation='relu')(x)\n",
        "encoded = Flatten()(x)\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tRe-4VZBffMt"
      },
      "source": [
        "**Note:** It is possible to exactly control zero-padding Keras. See [ZeroPadding2D](https://keras.io/api/layers/reshaping_layers/zero_padding2d/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JGmBgcqcBmxE"
      },
      "source": [
        "###Task 2.2 Stride for downsampling\n",
        "As mentioned in Lecture 6, *max pool* for downsampling is more or less deprecated. Instead, modern network architectures use `stride > 1` in the convolutiton layers for downsampling.\n",
        "\n",
        "Change the stride of the convolution layers to implement the following architecture.\n",
        "\n",
        "Also fill in the `???` (i.e., what is the stride and pad size?):\n",
        "```\n",
        "[32x32x3] INPUT\n",
        "[16x16x8] CONV1: 8 3x3 filters at stride 2, pad 1\n",
        "[8x8x16] CONV2: 16 3x3 filters at stride 2, pad 1\n",
        "[4x4x32] CONV3: 32 3x3 filters at stride 2, pad 1\n",
        "[64] FC1: 64 neurons\n",
        "[10] FC2: 10 neurons (class scores)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NpnBaI-qMBju"
      },
      "source": [
        "Your code goes here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V4a6ZUSMFNc8"
      },
      "source": [
        "# Encoder (convolutional base)\n",
        "x = Conv2D(8, kernel_size=(3, 3), strides=???, padding=???, activation='relu')(inputs)\n",
        "x = Conv2D(16, kernel_size=(3, 3), strides=???, padding=???, activation='relu')(x)\n",
        "x = Conv2D(32, kernel_size=(3, 3), strides=???, padding=???, activation='relu')(x)\n",
        "encoded = Flatten()(x)\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VMyfNVqiI8RQ"
      },
      "source": [
        "###Task 2.3: Batch normalization\n",
        "Always use batch normalization! It reduces the risk of vanishing gradients (i.e., it ensures that we have gradient flow through the whole network) and makes training faster.\n",
        "\n",
        "Batch normalization is performed after convolution, but before activation.\n",
        "\n",
        "To implement the architecture below you will need to separate the ReLU from the convolution layer. That is, instead of\n",
        "\n",
        "```\n",
        "x = Conv2D(16, kernel_size=(3, 3), activation='relu')(x)\n",
        "```\n",
        "\n",
        "write\n",
        "\n",
        "```\n",
        "x = Conv2D(16, kernel_size=(3, 3))(x)\n",
        "x = Activation('relu')(x)\n",
        "```\n",
        "\n",
        "Required documentation:\n",
        "- https://keras.io/activations/\n",
        "- https://keras.io/layers/normalization/\n",
        "\n",
        "Your task is to implement this architecture, where I have written out batch normalization (BN) and ReLU activation explicitly:\n",
        "\n",
        "```\n",
        "[32x32x3] INPUT\n",
        "[16x16x8] CONV1: 8 3x3 filters at stride 2, pad 1\n",
        "[16x16x8] BN1: Batch normalization\n",
        "[16x16x8] ReLU\n",
        "[8x8x16] CONV2: 16 3x3 filters at stride 2, pad 1\n",
        "[8x8x16] BN2: Batch normalization\n",
        "[8x8x16] ReLU\n",
        "[4x4x32] CONV3: 32 3x3 filters at stride 2, pad 1\n",
        "[4x4x32] BN3: Batch normalization\n",
        "[4x4x32] ReLU\n",
        "[64] FC1: 64 neurons\n",
        "[10] FC2: 10 neurons (class scores)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OaFrYzImOWGM"
      },
      "source": [
        "Your code goes here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zxxMAC074cA"
      },
      "source": [
        "from keras.layers import BatchNormalization, Activation\n",
        "\n",
        "# Encoder (convolutional base)\n",
        "# ???\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p5pvJ3vjNTtF"
      },
      "source": [
        "###Task 2.4: Global average pooling\n",
        "Recall that global average pooling takes an NxNxC volume and reduces it to a C-dimensional vector by averaging the NxN valus of each channel (c).\n",
        "\n",
        "Thus, we can replace the `Flatten` layer and the first `Dense` layer (i.e., fully connected layer) with a global average pooling layer.\n",
        "\n",
        "Check the documentation here:\n",
        "https://keras.io/api/layers/pooling_layers/global_average_pooling2d/\n",
        "\n",
        "Your task is to implement the following architecture:\n",
        "\n",
        "```\n",
        "[32x32x3] INPUT\n",
        "[16x16x8] CONV1: 8 3x3 filters at stride 2, pad 1\n",
        "[8x8x16] CONV2: 16 3x3 filters at stride 2, pad 1\n",
        "[4x4x32] CONV3: 32 3x3 filters at stride 2, pad 1\n",
        "[32] GAP: Global average pooling\n",
        "[10] FC2: 10 neurons (class scores)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQheNTTSOsfz"
      },
      "source": [
        "Your code goes here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5sSIJpdNLk4a"
      },
      "source": [
        "from keras.layers import GlobalAveragePooling2D\n",
        "\n",
        "# Encoder (convolutional base)\n",
        "# ???\n",
        "\n",
        "# Decoder (1 fully connected layer)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "seRuB8D_QrAp"
      },
      "source": [
        "**Note** that because we removed a dense layer, the above model looses some of its original capacity, so it might perform worse on the validation set.\n",
        "\n",
        "By inspecting the output of `model.summary()` you can see exactly how many trainable parameters the model has. Compare the number of parameters before and after replacing Flatten with GlobalAveragePooling2D."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7YcyGCORRUXB"
      },
      "source": [
        "###Task 2.6: Variable input size\n",
        "The really cool thing about global average pooling is that it allows the network to handle input images of variable size.\n",
        "\n",
        "Consider the following piece of code (it's supposed to crash...):\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NErawUzCU81q"
      },
      "source": [
        "# Tell Keras that height/width can be arbitrary\n",
        "variable_input_shape = ((None,None,3)) \n",
        "variable_inputs = Input(variable_input_shape)\n",
        "\n",
        "# Encoder (convolutional base)\n",
        "x = Conv2D(8, kernel_size=(3, 3), activation='relu')(variable_inputs)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(16, kernel_size=(3, 3), activation='relu')(x)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(32, kernel_size=(3, 3), activation='relu')(x)\n",
        "encoded = Flatten()(x)\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UyKohUFBbTb4"
      },
      "source": [
        "What goes wrong is that the Flatten layer must know the shape of the input in advance. Now, lets replace it with a global average pooling layer and see what happens:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UAsH3NA1bo3l"
      },
      "source": [
        "# Tell Keras that height/width can be arbitrary\n",
        "variable_input_shape = ((None,None,3)) \n",
        "variable_inputs = Input(variable_input_shape)\n",
        "\n",
        "# Encoder (convolutional base)\n",
        "x = Conv2D(8, kernel_size=(3, 3), activation='relu')(variable_inputs)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(16, kernel_size=(3, 3), activation='relu')(x)\n",
        "x = MaxPooling2D((2, 2))(x)\n",
        "x = Conv2D(32, kernel_size=(3, 3), activation='relu')(x)\n",
        "encoded = GlobalAveragePooling2D()(x)\n",
        "\n",
        "# Decoder (2 fully connected layers)\n",
        "x = Dense(64, activation='relu')(encoded)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(num_classes,activation='softmax')(x)\n",
        "# This creates a callable model that includes the Input layer and the prediction layer\n",
        "\n",
        "model = Model(inputs=variable_inputs, outputs=predictions)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "De6l35Dib-lB"
      },
      "source": [
        "Now, we can run the network on images of arbitrary shape:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NTs3Q-OGRVww"
      },
      "source": [
        "# Make a batch of images that have size 36x36 instead of 32x32\n",
        "import cv2\n",
        "batch = x_train[0:batch_size,:]\n",
        "batch_resized = np.zeros((batch_size,36,36,3))\n",
        "for i in range(batch_size):\n",
        "  batch_resized[i,:,:,:] = cv2.resize(batch[i,:,:,:],(36,36))\n",
        "\n",
        "# Shape 32x32\n",
        "predictions = model.predict(batch)\n",
        "print(predictions.shape)\n",
        "\n",
        "# Shape 36x36\n",
        "predictions = model.predict(batch_resized)\n",
        "print(predictions.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HNcuPRhFdRJO"
      },
      "source": [
        "####Question\n",
        "There is a small caveat, however. The network can only handle input images down to a certain shape (height/width).\n",
        "- Why?\n",
        "- What is the smallest input width/height this model can handle? "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3h5lMG4O3Aw"
      },
      "source": [
        "##Task 3: Implement building blocks of advanced network architectures\n",
        "###Task 3.1 Naive Inception module\n",
        "The simple, naive inception module combines 1x1, 3x3, and 5x5 convolution, as well as max pooling, into a single *layer* or *module*. It does so by concatenating along the channel dimension.\n",
        "\n",
        "Suppose the input to the module (called `x`) has shape `NxNxC`. Then the outputs of the convolutions should be:\n",
        "\n",
        "- `NxNxf1` for `conv1` (1x1 convolution), where `f1` is the number of 1x1 filters.\n",
        "- `NxNxf3` for `conv3` (3x3 convolution), where `f3` is the number of 3x3 filters.\n",
        "- `NxNxf5` for `conv5` (5x5 convolution), where `f5` is the number of 5x5 filters.\n",
        "\n",
        "and the output of the max pooling layer should be\n",
        "\n",
        "- `NxNxC` for `pool` (3x3 max pooling)\n",
        "\n",
        "You can then use Keras' `Concatenate`layer to combine the outputs. The shape of the output should be `NxNx(f1+f3+f5+C)`.\n",
        "\n",
        "Below is a template for implementing and testing a naive inception module. Your task is to fill in the empty gaps. The output should look like this:\n",
        "\n",
        "![alt text](https://github.com/aivclab/dlcourse/blob/master/data/inception_naive.png?raw=true)\n",
        "\n",
        "**NOTE 1** that the `InputLayer` is *not* part of the inception module, and neither is the first `Conv2D` layer. The first `Conv2D` layer just serves to generate an input feature map with a \"nice\" shape, meaning that the dimensions are powers of 2 (in this case `16x16x64`).\n",
        "\n",
        "If you need to consult the documentation, it is here: [Conv2d](https://keras.io/api/layers/convolution_layers/convolution2d/) [MaxPooling2D](https://keras.io/api/layers/pooling_layers/max_pooling2d/).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-2SUTxkeMeQ6"
      },
      "source": [
        "from keras.layers import Concatenate\n",
        "from keras.utils import plot_model\n",
        "\n",
        "# Naive inception module\n",
        "def naive_inception_module(x, f1=64, f3=128, f5=32):\n",
        "  # 1x1 conv\n",
        "  conv1 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  # 3x3 conv\n",
        "  conv3 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  # 5x5 conv\n",
        "  conv5 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  # 3x3 max pooling\n",
        "  pool = MaxPooling2D(pool_size=(3,3), strides=???, padding=???)(x)\n",
        "  # concatenate filters, assumes filters/channels last\n",
        "  y = Concatenate()([conv1, conv3, conv5, pool])\n",
        "\n",
        "  return y\n",
        "\n",
        "# Prior convolution(s) - not part of the inception module:\n",
        "# - inputs has shape 32x32x3\n",
        "# - x has shape 16x16x64 and serves as input to the inception module\n",
        "x = Conv2D(64, kernel_size=(3, 3), strides=2, padding='same',activation='relu')(inputs)\n",
        "\n",
        "# Add inception block 1\n",
        "layer = naive_inception_module(x)\n",
        "\n",
        "# create model\n",
        "model = Model(inputs=inputs, outputs=layer)\n",
        "model.summary()\n",
        "\n",
        "# plot model architecture\n",
        "plot_model(model, show_shapes=True, to_file='inception_module.png')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HoBlh5QjQMX1"
      },
      "source": [
        "The output should look like this:\n",
        "\n",
        "![alt text](https://github.com/aivclab/dlcourse/blob/master/data/inception_naive.png?raw=true)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HJ4U5fdFuvvK"
      },
      "source": [
        "###Question:\n",
        "- What is the number of trainable parameters in the simple model above?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwLjVu5qu_VA"
      },
      "source": [
        "###Task 3.2 Inception module\n",
        "The version of the inception module that we have implemented is called the *naive inception module*. In the original paper, a modification to the module was made in order to reduce the amount of computation required. Specifically, 1×1 convolutional layers were added to reduce the number of filters **before** the 3×3 and 5×5 convolutional layers, and to decrease the number of filters **after** the pooling layer.\n",
        "\n",
        "1×1 convolutions are used to compute reductions **before** the expensive 3×3 and 5×5 convolutions. Besides being used as reductions, they also include the use of rectified linear activation making them dual-purpose. In addition, a 1x1 convolution is added **after** the max pooling layer to reduce dimensionality.\n",
        "\n",
        "Suppose the input to the module (called `x`) has shape `NxNxC`. Then the outputs of the convolutions should be:\n",
        "\n",
        "- `NxNxf1` for `conv1` (1x1 convolution), where `f1` is the number of 1x1 filters.\n",
        "- `NxNxf3_reduce` for `conv3_reduce` (1x1 convolution), where `f3_reduce` is the number of 1x1 filters.\n",
        "- `NxNxf3` for `conv3` (3x3 convolution), where `f3` is the number of 3x3 filters. Note that the input to `conv3` is not `x`, but `conv3_reduce`.\n",
        "- `NxNxf5_reduce` for `conv5_reduce` (1x1 convolution), where `f5_reduce` is the number of 1x1 filters.\n",
        "- `NxNxf5` for `conv5` (5x5 convolution), where `f5` is the number of 5x5 filters. Note that the input to `conv5` is not `x`, but `conv5_reduce`.\n",
        "\n",
        "and the output of the max pooling layer should be\n",
        "\n",
        "- `NxNxC` for `pool` (3x3 max pooling)\n",
        "- `NxNxfpool_reduce` for `pool_reduce` (1x1 convolution), where `fpool_reduce` is the number of 1x1 filters. Note that the input to `pool_reduce` is not `x`, but `pool`.\n",
        "\n",
        "Below is a template for implementing and testing an inception module. Your task is to fill in the empty gaps."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "93xKdv6SyV6B"
      },
      "source": [
        "def inception_module(x, f1=64, f3=128, f5=32, f3_reduce=32, f5_reduce=32, fpool_reduce=32):\n",
        "  # 1x1 conv\n",
        "  conv1 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  # 3x3 conv\n",
        "  conv3_reduce = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  conv3 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(conv3_reduce)\n",
        "  # 5x5 conv\n",
        "  conv5_reduce = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(x)\n",
        "  conv5 = Conv2D(filters=???, kernel_size=???, padding=???, activation='relu')(conv5_reduce)\n",
        "  # 3x3 max pooling\n",
        "  pool = MaxPooling2D(pool_size=(3,3), strides=???, padding='same')(x)\n",
        "  pool_reduce = Conv2D(filters=???, kernel_size=???, padding='same', activation='relu')(pool)\n",
        "  # concatenate filters, assumes filters/channels last\n",
        "  y = Concatenate()([conv1, conv3, conv5, pool_reduce])\n",
        "  return y\n",
        "\n",
        "# Prior convolution(s) - not part of the inception module\n",
        "x = Conv2D(64, kernel_size=(3, 3), strides=2, padding='same',activation='relu')(inputs)\n",
        "\n",
        "# Add inception block\n",
        "layer = inception_module(x)\n",
        "\n",
        "# create model\n",
        "model = Model(inputs=inputs, outputs=layer)\n",
        "model.summary()\n",
        "\n",
        "# plot model architecture\n",
        "plot_model(model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3LEW2YUYRTnu"
      },
      "source": [
        "The output should look like this:\n",
        "\n",
        "![alt text](https://github.com/aivclab/dlcourse/blob/master/data/inception.png?raw=true)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ihty3Ds8yWO8"
      },
      "source": [
        "###Question:\n",
        "- What is the number of trainable parameters in the model above?\n",
        "- What is the shape of the output? Compare to *naive* inception module. Why are there fewer channels?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qm9IN-zzy5EF"
      },
      "source": [
        "###Task 3.3 ResNet block\n",
        "A key innovation in the ResNet paper was the residual block. The residual block, specifically the identity residual block (called **Type 1** in the lecture 7 slides), is a block of two convolutional layers with the same number of filters and a small filter size, where the output of the second layer is added with the input to the first convolutional layer. Drawn as a graph (see below), the input to the module is added to the output of the module and is called a shortcut connection. We can implement this directly in Keras using the Add() layer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j-C_XeytRgMw",
        "outputId": "dbd060f3-750a-45ae-e881-ca93bbb62aa4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 680
        }
      },
      "source": [
        "from keras.layers import Add\n",
        "\n",
        "def residual_module_type1(x, f=64):\n",
        "\t# conv1\n",
        "\tconv1 = Conv2D(f, (3,3), padding='same', activation='relu', kernel_initializer='he_normal')(x)\n",
        "\t# conv2\n",
        "\tconv2 = Conv2D(f, (3,3), padding='same', activation='linear', kernel_initializer='he_normal')(conv1)\n",
        "\t# add filters, assumes conv2 and x have the same shape\n",
        "\ty = Add()([conv2, x])\n",
        "\t# activation function\n",
        "\ty = Activation('relu')(y)\n",
        "\treturn y\n",
        "\n",
        "# Prior convolution(s) - not part of the residual block\n",
        "x = Conv2D(64, kernel_size=(3, 3), strides=2, padding='same',activation='relu')(inputs)\n",
        "\n",
        "# Add residual block\n",
        "layer = residual_module_type1(x)\n",
        "\n",
        "# create model\n",
        "model = Model(inputs=inputs, outputs=layer)\n",
        "\n",
        "# plot model architecture\n",
        "plot_model(model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4479: The name tf.truncated_normal is deprecated. Please use tf.random.truncated_normal instead.\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmYAAAJzCAYAAAClN9+iAAAABmJLR0QA/wD/AP+gvaeTAAAgAElE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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8lEUi1uB1xHv"
      },
      "source": [
        "The **Type 1** block above assumes that input `x` and output `y` have exactly the same shape. If this is not the case, we will get an error.\n",
        "\n",
        "The **Type 2** block serves to\n",
        "- downsample the input by a factor of two (along height and width dimensions)\n",
        "- double the number of channels\n",
        "\n",
        "Thus, if the input shape is `x.shape = N x N x C`, the output shape is `y.shape = N/2 x N/2 x C*2`.\n",
        "\n",
        "In the top figure below, the solid skip connections mark Type 1 blocks (shape preserved), and dashed skip connections mark Type 2 blocks (height/width halfed and channels doubled):\n",
        "\n",
        "![alt text](https://miro.medium.com/max/1372/1*6hF97Upuqg_LdsqWY6n_wg.png)\n",
        "\n",
        "One solution to implementing a Type 2 block is as follows:\n",
        "- `conv1`: Apply convolution on input `x` with a stride of 2 and `padding=same`. This has the effect of reducing the height and width by a factor of 2.\n",
        "- `conv2`: Apply convolution on output of `conv1` with a stride of 1 to preserve height/width.\n",
        "- `x_reshape`: This is the shortcut connection that must assure that `x` is reshaped to half the width/height. This can be done by applying a 1×1 convolution with a stride of 2 (before the addition).\n",
        "\n",
        "Your task is to fill in the blanks here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I-DtxmucRQC1"
      },
      "source": [
        "def residual_module_type2(x, f=64):\n",
        "\t# conv1 (reduces height/width by a factor of two and doubles the number of channels)\n",
        "\tconv1 = Conv2D(2*f, (3,3), strides=2, padding='same', activation='relu', kernel_initializer='he_normal')(x)\n",
        "\t# conv2 (same shape as conv1)\n",
        "\tconv2 = Conv2D(2*f, (3,3), padding='same', activation='linear', kernel_initializer='he_normal')(conv1)\n",
        "  # reshape x (same shape as conv2)\n",
        "\tx_reshape = Conv2D(???,activation='linear')(x)\n",
        "\t# add filters, assumes conv2 and x have the same shape\n",
        "\ty = Add()([conv2, x_reshape])\n",
        "\t# activation function\n",
        "\ty = Activation('relu')(y)\n",
        "\treturn y\n",
        "\n",
        "# Prior convolution(s) - not part of the residual block\n",
        "x = Conv2D(64, kernel_size=(3, 3), strides=2, padding='same',activation='relu')(inputs)\n",
        "\n",
        "# Add residual block\n",
        "layer = residual_module_type2(x)\n",
        "\n",
        "# create model\n",
        "model = Model(inputs=inputs, outputs=layer)\n",
        "model.summary()\n",
        "\n",
        "# plot model architecture\n",
        "plot_model(model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gTDnmjL4Famo"
      },
      "source": [
        "###Task 3.4 Depthwise Separable Convolution\n",
        "Depthwise separable convolution is a depthwise convolution followed by a\n",
        "pointwise convolution as follows:\n",
        "\n",
        "- **Depthwise convolution** is the channel-wise `K × K` spatial convolution. Suppose we have 64 channels, then we will have 64 `K × K` spatial convolutions. In Keras this is implemented using [DepthwiseConv2D](https://keras.io/api/layers/convolution_layers/depthwise_convolution2d/).\n",
        "- **Pointwise convolution** actually is the `1 × 1` convolution to change the dimension to, say 256.\n",
        "\n",
        "Your task is to convert the second convolution below \n",
        "\n",
        "```\n",
        "x = Conv2D(256, kernel_size=(3, 3), activation='relu')(x)\n",
        "```\n",
        "\n",
        "to a depthwis separable convolution. The filter size is `K=3`, the input shape is `30x30x64` and the output shape should be `28x28x256`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q-KHsElQGFkF"
      },
      "source": [
        "x = Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu')(inputs)\n",
        "x = Conv2D(256, kernel_size=(5, 5), padding='same', activation='relu')(x) # Convert this to DSC !!!\n",
        "model = Model(inputs=inputs, outputs=x)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZxtZKLv_WJxA"
      },
      "source": [
        "Your code goes here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kfYlCaOJRlao"
      },
      "source": [
        "from keras.layers import DepthwiseConv2D\n",
        "\n",
        "x = Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu')(inputs)\n",
        "???\n",
        "model = Model(inputs=inputs, outputs=x)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Flh6DmlJnUz"
      },
      "source": [
        "###Questions\n",
        "1. What is the number of parameters before and after converting to depthwise separate convolution (DSC)?\n",
        "2. What is the operation cost with standard convolution vs. DSC (see slides Lecture 7)?"
      ]
    }
  ]
}