Chapter03/ch3_nb4_apply_regularization_methods_to_cnns.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<p style=\"border: 1px solid #e7692c; border-left: 15px solid #e7692c; padding: 10px; text-align:justify;\">\n",
    "    <strong style=\"color: #e7692c\">Tip.</strong> <a style=\"color: #000000;\" href=\"https://nbviewer.jupyter.org/github/PacktPublishing/Hands-On-Computer-Vision-with-TensorFlow-2/blob/master/Chapter03/ch3_nb4_apply_regularization_methods_to_cnns.ipynb\" title=\"View with Jupyter Online\">Click here to view this notebook on <code>nbviewer.jupyter.org</code></a>. \n",
    "    <br/>These notebooks are better read there, as Github default viewer ignores some of the formatting and interactive content.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"font-size: 1em; padding: 0; margin: 0;\">\n",
    "    <tr style=\"vertical-align: top; padding: 0; margin: 0;background-color: #ffffff\">\n",
    "        <td style=\"vertical-align: top; padding: 0; margin: 0; padding-right: 15px;\">\n",
    "    <p style=\"background: #363636; color:#ffffff; text-align:justify; padding: 10px 25px;\">\n",
    "        <strong style=\"font-size: 1.0em;\"><span style=\"font-size: 1.2em;\"><span style=\"color: #e7692c;\">Hands-on</span> Computer Vision with TensorFlow 2</span><br/>by <em>Eliot Andres</em> & <em>Benjamin Planche</em> (Packt Pub.)</strong><br/><br/>\n",
    "        <strong>> Chapter 3: Modern Neural Networks</strong><br/>\n",
    "    </p>\n",
    "\n",
    "<h1 style=\"width: 100%; text-align: left; padding: 0px 25px;\"><small style=\"color: #e7692c;\">Notebook 4:</small><br/>Applying Regularization Methods to CNNs</h1>\n",
    "<br/>\n",
    "<p style=\"border-left: 15px solid #363636; text-align:justify; padding: 0 10px;\">\n",
    "    In this final notebook for Chapter 3, we will demonstrate the effects of the various <strong>regularization methods</strong> we presented in the book, applying them to our simple classification use-case.\n",
    "</p>\n",
    "<br/>\n",
    "<p style=\"border-left: 15px solid #e7692c; padding: 0 10px; text-align:justify;\">\n",
    "    <strong style=\"color: #e7692c;\">Tip.</strong> The notebooks shared on this git repository illustrate some notions from the book \"<em><strong>Hands-on Computer Vision with TensorFlow 2</strong></em>\" written by Eliot Andres and Benjamin Planche, published by Packt. If you enjoyed the insights shared here, <a href=\"https://www.amazon.com/Hands-Computer-Vision-TensorFlow-processing/dp/1788830644\" title=\"Learn more about the book!\"><strong>please consider acquiring the book!</strong></a>\n",
    "<br/><br/>\n",
    "The book provides further guidance for those eager to learn about computer vision and to harness the power of TensorFlow 2 and Keras to build efficient recognition systems for object detection, segmentation, video processing, smartphone applications, and more.</p>\n",
    "        </td>\n",
    "        <td style=\"vertical-align: top; padding: 0; margin: 0; width: 280px;\">\n",
    "    <a href=\"https://www.amazon.com/Hands-Computer-Vision-TensorFlow-processing/dp/1788830644\" title=\"Learn more about the book!\" target=\"_blank\">\n",
    "        <img src=\"../banner_images/book_cover.png\" width=280>\n",
    "    </a>\n",
    "    <p style=\"background: #e7692c; color:#ffffff; padding: 10px; text-align:justify;\"><strong>Leverage deep learning to create powerful image processing apps with TensorFlow 2 and Keras. <br/></strong>Get the book for more insights!</p>\n",
    "    <ul style=\"height: 32px; white-space: nowrap; text-align: center; margin: 0px; padding: 0px; padding-top: 10px;\">\n",
    "    <li style=\"display: block;height: 100%;float: left;vertical-align: middle;margin: 0 25px 10px;padding: 0px;\">\n",
    "        <a href=\"https://www.amazon.com/Hands-Computer-Vision-TensorFlow-processing/dp/1788830644\" title=\"Get the book on Amazon (paperback or Kindle version)!\" target=\"_blank\">\n",
    "        <img style=\"vertical-align: middle; max-width: 72px; max-height: 32px;\" src=\"../banner_images/logo_amazon.png\" width=\"75px\">\n",
    "        </a>\n",
    "    </li>\n",
    "    <li style=\"display: inline-block;height: 100%;vertical-align: middle;float: right;margin: -5px 25px 10px;padding: 0px;\">\n",
    "        <a href=\"https://www.packtpub.com/application-development/hands-computer-vision-tensorflow-2\" title=\"Get your Packt book (paperback, PDF, ePUB, or MOBI version)!\" target=\"_blank\">\n",
    "        <img style=\"vertical-align: middle; max-width: 72px; max-height: 32px;\" src=\"../banner_images/logo_packt.png\" width=\"75px\">\n",
    "        </a>\n",
    "    </li>\n",
    "    </ul>\n",
    "        </td>\n",
    "        </tr>\n",
    "        </table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "import os\n",
    "# Choosing which GPU this notebook can access\n",
    "# (useful when running multiple experiments in parallel, on different GPUs):\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]= \"1\" \n",
    "\n",
    "# Defining the seed for some random operations:\n",
    "random_seed = 42\n",
    "\n",
    "# Setting some variables to format the logs:\n",
    "log_begin_red, log_begin_blue, log_begin_green = '\\033[91m', '\\033[94m', '\\033[92m'\n",
    "log_begin_bold, log_begin_underline = '\\033[1m', '\\033[4m'\n",
    "log_end_format = '\\033[0m'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing the Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, we will use the [MNIST](http://yann.lecun.com/exdb/mnist) dataset[$^1$](#ref) for our demonstration (Yann LeCun and Corinna Cortes hold all copyrights for this dataset). Therefore, we prepare the data as done in the previous notebooks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = 10\n",
    "img_rows, img_cols, img_ch = 28, 28, 1\n",
    "input_shape = (img_rows, img_cols, img_ch)\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
    "\n",
    "x_train = x_train.reshape(x_train.shape[0], *input_shape)\n",
    "x_test = x_test.reshape(x_test.shape[0], *input_shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However this time, to highlight the advantages of regularization, we will make the recognition task harder by artificially reducing the number of samples available for training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data: (200, 28, 28, 1)\n",
      "Testing data: (10000, 28, 28, 1)\n"
     ]
    }
   ],
   "source": [
    "x_train, y_train = x_train[:200], y_train[:200] # ... 200 training samples instead of 60,000...\n",
    "\n",
    "print('Training data: {}'.format(x_train.shape))\n",
    "print('Testing data: {}'.format(x_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a Model with Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applying the code presented in the chapter, we will first demonstrate how to implement and apply a regularization loss ourselves. Then, we will show how one can directly use Keras API to train models with standard regularization solutions (*L1/L2*, *dropout*, *batch normalization*), comparing their effects. We will use the training of *LeNet-5*[$^2$](#ref) on MNIST to illustrate all this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model, Sequential\n",
    "from tensorflow.keras.layers import (Input, Activation, Dense, Flatten, Conv2D, \n",
    "                                     MaxPooling2D, Dropout, BatchNormalization)\n",
    "\n",
    "epochs      = 200\n",
    "batch_size  = 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manually applying regularization losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate how to add a regularization loss to any layer, we will start from the simple convolution layer we presented in the book and in a previous [notebook](./ch3_nb2_build_and_train_first_cnn_with_tf2.pynb) (i.e., a simpler, self-made `Conv2d` layer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def conv_layer(x, kernels, bias, s):\n",
    "    z = tf.nn.conv2d(x, kernels, strides=[1,s,s,1], padding='VALID')\n",
    "    # Finally, applying the bias and activation function (e.g. ReLU):\n",
    "    return tf.nn.relu(z + bias)\n",
    "\n",
    "\n",
    "class SimpleConvolutionLayer(tf.keras.layers.Layer):\n",
    "    def __init__(self, num_kernels=32, kernel_size=(3, 3), stride=1):\n",
    "        \"\"\" Initialize the layer.\n",
    "        :param num_kernels: Number of kernels for the convolution\n",
    "        :param kernel_size: Kernel size (H x W)\n",
    "        :param stride: Vertical/horizontal stride\n",
    "        \"\"\"\n",
    "        super().__init__() \n",
    "        self.num_kernels = num_kernels\n",
    "        self.kernel_size = kernel_size\n",
    "        self.stride = stride\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        \"\"\" Build the layer, initializing its parameters.\n",
    "        This will be internally called the 1st time the layer is used.\n",
    "        :param input_shape: Input shape for the layer (e.g. BxHxWxC)\n",
    "        \"\"\"\n",
    "        num_input_ch = input_shape[-1] # assuming shape format BHWC\n",
    "        # Now we know the shape of the kernel tensor we need:\n",
    "        kernels_shape = (*self.kernel_size, num_input_ch, self.num_kernels)\n",
    "        # We initialize the filter values e.g. from a Glorot distribution:\n",
    "        glorot_init = tf.initializers.GlorotUniform()\n",
    "        self.kernels = self.add_weight( # method to add Variables to layer\n",
    "            name='kernels', shape=kernels_shape, initializer=glorot_init,\n",
    "            trainable=True) # and we make it trainable.\n",
    "        # Same for the bias variable (e.g. from a normal distribution):\n",
    "        self.bias = self.add_weight(\n",
    "            name='bias', shape=(self.num_kernels,), \n",
    "            initializer='random_normal', trainable=True)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        \"\"\" Call the layer, apply its operations to the input tensor.\"\"\"\n",
    "        return conv_layer(inputs, self.kernels, self.bias, self.stride)\n",
    "\n",
    "    def get_config(self):\n",
    "        \"\"\"\n",
    "        Helper function to define the layer and its parameters.\n",
    "        :return:        Dictionary containing the layer's configuration\n",
    "        \"\"\"\n",
    "        return {'num_kernels': self.num_kernels,\n",
    "                'kernel_size': self.kernel_size,\n",
    "                'strides': self.strides,\n",
    "                'use_bias': self.use_bias}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will extend this layer class to add kernel/bias regularization. As explained in the book, the `Layer`'s method `.add_loss()` can be used for that purpose:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "def l2_reg(coef=1e-2):\n",
    "    \"\"\"\n",
    "    Returns a function computing a weighed L2 norm of a given tensor.\n",
    "    (this is basically a reimplementation of f.keras.regularizers.l2())\n",
    "    :param coef:    Weight for the norm\n",
    "    :return:        Loss function\n",
    "    \"\"\"\n",
    "    return lambda x: tf.reduce_sum(x ** 2) * coef\n",
    "\n",
    "    \n",
    "class ConvWithRegularizers(SimpleConvolutionLayer):\n",
    "    def __init__(self, num_kernels=32, kernel_size=(3, 3), stride=1,\n",
    "                 kernel_regularizer=l2_reg(), bias_regularizer=None):\n",
    "        \"\"\" \n",
    "        Initialize the layer.\n",
    "        :param num_kernels:        Number of kernels for the convolution\n",
    "        :param kernel_size:        Kernel size (H x W)\n",
    "        :param stride:             Vertical/horizontal stride\n",
    "        :param kernel_regularizer: (opt.) Regularization loss for the kernel variable\n",
    "        :param bias_regularizer:   (opt.) Regularization loss for the bias variable\n",
    "        \"\"\"\n",
    "        super().__init__(num_kernels, kernel_size, stride)  \n",
    "        self.kernel_regularizer = kernel_regularizer\n",
    "        self.bias_regularizer = bias_regularizer\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        \"\"\"\n",
    "        Build the layer, initializing its components.\n",
    "        \"\"\"\n",
    "        super().build(input_shape)\n",
    "        # Attaching the regularization losses to the variables.\n",
    "        if self.kernel_regularizer is not None:\n",
    "            self.add_loss(partial(self.kernel_regularizer, self.kernels))\n",
    "        if self.bias_regularizer is not None:\n",
    "            self.add_loss(partial(self.bias_regularizer, self.bias))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When instantiating this layer, the regularizer passed as attributes will be attached to the layer. The loss values of these regularizers can be obtained whenever, simply calling the layer's property `.losses`. Let us check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regularization losses over kernel and bias parameters: [2.0280523, 0.11339313]\n",
      "L2 norms of kernel and bias parameters: [2.0280523, 0.11339313]\n"
     ]
    }
   ],
   "source": [
    "conv = ConvWithRegularizers(num_kernels=32, kernel_size=(3, 3), stride=1,\n",
    "                            kernel_regularizer=l2_reg(1.), bias_regularizer=l2_reg(1.))\n",
    "conv.build(input_shape=tf.TensorShape((None, 28, 28, 1)))\n",
    "\n",
    "# Fetching the layer's losses:\n",
    "reg_losses = conv.losses\n",
    "print('Regularization losses over kernel and bias parameters: {}'.format(\n",
    "    [loss.numpy() for loss in reg_losses]))\n",
    "\n",
    "# Comparing with the L2 norms of its kernel and bias tensors:\n",
    "kernel_norm, bias_norm = tf.reduce_sum(conv.kernels ** 2).numpy(), tf.reduce_sum(conv.bias ** 2).numpy()\n",
    "print('L2 norms of kernel and bias parameters: {}'.format([kernel_norm, bias_norm]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The neat thing with the property `.losses` is that it also list the losses attached to all the layers and  models composing an instance. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Losses attached to the model and its layers:\n",
      "\r",
      "[2.0123982, 0.09478608, 31.541805, 0.061432756, 32.13073, 0.08924208] (6 losses)\n"
     ]
    }
   ],
   "source": [
    "model = Sequential([\n",
    "    Input(shape=input_shape),\n",
    "    ConvWithRegularizers(kernel_regularizer=l2_reg(1.), bias_regularizer=l2_reg(1.)),\n",
    "    ConvWithRegularizers(kernel_regularizer=l2_reg(1.), bias_regularizer=l2_reg(1.)),\n",
    "    ConvWithRegularizers(kernel_regularizer=l2_reg(1.), bias_regularizer=l2_reg(1.))  \n",
    "])\n",
    "\n",
    "print('Losses attached to the model and its layers:\\n\\r{} ({} losses)'.format(\n",
    "    [loss.numpy() for loss in model.losses], len(model.losses)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now build a *LeNet-5* with our custom layers, and train it taking into account the regularization terms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LeNet5(Model): # `Model` has the same API as `Layer` + extends it\n",
    "    \n",
    "    def __init__(self, num_classes,\n",
    "                 kernel_regularizer=l2_reg(), bias_regularizer=l2_reg()):\n",
    "        # Create the model and its layers:\n",
    "        super(LeNet5, self).__init__()\n",
    "        self.conv1 = ConvWithRegularizers(\n",
    "            6, kernel_size=(5, 5), \n",
    "            kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)\n",
    "        self.conv2 = ConvWithRegularizers(\n",
    "            16, kernel_size=(5, 5),\n",
    "            kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)\n",
    "        self.max_pool = MaxPooling2D(pool_size=(2, 2))\n",
    "        self.flatten = Flatten()\n",
    "        self.dense1 = Dense(120, activation='relu')\n",
    "        self.dense2 = Dense(84, activation='relu')\n",
    "        self.dense3 = Dense(num_classes, activation='softmax')\n",
    "        \n",
    "    def call(self, x): # Apply the layers in order to process the inputs\n",
    "        x = self.max_pool(self.conv1(x)) # 1st block\n",
    "        x = self.max_pool(self.conv2(x)) # 2nd block\n",
    "        x = self.flatten(x)\n",
    "        x = self.dense3(self.dense2(self.dense1(x))) # dense layers\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training: \u001b[91mstart\u001b[0m\n",
      "Epoch   0/200: main loss = \u001b[94m2.300\u001b[0m; reg loss = \u001b[94m0.106\u001b[0m; val acc = \u001b[94m11.060%\u001b[0m\n",
      "Epoch  10/200: main loss = \u001b[94m1.226\u001b[0m; reg loss = \u001b[94m0.115\u001b[0m; val acc = \u001b[94m48.430%\u001b[0m\n",
      "Epoch  20/200: main loss = \u001b[94m0.302\u001b[0m; reg loss = \u001b[94m0.132\u001b[0m; val acc = \u001b[94m79.040%\u001b[0m\n",
      "Epoch  30/200: main loss = \u001b[94m0.084\u001b[0m; reg loss = \u001b[94m0.136\u001b[0m; val acc = \u001b[94m81.240%\u001b[0m\n",
      "Epoch  40/200: main loss = \u001b[94m0.036\u001b[0m; reg loss = \u001b[94m0.136\u001b[0m; val acc = \u001b[94m81.590%\u001b[0m\n",
      "Epoch  50/200: main loss = \u001b[94m0.021\u001b[0m; reg loss = \u001b[94m0.132\u001b[0m; val acc = \u001b[94m81.310%\u001b[0m\n",
      "Epoch  60/200: main loss = \u001b[94m0.015\u001b[0m; reg loss = \u001b[94m0.127\u001b[0m; val acc = \u001b[94m81.360%\u001b[0m\n",
      "Epoch  70/200: main loss = \u001b[94m0.012\u001b[0m; reg loss = \u001b[94m0.121\u001b[0m; val acc = \u001b[94m81.500%\u001b[0m\n",
      "Epoch  80/200: main loss = \u001b[94m0.010\u001b[0m; reg loss = \u001b[94m0.116\u001b[0m; val acc = \u001b[94m81.510%\u001b[0m\n",
      "Epoch  90/200: main loss = \u001b[94m0.010\u001b[0m; reg loss = \u001b[94m0.110\u001b[0m; val acc = \u001b[94m81.570%\u001b[0m\n",
      "Epoch 100/200: main loss = \u001b[94m0.009\u001b[0m; reg loss = \u001b[94m0.105\u001b[0m; val acc = \u001b[94m81.640%\u001b[0m\n",
      "Epoch 110/200: main loss = \u001b[94m0.009\u001b[0m; reg loss = \u001b[94m0.100\u001b[0m; val acc = \u001b[94m81.700%\u001b[0m\n",
      "Epoch 120/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.095\u001b[0m; val acc = \u001b[94m81.680%\u001b[0m\n",
      "Epoch 130/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.091\u001b[0m; val acc = \u001b[94m81.780%\u001b[0m\n",
      "Epoch 140/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.087\u001b[0m; val acc = \u001b[94m81.860%\u001b[0m\n",
      "Epoch 150/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.083\u001b[0m; val acc = \u001b[94m81.930%\u001b[0m\n",
      "Epoch 160/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.080\u001b[0m; val acc = \u001b[94m81.970%\u001b[0m\n",
      "Epoch 170/200: main loss = \u001b[94m0.008\u001b[0m; reg loss = \u001b[94m0.077\u001b[0m; val acc = \u001b[94m81.960%\u001b[0m\n",
      "Epoch 180/200: main loss = \u001b[94m0.007\u001b[0m; reg loss = \u001b[94m0.074\u001b[0m; val acc = \u001b[94m82.070%\u001b[0m\n",
      "Epoch 190/200: main loss = \u001b[94m0.007\u001b[0m; reg loss = \u001b[94m0.071\u001b[0m; val acc = \u001b[94m82.100%\u001b[0m\n",
      "Epoch 199/200: main loss = \u001b[94m0.007\u001b[0m; reg loss = \u001b[94m0.068\u001b[0m; val acc = \u001b[94m82.140%\u001b[0m\n",
      "Training: \u001b[92mend\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "optimizer  = tf.optimizers.SGD()\n",
    "dataset    = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(batch_size)\n",
    "log_string_template = 'Epoch {0:3}/{1}: main loss = {5}{2:5.3f}{6}; ' + \\\n",
    "                      'reg loss = {5}{3:5.3f}{6}; val acc = {5}{4:5.3f}%{6}'\n",
    "\n",
    "def train_classifier_on_mnist(model, log_frequency=10):\n",
    "\n",
    "    avg_main_loss = tf.keras.metrics.Mean(name='avg_main_loss', dtype=tf.float32)\n",
    "    avg_reg_loss  = tf.keras.metrics.Mean(name='avg_reg_loss', dtype=tf.float32)\n",
    "\n",
    "    print(\"Training: {}start{}\".format(log_begin_red, log_end_format))\n",
    "    for epoch in range(epochs):\n",
    "        for (batch_images, batch_gts) in dataset:    # For each batch of this epoch\n",
    "\n",
    "            with tf.GradientTape() as grad_tape:     # Tell TF to tape the gradients\n",
    "                y = model(batch_images)              # Feed forward\n",
    "                main_loss = tf.losses.sparse_categorical_crossentropy(\n",
    "                    batch_gts, y)                    # Compute loss\n",
    "                reg_loss = sum(model.losses)         # List and add other losses\n",
    "                loss = main_loss + reg_loss\n",
    "\n",
    "            # Get the gradients of combined losses and back-propagate:\n",
    "            grads = grad_tape.gradient(loss, model.trainable_variables)\n",
    "            optimizer.apply_gradients(zip(grads, model.trainable_variables))\n",
    "\n",
    "            # Keep track of losses for display:\n",
    "            avg_main_loss.update_state(main_loss)\n",
    "            avg_reg_loss.update_state(reg_loss)\n",
    "\n",
    "        if epoch % log_frequency == 0 or epoch == (epochs - 1): # Log some metrics\n",
    "            # Validate, computing the accuracy on test data:\n",
    "            acc = tf.reduce_mean(tf.metrics.sparse_categorical_accuracy(\n",
    "                tf.constant(y_test), model(x_test))).numpy() * 100\n",
    "\n",
    "            main_loss = avg_main_loss.result()\n",
    "            reg_loss = avg_reg_loss.result()\n",
    "\n",
    "            print(log_string_template.format(\n",
    "                epoch, epochs, main_loss, reg_loss, acc, log_begin_blue, log_end_format))\n",
    "\n",
    "        avg_main_loss.reset_states()\n",
    "        avg_reg_loss.reset_states()\n",
    "    print(\"Training: {}end{}\".format(log_begin_green, log_end_format))\n",
    "    return model\n",
    "    \n",
    "\n",
    "model = LeNet5(10, kernel_regularizer=l2_reg(), bias_regularizer=l2_reg())\n",
    "model = train_classifier_on_mnist(model, log_frequency=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is interesting to observe that, at first, the regularization losses increase while the classification loss decreases. As the value of the latter is much higher at first, the network basically focuses on minimizing it, regardless of the values its kernels/biases are taking. Once the classification dropped low enough, then the regularization losses start being taken into account too. \n",
    "\n",
    "Let us compare the accuracy of our regularized network with one without these terms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training: \u001b[91mstart\u001b[0m\n",
      "Epoch   0/200: main loss = \u001b[94m2.309\u001b[0m; reg loss = \u001b[94m0.000\u001b[0m; val acc = \u001b[94m18.120%\u001b[0m\n",
      "Epoch  50/200: main loss = \u001b[94m0.015\u001b[0m; reg loss = \u001b[94m0.000\u001b[0m; val acc = \u001b[94m81.420%\u001b[0m\n",
      "Epoch 100/200: main loss = \u001b[94m0.003\u001b[0m; reg loss = \u001b[94m0.000\u001b[0m; val acc = \u001b[94m81.460%\u001b[0m\n",
      "Epoch 150/200: main loss = \u001b[94m0.002\u001b[0m; reg loss = \u001b[94m0.000\u001b[0m; val acc = \u001b[94m81.430%\u001b[0m\n",
      "Epoch 199/200: main loss = \u001b[94m0.001\u001b[0m; reg loss = \u001b[94m0.000\u001b[0m; val acc = \u001b[94m81.440%\u001b[0m\n",
      "Training: \u001b[92mend\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "model = LeNet5(10, kernel_regularizer=None, bias_regularizer=None)\n",
    "model = train_classifier_on_mnist(model, log_frequency=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ~1% accuracy gain on the test set, which is non negligeable!\n",
    "\n",
    "The usage of **`add_loss()`** and **`.losses`** is however the main take-away of this experiment, as they can become useful for more complex models, when we want to apply layer-specific losses for instance.\n",
    "\n",
    "When it comes to regularization, TensorFlow and Keras already provide simpler tools, as we will cover in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying Various Pre-implemented Regularization Methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides the L1/L2 regularization, other methods were presented in the chapter. Switching completely to the Keras API, we will experiment with those methods and quickly compare their effect on our toy use-case.\n",
    "\n",
    "For that, let us create another _LeNet-5_ factory function (using the Sequential API this time. just to illustrate the differences):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lenet(name='lenet', input_shape=input_shape,\n",
    "          use_dropout=False, use_batchnorm=False, regularizer=None):\n",
    "    \"\"\"\n",
    "    Create a LeNet-5 Keras model, with optional regularization schemes.\n",
    "    :param name:           Name for the model\n",
    "    :param input_shape:    Model's input shape\n",
    "    :param use_dropout:    Flag to add Dropout layers after key layers\n",
    "    :param use_batchnorm:  Flag to add BatchNormalization layers after key layers\n",
    "    :param regularizer:    Regularization function to be applied to layers' kernels\n",
    "    :return:               LeNet-5 Keras model\n",
    "    \"\"\"\n",
    "    \n",
    "    layers = []\n",
    "    \n",
    "    # 1st block:\n",
    "    layers += [Conv2D(6, kernel_size=(5, 5), padding='same', \n",
    "                      input_shape=input_shape, kernel_regularizer=regularizer)]\n",
    "    if use_batchnorm:\n",
    "        layers += [BatchNormalization()]\n",
    "    layers += [Activation('relu'),\n",
    "               MaxPooling2D(pool_size=(2, 2))]\n",
    "    if use_dropout:\n",
    "        layers += [Dropout(0.25)]\n",
    "        \n",
    "    # 2nd block:\n",
    "    layers += [ \n",
    "        Conv2D(16, kernel_size=(5, 5), kernel_regularizer=regularizer)]\n",
    "    if use_batchnorm:\n",
    "        layers += [BatchNormalization()]\n",
    "    layers += [Activation('relu'),\n",
    "               MaxPooling2D(pool_size=(2, 2))]\n",
    "    if use_dropout:\n",
    "        layers += [Dropout(0.25)]\n",
    " \n",
    "    # Dense layers:\n",
    "    layers += [Flatten()]\n",
    "    \n",
    "    layers += [Dense(120, kernel_regularizer=regularizer)]\n",
    "    if use_batchnorm:\n",
    "        layers += [BatchNormalization()]\n",
    "    layers += [Activation('relu')]\n",
    "    if use_dropout:\n",
    "        layers += [Dropout(0.25)]\n",
    "        \n",
    "    layers += [Dense(84, kernel_regularizer=regularizer)]\n",
    "    layers += [Activation('relu')]\n",
    "        \n",
    "    layers += [Dense(num_classes, activation='softmax')]\n",
    "    \n",
    "    model = Sequential(layers, name=name)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To showcase the effect that modern optimizers (available in Tensorflow and Keras) have on trainings, we will create several similar LeNet instance, and train each with a different combination of regularization techniques[$^{3,4,5}$](#ref)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we pre-define the various configurations we want to compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "configurations = {\n",
    "    'none':         {'use_dropout': False, 'use_batchnorm': False, 'regularizer': None},\n",
    "    'l1':           {'use_dropout': False, 'use_batchnorm': False, 'regularizer': tf.keras.regularizers.l1(0.01)},\n",
    "    'l2':           {'use_dropout': False, 'use_batchnorm': False, 'regularizer': tf.keras.regularizers.l2(0.01)},\n",
    "    'dropout':      {'use_dropout': True,  'use_batchnorm': False, 'regularizer': None},\n",
    "    'bn':           {'use_dropout': False, 'use_batchnorm': True,  'regularizer': None},\n",
    "    'l1+dropout':   {'use_dropout': False, 'use_batchnorm': True,  'regularizer': tf.keras.regularizers.l1(0.01)},\n",
    "    'l1+bn':        {'use_dropout': False, 'use_batchnorm': True,  'regularizer': tf.keras.regularizers.l1(0.01)},\n",
    "    'l1+dropout+bn':{'use_dropout': False, 'use_batchnorm': True,  'regularizer': tf.keras.regularizers.l1(0.01)}\n",
    "    # ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each regularization configuration we are considering, we will instantiate a new LeNet model and train it with. We will save their training `history` (containing the losses and metrics history over training), for comparison *(this process takes time, especially on CPU!)*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experiment: \u001b[91mstart\u001b[0m (training logs = off)\n",
      "\t> Training with none: \u001b[91mstart\u001b[0m\n",
      "\t> Training with none: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with l1: \u001b[91mstart\u001b[0m\n",
      "\t> Training with l1: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with l2: \u001b[91mstart\u001b[0m\n",
      "\t> Training with l2: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with dropout: \u001b[91mstart\u001b[0m\n",
      "\t> Training with dropout: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with bn: \u001b[91mstart\u001b[0m\n",
      "\t> Training with bn: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with l1+dropout: \u001b[91mstart\u001b[0m\n",
      "\t> Training with l1+dropout: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with l1+bn: \u001b[91mstart\u001b[0m\n",
      "\t> Training with l1+bn: \u001b[92mdone\u001b[0m.\n",
      "\t> Training with l1+dropout+bn: \u001b[91mstart\u001b[0m\n",
      "\t> Training with l1+dropout+bn: \u001b[92mdone\u001b[0m.\n",
      "Experiment: \u001b[92mdone\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "history_per_instance = dict()\n",
    "\n",
    "print(\"Experiment: {0}start{1} (training logs = off)\".format(log_begin_red, log_end_format))\n",
    "for config_name in configurations:\n",
    "    # Resetting the seeds (for random number generation), to reduce the impact of randomness on the comparison:\n",
    "    tf.random.set_seed(random_seed)\n",
    "    np.random.seed(random_seed)\n",
    "    # Creating the model:\n",
    "    model = lenet(\"lenet_{}\".format(config_name), **configurations[config_name])\n",
    "    model.compile(optimizer='sgd', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "    # Launching the training (we set `verbose=0`, so the training won't generate any logs):\n",
    "    print(\"\\t> Training with {0}: {1}start{2}\".format(\n",
    "        config_name, log_begin_red, log_end_format))\n",
    "    history = model.fit(x_train, y_train,\n",
    "                        batch_size=32, epochs=300, validation_data=(x_test, y_test),\n",
    "                        verbose=0)\n",
    "    history_per_instance[config_name] = history\n",
    "    print('\\t> Training with {0}: {1}done{2}.'.format(\n",
    "        config_name, log_begin_green, log_end_format))\n",
    "print(\"Experiment: {0}done{1}\".format(log_begin_green, log_end_format))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We finally plot the training and validation losses + accuracies, for comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 2, figsize=(10,10), sharex='col') # add parameter `sharey='row'` for a more direct comparison\n",
    "ax[0, 0].set_title(\"loss\")\n",
    "ax[0, 1].set_title(\"val-loss\")\n",
    "ax[1, 0].set_title(\"accuracy\")\n",
    "ax[1, 1].set_title(\"val-accuracy\")\n",
    "\n",
    "lines, labels = [], []\n",
    "for config_name in history_per_instance:\n",
    "    history = history_per_instance[config_name]\n",
    "    ax[0, 0].plot(history.history['loss'])\n",
    "    ax[0, 1].plot(history.history['val_loss'])\n",
    "    ax[1, 0].plot(history.history['accuracy'])\n",
    "    line = ax[1, 1].plot(history.history['val_accuracy'])\n",
    "    lines.append(line[0])\n",
    "    labels.append(config_name)\n",
    "\n",
    "fig.legend(lines,labels, loc='center right', borderaxespad=0.1)\n",
    "plt.subplots_adjust(right=0.84)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max val-accuracy for model \"none\": 69.05%\n",
      "Max val-accuracy for model \"l1\": 59.55%\n",
      "Max val-accuracy for model \"l2\": 68.11%\n",
      "Max val-accuracy for model \"dropout\": 48.69%\n",
      "Max val-accuracy for model \"bn\": 78.85%\n",
      "Max val-accuracy for model \"l1+dropout\": 79.03%\n",
      "Max val-accuracy for model \"l1+bn\": 79.03%\n",
      "Max val-accuracy for model \"l1+dropout+bn\": 79.00%\n"
     ]
    }
   ],
   "source": [
    "for config_name in history_per_instance:\n",
    "    best_val_acc = max(history_per_instance[config_name].history['val_accuracy']) * 100\n",
    "    print('Max val-accuracy for model \"{}\": {:2.2f}%'.format(config_name, best_val_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Note:*** As we can observe from the figure, it seems like some of the models could still further improve if trained longer. We leave it  to our readers to check."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Given how small and artificial this problem is, the idea is not to directly compare the performance of these regularization techniques, but rather to demonstrate their overall benefits. It is wise to keep these methods in mind when tackling real-life computer vision problems, as data scarcity and overfitting are common problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref\"></a>\n",
    "#### References\n",
    "\n",
    "1. LeCun, Y., Cortes, C., Burges, C., 2010. MNIST handwritten digit database. AT&T Labs [Online]. Available: http://yann.lecun.com/exdb/mnist 2, 18.\n",
    "2. LeCun, Yann. \"*LeNet-5, convolutional neural networks.*\" [http://yann.lecun.com/exdb/lenet](http://yann.lecun.com/exdb/lenet) (2015): 20.\n",
    "3. Girosi, F., Jones, M., Poggio, T., 1995. Regularization theory and neural networks architectures. Neural computation 7, 219269.\n",
    "4. Ioffe, S., Szegedy, C., 2015. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167.\n",
    "5. Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., Salakhutdinov, R., 2014. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research 15, 19291958.\n"
   ]
  }
 ],
 "metadata": {
  "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}