Object_Localization.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "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.4"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KsjDCIat6_UK"
      },
      "source": [
        "# Image Classification and Object Localization\n",
        "\n",
        "- classify the main subject in an image\n",
        "- localize it by drawing bounding boxes around it.\n",
        "\n",
        "We'll use the [MNIST](http://yann.lecun.com/exdb/mnist/) dataset to synthesize a custom dataset for the objective to:\n",
        "- Place each \"digit\" image on a black canvas of width 75 x 75 at random locations.\n",
        "- Calculate the corresponding bounding boxes for those \"digits\".\n",
        "\n",
        "The bounding box prediction can be modelled as a \"regression\" task, which means that the model will predict a numeric value (as opposed to a category)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpiJj8ym0v0-"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AoilhmYe1b5t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "279a0918-905e-420d-fe33-1a76c08f1208"
      },
      "source": [
        "import os, re, time, json\n",
        "import PIL.Image, PIL.ImageFont, PIL.ImageDraw\n",
        "import numpy as np\n",
        "try:\n",
        "  # %tensorflow_version only exists in Colab.\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "import tensorflow as tf\n",
        "from matplotlib import pyplot as plt\n",
        "import tensorflow_datasets as tfds\n",
        "\n",
        "print(\"Tensorflow version \" + tf.__version__)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab only includes TensorFlow 2.x; %tensorflow_version has no effect.\n",
            "Tensorflow version 2.9.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xmoFKEd98MP3"
      },
      "source": [
        "# Visualization Utilities\n",
        "\n",
        "These functions are used to draw bounding boxes around the digits."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tBjj1Fg-i_lc"
      },
      "source": [
        "#@title Plot Utilities for Bounding Boxes \n",
        "\n",
        "im_width = 75\n",
        "im_height = 75\n",
        "use_normalized_coordinates = True\n",
        "\n",
        "def draw_bounding_boxes_on_image_array(image,\n",
        "                                       boxes,\n",
        "                                       color=[],\n",
        "                                       thickness=1,\n",
        "                                       display_str_list=()):\n",
        "  \"\"\"Draws bounding boxes on image (numpy array).\n",
        "  Args:\n",
        "    image: a numpy array object.\n",
        "    boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).\n",
        "           The coordinates are in normalized format between [0, 1].\n",
        "    color: color to draw bounding box. Default is red.\n",
        "    thickness: line thickness. Default value is 4.\n",
        "    display_str_list_list: a list of strings for each bounding box.\n",
        "  Raises:\n",
        "    ValueError: if boxes is not a [N, 4] array\n",
        "  \"\"\"\n",
        "  image_pil = PIL.Image.fromarray(image)\n",
        "  rgbimg = PIL.Image.new(\"RGBA\", image_pil.size)\n",
        "  rgbimg.paste(image_pil)\n",
        "  draw_bounding_boxes_on_image(rgbimg, boxes, color, thickness,\n",
        "                               display_str_list)\n",
        "  return np.array(rgbimg)\n",
        "  \n",
        "\n",
        "def draw_bounding_boxes_on_image(image,\n",
        "                                 boxes,\n",
        "                                 color=[],\n",
        "                                 thickness=1,\n",
        "                                 display_str_list=()):\n",
        "  \"\"\"Draws bounding boxes on image.\n",
        "  Args:\n",
        "    image: a PIL.Image object.\n",
        "    boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).\n",
        "           The coordinates are in normalized format between [0, 1].\n",
        "    color: color to draw bounding box. Default is red.\n",
        "    thickness: line thickness. Default value is 4.\n",
        "    display_str_list: a list of strings for each bounding box.\n",
        "                           \n",
        "  Raises:\n",
        "    ValueError: if boxes is not a [N, 4] array\n",
        "  \"\"\"\n",
        "  boxes_shape = boxes.shape\n",
        "  if not boxes_shape:\n",
        "    return\n",
        "  if len(boxes_shape) != 2 or boxes_shape[1] != 4:\n",
        "    raise ValueError('Input must be of size [N, 4]')\n",
        "  for i in range(boxes_shape[0]):\n",
        "    draw_bounding_box_on_image(image, boxes[i, 1], boxes[i, 0], boxes[i, 3],\n",
        "                               boxes[i, 2], color[i], thickness, display_str_list[i])\n",
        "        \n",
        "def draw_bounding_box_on_image(image,\n",
        "                               ymin,\n",
        "                               xmin,\n",
        "                               ymax,\n",
        "                               xmax,\n",
        "                               color='red',\n",
        "                               thickness=1,\n",
        "                               display_str=None,\n",
        "                               use_normalized_coordinates=True):\n",
        "  \"\"\"Adds a bounding box to an image.\n",
        "  Bounding box coordinates can be specified in either absolute (pixel) or\n",
        "  normalized coordinates by setting the use_normalized_coordinates argument.\n",
        "  Args:\n",
        "    image: a PIL.Image object.\n",
        "    ymin: ymin of bounding box.\n",
        "    xmin: xmin of bounding box.\n",
        "    ymax: ymax of bounding box.\n",
        "    xmax: xmax of bounding box.\n",
        "    color: color to draw bounding box. Default is red.\n",
        "    thickness: line thickness. Default value is 4.\n",
        "    display_str_list: string to display in box\n",
        "    use_normalized_coordinates: If True (default), treat coordinates\n",
        "      ymin, xmin, ymax, xmax as relative to the image.  Otherwise treat\n",
        "      coordinates as absolute.\n",
        "  \"\"\"\n",
        "  draw = PIL.ImageDraw.Draw(image)\n",
        "  im_width, im_height = image.size\n",
        "  if use_normalized_coordinates:\n",
        "    (left, right, top, bottom) = (xmin * im_width, xmax * im_width,\n",
        "                                  ymin * im_height, ymax * im_height)\n",
        "  else:\n",
        "    (left, right, top, bottom) = (xmin, xmax, ymin, ymax)\n",
        "  draw.line([(left, top), (left, bottom), (right, bottom),\n",
        "             (right, top), (left, top)], width=thickness, fill=color)\n",
        "  \n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USx9tRBF8hWy"
      },
      "source": [
        "These utilities are used to visualize the data and predictions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qhdz68Xm3Z4Z",
        "cellView": "code"
      },
      "source": [
        "#@title Visualization Utilities \n",
        "\"\"\"\n",
        "This cell contains helper functions used for visualization\n",
        "and downloads only. \n",
        "\n",
        "You can skip reading it, as there is very\n",
        "little Keras or Tensorflow related code here.\n",
        "\"\"\"\n",
        "\n",
        "# Matplotlib config\n",
        "plt.rc('image', cmap='gray')\n",
        "plt.rc('grid', linewidth=0)\n",
        "plt.rc('xtick', top=False, bottom=False, labelsize='large')\n",
        "plt.rc('ytick', left=False, right=False, labelsize='large')\n",
        "plt.rc('axes', facecolor='F8F8F8', titlesize=\"large\", edgecolor='white')\n",
        "plt.rc('text', color='a8151a')\n",
        "plt.rc('figure', facecolor='F0F0F0')# Matplotlib fonts\n",
        "MATPLOTLIB_FONT_DIR = os.path.join(os.path.dirname(plt.__file__), \"mpl-data/fonts/ttf\")\n",
        "\n",
        "# pull a batch from the datasets. This code is not very nice, it gets much better in eager mode (TODO)\n",
        "def dataset_to_numpy_util(training_dataset, validation_dataset, N):\n",
        "  \n",
        "  # get one batch from each: 10000 validation digits, N training digits\n",
        "  batch_train_ds = training_dataset.unbatch().batch(N)\n",
        "  \n",
        "  # eager execution: loop through datasets normally\n",
        "  if tf.executing_eagerly():\n",
        "    for validation_digits, (validation_labels, validation_bboxes) in validation_dataset:\n",
        "      validation_digits = validation_digits.numpy()\n",
        "      validation_labels = validation_labels.numpy()\n",
        "      validation_bboxes = validation_bboxes.numpy()\n",
        "      break\n",
        "    for training_digits, (training_labels, training_bboxes) in batch_train_ds:\n",
        "      training_digits = training_digits.numpy()\n",
        "      training_labels = training_labels.numpy()\n",
        "      training_bboxes = training_bboxes.numpy()\n",
        "      break\n",
        "  \n",
        "  # these were one-hot encoded in the dataset\n",
        "  validation_labels = np.argmax(validation_labels, axis=1)\n",
        "  training_labels = np.argmax(training_labels, axis=1)\n",
        "  \n",
        "  return (training_digits, training_labels, training_bboxes,\n",
        "          validation_digits, validation_labels, validation_bboxes)\n",
        "\n",
        "# create digits from local fonts for testing\n",
        "def create_digits_from_local_fonts(n):\n",
        "  font_labels = []\n",
        "  img = PIL.Image.new('LA', (75*n, 75), color = (0,255)) # format 'LA': black in channel 0, alpha in channel 1\n",
        "  font1 = PIL.ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'DejaVuSansMono-Oblique.ttf'), 25)\n",
        "  font2 = PIL.ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'STIXGeneral.ttf'), 25)\n",
        "  d = PIL.ImageDraw.Draw(img)\n",
        "  for i in range(n):\n",
        "    font_labels.append(i%10)\n",
        "    d.text((7+i*75,0 if i<10 else -4), str(i%10), fill=(255,255), font=font1 if i<10 else font2)\n",
        "  font_digits = np.array(img.getdata(), np.float32)[:,0] / 255.0 # black in channel 0, alpha in channel 1 (discarded)\n",
        "  font_digits = np.reshape(np.stack(np.split(np.reshape(font_digits, [75, 75*n]), n, axis=1), axis=0), [n, 75*75])\n",
        "  return font_digits, font_labels\n",
        "\n",
        "\n",
        "# utility to display a row of digits with their predictions\n",
        "def display_digits_with_boxes(digits, predictions, labels, pred_bboxes, bboxes, iou, title):\n",
        "\n",
        "  n = 10\n",
        "\n",
        "  indexes = np.random.choice(len(predictions), size=n)\n",
        "  n_digits = digits[indexes]\n",
        "  n_predictions = predictions[indexes]\n",
        "  n_labels = labels[indexes]\n",
        "\n",
        "  n_iou = []\n",
        "  if len(iou) > 0:\n",
        "    n_iou = iou[indexes]\n",
        "\n",
        "  if (len(pred_bboxes) > 0):\n",
        "    n_pred_bboxes = pred_bboxes[indexes,:]\n",
        "\n",
        "  if (len(bboxes) > 0):\n",
        "    n_bboxes = bboxes[indexes,:]\n",
        "\n",
        "\n",
        "  n_digits = n_digits * 255.0\n",
        "  n_digits = n_digits.reshape(n, 75, 75)\n",
        "  fig = plt.figure(figsize=(20, 4))\n",
        "  plt.title(title)\n",
        "  plt.yticks([])\n",
        "  plt.xticks([])\n",
        "  \n",
        "  for i in range(10):\n",
        "    ax = fig.add_subplot(1, 10, i+1)\n",
        "    bboxes_to_plot = []\n",
        "    if (len(pred_bboxes) > i):\n",
        "      bboxes_to_plot.append(n_pred_bboxes[i])\n",
        "    \n",
        "    if (len(bboxes) > i):\n",
        "      bboxes_to_plot.append(n_bboxes[i])\n",
        "\n",
        "    img_to_draw = draw_bounding_boxes_on_image_array(image=n_digits[i], boxes=np.asarray(bboxes_to_plot), color=['red', 'green'], display_str_list=[\"true\", \"pred\"])\n",
        "    plt.xlabel(n_predictions[i])\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    \n",
        "    if n_predictions[i] != n_labels[i]:\n",
        "      ax.xaxis.label.set_color('red')\n",
        "\n",
        "    \n",
        "    \n",
        "    plt.imshow(img_to_draw)\n",
        "\n",
        "    if len(iou) > i :\n",
        "      color = \"black\"\n",
        "      if (n_iou[i][0] < iou_threshold):\n",
        "        color = \"red\"\n",
        "      ax.text(0.2, -0.3, \"iou: %s\" %(n_iou[i][0]), color=color, transform=ax.transAxes)\n",
        "\n",
        "\n",
        "# utility to display training and validation curves\n",
        "def plot_metrics(metric_name, title, ylim=5):\n",
        "  plt.title(title)\n",
        "  plt.ylim(0,ylim)\n",
        "  plt.plot(history.history[metric_name],color='blue',label=metric_name)\n",
        "  plt.plot(history.history['val_' + metric_name],color='green',label='val_' + metric_name)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Ok__0RB-M8S"
      },
      "source": [
        "## Selecting Between Strategies"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R4jujVYWY9-6"
      },
      "source": [
        "### TPU or GPU detection\n",
        "\n",
        "- If the TPU is available, then we'll be using the TPU Strategy.\n",
        "Otherwise:\n",
        "- If more than one GPU is available, then we'll use the Mirrored Strategy\n",
        "- If one GPU is available or if just the CPU is available, we'll use the default strategy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hd5zB1G7Y9-7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6013018a-d4db-4919-c946-167545bb3cc5"
      },
      "source": [
        "# Detect hardware\n",
        "try:\n",
        "  tpu = tf.distribute.cluster_resolver.TPUClusterResolver() # TPU detection\n",
        "except ValueError:\n",
        "  tpu = None\n",
        "  gpus = tf.config.experimental.list_logical_devices(\"GPU\")\n",
        "    \n",
        "# Select appropriate distribution strategy\n",
        "if tpu:\n",
        "  tf.config.experimental_connect_to_cluster(tpu)\n",
        "  tf.tpu.experimental.initialize_tpu_system(tpu)\n",
        "  strategy = tf.distribute.TPUStrategy(tpu) # Going back and forth between TPU and host is expensive. Better to run 128 batches on the TPU before reporting back.\n",
        "  print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])  \n",
        "elif len(gpus) > 1:\n",
        "  strategy = tf.distribute.MirroredStrategy([gpu.name for gpu in gpus])\n",
        "  print('Running on multiple GPUs ', [gpu.name for gpu in gpus])\n",
        "elif len(gpus) == 1:\n",
        "  strategy = tf.distribute.get_strategy() # default strategy that works on CPU and single GPU\n",
        "  print('Running on single GPU ', gpus[0].name)\n",
        "else:\n",
        "  strategy = tf.distribute.get_strategy() # default strategy that works on CPU and single GPU\n",
        "  print('Running on CPU')\n",
        "print(\"Number of accelerators: \", strategy.num_replicas_in_sync)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running on single GPU  /device:GPU:0\n",
            "Number of accelerators:  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lvo0t7XVIkWZ"
      },
      "source": [
        "### Parameters\n",
        "\n",
        "The global batch size is the batch size per replica (64 in this case) times the number of replicas in the distribution strategy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCpkS9C_H7Tl"
      },
      "source": [
        "BATCH_SIZE = 64 * strategy.num_replicas_in_sync # Gobal batch size.\n",
        "# The global batch size will be automatically sharded across all\n",
        "# replicas by the tf.data.Dataset API. A single TPU has 8 cores.\n",
        "# The best practice is to scale the batch size by the number of\n",
        "# replicas (cores). The learning rate should be increased as well.\n"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JVkc7nzg-WUy"
      },
      "source": [
        "## Loading and Preprocessing the Dataset\n",
        "\n",
        "Define some helper functions that will pre-process your data:\n",
        "- `read_image_tfds`: randomly overlays the \"digit\" image on top of a larger canvas.\n",
        "- `get_training_dataset`: loads data and splits it to get the training set.\n",
        "- `get_validation_dataset`: loads and splits the data to get the validation set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZE8dgyPC1_6m"
      },
      "source": [
        "\n",
        "'''\n",
        "Transforms each image in dataset by pasting it on a 75x75 canvas at random locations.\n",
        "'''\n",
        "def read_image_tfds(image, label):\n",
        "    xmin = tf.random.uniform((), 0 , 48, dtype=tf.int32)\n",
        "    ymin = tf.random.uniform((), 0 , 48, dtype=tf.int32)\n",
        "    image = tf.reshape(image, (28,28,1,))\n",
        "    image = tf.image.pad_to_bounding_box(image, ymin, xmin, 75, 75)\n",
        "    image = tf.cast(image, tf.float32)/255.0\n",
        "    xmin = tf.cast(xmin, tf.float32)\n",
        "    ymin = tf.cast(ymin, tf.float32)\n",
        "   \n",
        "    xmax = (xmin + 28) / 75\n",
        "    ymax = (ymin + 28) / 75\n",
        "    xmin = xmin / 75\n",
        "    ymin = ymin / 75\n",
        "    return image, (tf.one_hot(label, 10), [xmin, ymin, xmax, ymax])\n",
        "  \n",
        "'''\n",
        "Loads and maps the training split of the dataset using the map function. Note that we try to load the gcs version since TPU can only work with datasets on Google Cloud Storage.\n",
        "'''\n",
        "def get_training_dataset():\n",
        "      \n",
        "      with  strategy.scope():\n",
        "        dataset = tfds.load(\"mnist\", split=\"train\", as_supervised=True, try_gcs=True)\n",
        "        dataset = dataset.map(read_image_tfds, num_parallel_calls=16)\n",
        "        dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)\n",
        "        dataset = dataset.repeat() # Mandatory for Keras for now\n",
        "        dataset = dataset.batch(BATCH_SIZE, drop_remainder=True) # drop_remainder is important on TPU, batch size must be fixed\n",
        "        dataset = dataset.prefetch(-1)  # fetch next batches while training on the current one (-1: autotune prefetch buffer size)\n",
        "      return dataset\n",
        "\n",
        "'''\n",
        "Loads and maps the validation split of the dataset using the map function. Note that we try to load the gcs version since TPU can only work with datasets on Google Cloud Storage.\n",
        "'''  \n",
        "def get_validation_dataset():\n",
        "    dataset = tfds.load(\"mnist\", split=\"test\", as_supervised=True, try_gcs=True)\n",
        "    dataset = dataset.map(read_image_tfds, num_parallel_calls=16)\n",
        "\n",
        "    #dataset = dataset.cache() # this small dataset can be entirely cached in RAM\n",
        "    dataset = dataset.batch(10000, drop_remainder=True) # 10000 items in eval dataset, all in one batch\n",
        "    dataset = dataset.repeat() # Mandatory for Keras for now\n",
        "    return dataset\n",
        "\n",
        "# instantiate the datasets\n",
        "with strategy.scope():\n",
        "  training_dataset = get_training_dataset()\n",
        "  validation_dataset = get_validation_dataset()"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_fXo6GuvL3EB"
      },
      "source": [
        "### Visualize Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yZ4tjPKvL2eh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 511
        },
        "outputId": "5b48dfcb-cb21-4252-c4c2-f2b1d7578567"
      },
      "source": [
        "(training_digits, training_labels, training_bboxes,\n",
        " validation_digits, validation_labels, validation_bboxes) = dataset_to_numpy_util(training_dataset, validation_dataset, 10)\n",
        "\n",
        "display_digits_with_boxes(training_digits, training_labels, training_labels, np.array([]), training_bboxes, np.array([]), \"training digits and their labels\")\n",
        "display_digits_with_boxes(validation_digits, validation_labels, validation_labels, np.array([]), validation_bboxes, np.array([]), \"validation digits and their labels\")\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f8nHWWkS_eeZ"
      },
      "source": [
        "## Define the Network\n",
        "\n",
        "- `feature_extractor`: these convolutional layers extract the features of the image.\n",
        "- `classifier`:  This define the output layer that predicts among 10 categories (digits 0 through 9)\n",
        "- `bounding_box_regression`: This defines the output layer that predicts 4 numeric values, which define the coordinates of the bounding box (xmin, ymin, xmax, ymax)\n",
        "- `final_model`: This combines the layers for feature extraction, classification and bounding box prediction.  \n",
        "  - Notice that this is another example of a branching model, because the model splits to produce two kinds of output (a category and set of numbers).  \n",
        "  - Since you've learned to use the Functional API earlier in the specialization (course 1), you have the flexibility to define this kind of branching model!\n",
        "- `define_and_compile_model`: choose the optimizer and metrics, then compile the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "56y8UNFQIVwj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8fb421a-4b54-4e4d-de5d-158903d1b267"
      },
      "source": [
        "'''\n",
        "Feature extractor is the CNN that is made up of convolution and pooling layers.\n",
        "'''\n",
        "def feature_extractor(inputs):\n",
        "    x = tf.keras.layers.Conv2D(16, activation='relu', kernel_size=3, input_shape=(75, 75, 1))(inputs)\n",
        "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
        "\n",
        "    x = tf.keras.layers.Conv2D(32,kernel_size=3,activation='relu')(x)\n",
        "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
        "\n",
        "    x = tf.keras.layers.Conv2D(64,kernel_size=3,activation='relu')(x)\n",
        "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
        "\n",
        "    return x\n",
        "\n",
        "'''\n",
        "dense_layers adds a flatten and dense layer.\n",
        "This will follow the feature extraction layers\n",
        "'''\n",
        "def dense_layers(inputs):\n",
        "  x = tf.keras.layers.Flatten()(inputs)\n",
        "  x = tf.keras.layers.Dense(128, activation='relu')(x)\n",
        "  return x\n",
        "\n",
        "\n",
        "'''\n",
        "Classifier defines the classification output.\n",
        "This has a set of fully connected layers and a softmax layer.\n",
        "'''\n",
        "def classifier(inputs):\n",
        "\n",
        "  classification_output = tf.keras.layers.Dense(10, activation='softmax', name = 'classification')(inputs)\n",
        "  return classification_output\n",
        "\n",
        "\n",
        "'''\n",
        "This function defines the regression output for bounding box prediction. \n",
        "Note that we have four outputs corresponding to (xmin, ymin, xmax, ymax)\n",
        "'''\n",
        "def bounding_box_regression(inputs):\n",
        "    bounding_box_regression_output = tf.keras.layers.Dense(units = '4', name = 'bounding_box')(inputs)\n",
        "    return bounding_box_regression_output\n",
        "\n",
        "\n",
        "def final_model(inputs):\n",
        "    feature_cnn = feature_extractor(inputs)\n",
        "    dense_output = dense_layers(feature_cnn)\n",
        "\n",
        "    '''\n",
        "    The model branches here.  \n",
        "    The dense layer's output gets fed into two branches:\n",
        "    classification_output and bounding_box_output\n",
        "    '''\n",
        "    classification_output = classifier(dense_output)\n",
        "    bounding_box_output = bounding_box_regression(dense_output)\n",
        "\n",
        "    model = tf.keras.Model(inputs = inputs, outputs = [classification_output, bounding_box_output])\n",
        "\n",
        "    return model\n",
        "  \n",
        "\n",
        "def define_and_compile_model(inputs):\n",
        "  model = final_model(inputs)\n",
        "  \n",
        "  model.compile(optimizer='adam', \n",
        "              loss = {'classification' : 'categorical_crossentropy',\n",
        "                      'bounding_box' : 'mse'\n",
        "                     },\n",
        "              metrics = {'classification' : 'accuracy',\n",
        "                         'bounding_box' : 'mse'\n",
        "                        })\n",
        "  return model\n",
        "\n",
        "    \n",
        "with strategy.scope():\n",
        "  inputs = tf.keras.layers.Input(shape=(75, 75, 1,))\n",
        "  model = define_and_compile_model(inputs)\n",
        "\n",
        "# print model layers\n",
        "model.summary()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_1 (InputLayer)           [(None, 75, 75, 1)]  0           []                               \n",
            "                                                                                                  \n",
            " conv2d (Conv2D)                (None, 73, 73, 16)   160         ['input_1[0][0]']                \n",
            "                                                                                                  \n",
            " average_pooling2d (AveragePool  (None, 36, 36, 16)  0           ['conv2d[0][0]']                 \n",
            " ing2D)                                                                                           \n",
            "                                                                                                  \n",
            " conv2d_1 (Conv2D)              (None, 34, 34, 32)   4640        ['average_pooling2d[0][0]']      \n",
            "                                                                                                  \n",
            " average_pooling2d_1 (AveragePo  (None, 17, 17, 32)  0           ['conv2d_1[0][0]']               \n",
            " oling2D)                                                                                         \n",
            "                                                                                                  \n",
            " conv2d_2 (Conv2D)              (None, 15, 15, 64)   18496       ['average_pooling2d_1[0][0]']    \n",
            "                                                                                                  \n",
            " average_pooling2d_2 (AveragePo  (None, 7, 7, 64)    0           ['conv2d_2[0][0]']               \n",
            " oling2D)                                                                                         \n",
            "                                                                                                  \n",
            " flatten (Flatten)              (None, 3136)         0           ['average_pooling2d_2[0][0]']    \n",
            "                                                                                                  \n",
            " dense (Dense)                  (None, 128)          401536      ['flatten[0][0]']                \n",
            "                                                                                                  \n",
            " classification (Dense)         (None, 10)           1290        ['dense[0][0]']                  \n",
            "                                                                                                  \n",
            " bounding_box (Dense)           (None, 4)            516         ['dense[0][0]']                  \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 426,638\n",
            "Trainable params: 426,638\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CuhDh8ao8VyB"
      },
      "source": [
        "### Train and validate the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TTwH_P-ZJ_xx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "748c4ea7-0ddd-4561-d31b-40ec5218a0b7"
      },
      "source": [
        "EPOCHS = 65 # 45\n",
        "steps_per_epoch = 60000//BATCH_SIZE  # 60,000 items in this dataset\n",
        "validation_steps = 1\n",
        "\n",
        "history = model.fit(training_dataset,\n",
        "                    steps_per_epoch=steps_per_epoch, validation_data=validation_dataset, validation_steps=validation_steps, epochs=EPOCHS)\n",
        "\n",
        "loss, classification_loss, bounding_box_loss, classification_accuracy, bounding_box_mse = model.evaluate(validation_dataset, steps=1)\n",
        "print(\"Validation accuracy: \", classification_accuracy)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/65\n",
            "937/937 [==============================] - 27s 17ms/step - loss: 0.9202 - classification_loss: 0.9059 - bounding_box_loss: 0.0142 - classification_accuracy: 0.6794 - bounding_box_mse: 0.0142 - val_loss: 0.2970 - val_classification_loss: 0.2890 - val_bounding_box_loss: 0.0080 - val_classification_accuracy: 0.9112 - val_bounding_box_mse: 0.0080\n",
            "Epoch 2/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.2556 - classification_loss: 0.2494 - bounding_box_loss: 0.0062 - classification_accuracy: 0.9242 - bounding_box_mse: 0.0062 - val_loss: 0.1925 - val_classification_loss: 0.1878 - val_bounding_box_loss: 0.0047 - val_classification_accuracy: 0.9433 - val_bounding_box_mse: 0.0047\n",
            "Epoch 3/65\n",
            "937/937 [==============================] - 14s 15ms/step - loss: 0.1870 - classification_loss: 0.1835 - bounding_box_loss: 0.0035 - classification_accuracy: 0.9441 - bounding_box_mse: 0.0035 - val_loss: 0.1513 - val_classification_loss: 0.1485 - val_bounding_box_loss: 0.0028 - val_classification_accuracy: 0.9537 - val_bounding_box_mse: 0.0028\n",
            "Epoch 4/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.1501 - classification_loss: 0.1477 - bounding_box_loss: 0.0024 - classification_accuracy: 0.9541 - bounding_box_mse: 0.0024 - val_loss: 0.1195 - val_classification_loss: 0.1175 - val_bounding_box_loss: 0.0020 - val_classification_accuracy: 0.9648 - val_bounding_box_mse: 0.0020\n",
            "Epoch 5/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.1316 - classification_loss: 0.1297 - bounding_box_loss: 0.0019 - classification_accuracy: 0.9604 - bounding_box_mse: 0.0019 - val_loss: 0.1041 - val_classification_loss: 0.1026 - val_bounding_box_loss: 0.0015 - val_classification_accuracy: 0.9671 - val_bounding_box_mse: 0.0015\n",
            "Epoch 6/65\n",
            "937/937 [==============================] - 12s 12ms/step - loss: 0.1124 - classification_loss: 0.1110 - bounding_box_loss: 0.0015 - classification_accuracy: 0.9662 - bounding_box_mse: 0.0015 - val_loss: 0.0875 - val_classification_loss: 0.0863 - val_bounding_box_loss: 0.0012 - val_classification_accuracy: 0.9723 - val_bounding_box_mse: 0.0012\n",
            "Epoch 7/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.1004 - classification_loss: 0.0991 - bounding_box_loss: 0.0013 - classification_accuracy: 0.9694 - bounding_box_mse: 0.0013 - val_loss: 0.1003 - val_classification_loss: 0.0990 - val_bounding_box_loss: 0.0014 - val_classification_accuracy: 0.9700 - val_bounding_box_mse: 0.0014\n",
            "Epoch 8/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0897 - classification_loss: 0.0885 - bounding_box_loss: 0.0012 - classification_accuracy: 0.9735 - bounding_box_mse: 0.0012 - val_loss: 0.0657 - val_classification_loss: 0.0644 - val_bounding_box_loss: 0.0013 - val_classification_accuracy: 0.9804 - val_bounding_box_mse: 0.0013\n",
            "Epoch 9/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0817 - classification_loss: 0.0806 - bounding_box_loss: 0.0011 - classification_accuracy: 0.9749 - bounding_box_mse: 0.0011 - val_loss: 0.0693 - val_classification_loss: 0.0683 - val_bounding_box_loss: 9.4124e-04 - val_classification_accuracy: 0.9777 - val_bounding_box_mse: 9.4124e-04\n",
            "Epoch 10/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0747 - classification_loss: 0.0737 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9781 - bounding_box_mse: 0.0010 - val_loss: 0.0673 - val_classification_loss: 0.0664 - val_bounding_box_loss: 9.1664e-04 - val_classification_accuracy: 0.9786 - val_bounding_box_mse: 9.1664e-04\n",
            "Epoch 11/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0672 - classification_loss: 0.0662 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9788 - bounding_box_mse: 0.0010 - val_loss: 0.0594 - val_classification_loss: 0.0582 - val_bounding_box_loss: 0.0012 - val_classification_accuracy: 0.9832 - val_bounding_box_mse: 0.0012\n",
            "Epoch 12/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0634 - classification_loss: 0.0624 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9809 - bounding_box_mse: 0.0010 - val_loss: 0.0450 - val_classification_loss: 0.0441 - val_bounding_box_loss: 9.8040e-04 - val_classification_accuracy: 0.9864 - val_bounding_box_mse: 9.8040e-04\n",
            "Epoch 13/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0596 - classification_loss: 0.0586 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9817 - bounding_box_mse: 0.0010 - val_loss: 0.0488 - val_classification_loss: 0.0479 - val_bounding_box_loss: 9.8193e-04 - val_classification_accuracy: 0.9847 - val_bounding_box_mse: 9.8193e-04\n",
            "Epoch 14/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0570 - classification_loss: 0.0560 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9830 - bounding_box_mse: 0.0010 - val_loss: 0.0441 - val_classification_loss: 0.0431 - val_bounding_box_loss: 9.9932e-04 - val_classification_accuracy: 0.9862 - val_bounding_box_mse: 9.9932e-04\n",
            "Epoch 15/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0524 - classification_loss: 0.0514 - bounding_box_loss: 9.8651e-04 - classification_accuracy: 0.9846 - bounding_box_mse: 9.8651e-04 - val_loss: 0.0477 - val_classification_loss: 0.0468 - val_bounding_box_loss: 9.5489e-04 - val_classification_accuracy: 0.9845 - val_bounding_box_mse: 9.5489e-04\n",
            "Epoch 16/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0495 - classification_loss: 0.0485 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9848 - bounding_box_mse: 0.0010 - val_loss: 0.0507 - val_classification_loss: 0.0496 - val_bounding_box_loss: 0.0011 - val_classification_accuracy: 0.9832 - val_bounding_box_mse: 0.0011\n",
            "Epoch 17/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0480 - classification_loss: 0.0470 - bounding_box_loss: 0.0010 - classification_accuracy: 0.9857 - bounding_box_mse: 0.0010 - val_loss: 0.0432 - val_classification_loss: 0.0423 - val_bounding_box_loss: 8.7593e-04 - val_classification_accuracy: 0.9863 - val_bounding_box_mse: 8.7593e-04\n",
            "Epoch 18/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0469 - classification_loss: 0.0459 - bounding_box_loss: 9.7552e-04 - classification_accuracy: 0.9861 - bounding_box_mse: 9.7552e-04 - val_loss: 0.0389 - val_classification_loss: 0.0379 - val_bounding_box_loss: 0.0010 - val_classification_accuracy: 0.9882 - val_bounding_box_mse: 0.0010\n",
            "Epoch 19/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0450 - classification_loss: 0.0440 - bounding_box_loss: 9.3481e-04 - classification_accuracy: 0.9861 - bounding_box_mse: 9.3481e-04 - val_loss: 0.0439 - val_classification_loss: 0.0431 - val_bounding_box_loss: 8.6615e-04 - val_classification_accuracy: 0.9875 - val_bounding_box_mse: 8.6615e-04\n",
            "Epoch 20/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0433 - classification_loss: 0.0423 - bounding_box_loss: 9.5063e-04 - classification_accuracy: 0.9870 - bounding_box_mse: 9.5063e-04 - val_loss: 0.0405 - val_classification_loss: 0.0396 - val_bounding_box_loss: 9.2165e-04 - val_classification_accuracy: 0.9872 - val_bounding_box_mse: 9.2165e-04\n",
            "Epoch 21/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0393 - classification_loss: 0.0384 - bounding_box_loss: 9.1134e-04 - classification_accuracy: 0.9882 - bounding_box_mse: 9.1134e-04 - val_loss: 0.0352 - val_classification_loss: 0.0343 - val_bounding_box_loss: 8.6023e-04 - val_classification_accuracy: 0.9890 - val_bounding_box_mse: 8.6023e-04\n",
            "Epoch 22/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0380 - classification_loss: 0.0371 - bounding_box_loss: 8.8746e-04 - classification_accuracy: 0.9881 - bounding_box_mse: 8.8746e-04 - val_loss: 0.0366 - val_classification_loss: 0.0357 - val_bounding_box_loss: 9.1407e-04 - val_classification_accuracy: 0.9889 - val_bounding_box_mse: 9.1407e-04\n",
            "Epoch 23/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0372 - classification_loss: 0.0363 - bounding_box_loss: 9.1677e-04 - classification_accuracy: 0.9889 - bounding_box_mse: 9.1677e-04 - val_loss: 0.0342 - val_classification_loss: 0.0332 - val_bounding_box_loss: 0.0010 - val_classification_accuracy: 0.9889 - val_bounding_box_mse: 0.0010\n",
            "Epoch 24/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0376 - classification_loss: 0.0367 - bounding_box_loss: 9.0397e-04 - classification_accuracy: 0.9887 - bounding_box_mse: 9.0397e-04 - val_loss: 0.0462 - val_classification_loss: 0.0453 - val_bounding_box_loss: 9.1341e-04 - val_classification_accuracy: 0.9849 - val_bounding_box_mse: 9.1341e-04\n",
            "Epoch 25/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0363 - classification_loss: 0.0354 - bounding_box_loss: 8.7971e-04 - classification_accuracy: 0.9891 - bounding_box_mse: 8.7971e-04 - val_loss: 0.0354 - val_classification_loss: 0.0345 - val_bounding_box_loss: 8.9532e-04 - val_classification_accuracy: 0.9899 - val_bounding_box_mse: 8.9532e-04\n",
            "Epoch 26/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0348 - classification_loss: 0.0339 - bounding_box_loss: 8.6830e-04 - classification_accuracy: 0.9898 - bounding_box_mse: 8.6830e-04 - val_loss: 0.0337 - val_classification_loss: 0.0329 - val_bounding_box_loss: 7.6630e-04 - val_classification_accuracy: 0.9903 - val_bounding_box_mse: 7.6630e-04\n",
            "Epoch 27/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0332 - classification_loss: 0.0323 - bounding_box_loss: 8.6701e-04 - classification_accuracy: 0.9903 - bounding_box_mse: 8.6701e-04 - val_loss: 0.0435 - val_classification_loss: 0.0426 - val_bounding_box_loss: 9.0443e-04 - val_classification_accuracy: 0.9862 - val_bounding_box_mse: 9.0443e-04\n",
            "Epoch 28/65\n",
            "937/937 [==============================] - 13s 14ms/step - loss: 0.0321 - classification_loss: 0.0312 - bounding_box_loss: 8.8245e-04 - classification_accuracy: 0.9906 - bounding_box_mse: 8.8245e-04 - val_loss: 0.0373 - val_classification_loss: 0.0365 - val_bounding_box_loss: 8.7918e-04 - val_classification_accuracy: 0.9887 - val_bounding_box_mse: 8.7918e-04\n",
            "Epoch 29/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0319 - classification_loss: 0.0311 - bounding_box_loss: 8.3757e-04 - classification_accuracy: 0.9906 - bounding_box_mse: 8.3757e-04 - val_loss: 0.0351 - val_classification_loss: 0.0343 - val_bounding_box_loss: 8.2929e-04 - val_classification_accuracy: 0.9883 - val_bounding_box_mse: 8.2929e-04\n",
            "Epoch 30/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0299 - classification_loss: 0.0291 - bounding_box_loss: 8.0308e-04 - classification_accuracy: 0.9909 - bounding_box_mse: 8.0308e-04 - val_loss: 0.0341 - val_classification_loss: 0.0334 - val_bounding_box_loss: 7.8298e-04 - val_classification_accuracy: 0.9903 - val_bounding_box_mse: 7.8298e-04\n",
            "Epoch 31/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0302 - classification_loss: 0.0294 - bounding_box_loss: 7.8650e-04 - classification_accuracy: 0.9908 - bounding_box_mse: 7.8650e-04 - val_loss: 0.0329 - val_classification_loss: 0.0322 - val_bounding_box_loss: 7.5560e-04 - val_classification_accuracy: 0.9887 - val_bounding_box_mse: 7.5560e-04\n",
            "Epoch 32/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0291 - classification_loss: 0.0284 - bounding_box_loss: 7.1772e-04 - classification_accuracy: 0.9910 - bounding_box_mse: 7.1772e-04 - val_loss: 0.0418 - val_classification_loss: 0.0411 - val_bounding_box_loss: 7.1633e-04 - val_classification_accuracy: 0.9875 - val_bounding_box_mse: 7.1633e-04\n",
            "Epoch 33/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0267 - classification_loss: 0.0260 - bounding_box_loss: 7.1058e-04 - classification_accuracy: 0.9921 - bounding_box_mse: 7.1058e-04 - val_loss: 0.0310 - val_classification_loss: 0.0302 - val_bounding_box_loss: 7.3901e-04 - val_classification_accuracy: 0.9898 - val_bounding_box_mse: 7.3901e-04\n",
            "Epoch 34/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0264 - classification_loss: 0.0257 - bounding_box_loss: 6.7408e-04 - classification_accuracy: 0.9918 - bounding_box_mse: 6.7408e-04 - val_loss: 0.0261 - val_classification_loss: 0.0255 - val_bounding_box_loss: 6.2680e-04 - val_classification_accuracy: 0.9924 - val_bounding_box_mse: 6.2680e-04\n",
            "Epoch 35/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0268 - classification_loss: 0.0262 - bounding_box_loss: 6.2822e-04 - classification_accuracy: 0.9920 - bounding_box_mse: 6.2822e-04 - val_loss: 0.0294 - val_classification_loss: 0.0289 - val_bounding_box_loss: 5.6223e-04 - val_classification_accuracy: 0.9898 - val_bounding_box_mse: 5.6223e-04\n",
            "Epoch 36/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0269 - classification_loss: 0.0263 - bounding_box_loss: 6.0288e-04 - classification_accuracy: 0.9918 - bounding_box_mse: 6.0288e-04 - val_loss: 0.0301 - val_classification_loss: 0.0295 - val_bounding_box_loss: 5.4282e-04 - val_classification_accuracy: 0.9896 - val_bounding_box_mse: 5.4282e-04\n",
            "Epoch 37/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0259 - classification_loss: 0.0253 - bounding_box_loss: 5.7368e-04 - classification_accuracy: 0.9923 - bounding_box_mse: 5.7368e-04 - val_loss: 0.0264 - val_classification_loss: 0.0258 - val_bounding_box_loss: 6.1078e-04 - val_classification_accuracy: 0.9907 - val_bounding_box_mse: 6.1078e-04\n",
            "Epoch 38/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0246 - classification_loss: 0.0240 - bounding_box_loss: 5.3939e-04 - classification_accuracy: 0.9922 - bounding_box_mse: 5.3939e-04 - val_loss: 0.0249 - val_classification_loss: 0.0245 - val_bounding_box_loss: 4.8177e-04 - val_classification_accuracy: 0.9918 - val_bounding_box_mse: 4.8177e-04\n",
            "Epoch 39/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0239 - classification_loss: 0.0233 - bounding_box_loss: 5.0977e-04 - classification_accuracy: 0.9928 - bounding_box_mse: 5.0977e-04 - val_loss: 0.0267 - val_classification_loss: 0.0262 - val_bounding_box_loss: 5.1292e-04 - val_classification_accuracy: 0.9912 - val_bounding_box_mse: 5.1292e-04\n",
            "Epoch 40/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0248 - classification_loss: 0.0243 - bounding_box_loss: 4.8509e-04 - classification_accuracy: 0.9922 - bounding_box_mse: 4.8509e-04 - val_loss: 0.0275 - val_classification_loss: 0.0271 - val_bounding_box_loss: 4.3092e-04 - val_classification_accuracy: 0.9912 - val_bounding_box_mse: 4.3092e-04\n",
            "Epoch 41/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0219 - classification_loss: 0.0214 - bounding_box_loss: 4.6204e-04 - classification_accuracy: 0.9932 - bounding_box_mse: 4.6204e-04 - val_loss: 0.0274 - val_classification_loss: 0.0269 - val_bounding_box_loss: 4.6341e-04 - val_classification_accuracy: 0.9914 - val_bounding_box_mse: 4.6341e-04\n",
            "Epoch 42/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0221 - classification_loss: 0.0217 - bounding_box_loss: 4.5621e-04 - classification_accuracy: 0.9932 - bounding_box_mse: 4.5621e-04 - val_loss: 0.0244 - val_classification_loss: 0.0239 - val_bounding_box_loss: 4.7530e-04 - val_classification_accuracy: 0.9931 - val_bounding_box_mse: 4.7530e-04\n",
            "Epoch 43/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0215 - classification_loss: 0.0211 - bounding_box_loss: 4.3752e-04 - classification_accuracy: 0.9934 - bounding_box_mse: 4.3752e-04 - val_loss: 0.0271 - val_classification_loss: 0.0267 - val_bounding_box_loss: 4.1944e-04 - val_classification_accuracy: 0.9914 - val_bounding_box_mse: 4.1944e-04\n",
            "Epoch 44/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0217 - classification_loss: 0.0212 - bounding_box_loss: 4.1364e-04 - classification_accuracy: 0.9934 - bounding_box_mse: 4.1364e-04 - val_loss: 0.0271 - val_classification_loss: 0.0267 - val_bounding_box_loss: 4.3057e-04 - val_classification_accuracy: 0.9908 - val_bounding_box_mse: 4.3057e-04\n",
            "Epoch 45/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0214 - classification_loss: 0.0209 - bounding_box_loss: 4.2998e-04 - classification_accuracy: 0.9933 - bounding_box_mse: 4.2998e-04 - val_loss: 0.0260 - val_classification_loss: 0.0255 - val_bounding_box_loss: 4.9439e-04 - val_classification_accuracy: 0.9915 - val_bounding_box_mse: 4.9439e-04\n",
            "Epoch 46/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0210 - classification_loss: 0.0206 - bounding_box_loss: 4.2686e-04 - classification_accuracy: 0.9938 - bounding_box_mse: 4.2686e-04 - val_loss: 0.0260 - val_classification_loss: 0.0256 - val_bounding_box_loss: 4.4242e-04 - val_classification_accuracy: 0.9917 - val_bounding_box_mse: 4.4242e-04\n",
            "Epoch 47/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0196 - classification_loss: 0.0191 - bounding_box_loss: 4.2488e-04 - classification_accuracy: 0.9939 - bounding_box_mse: 4.2488e-04 - val_loss: 0.0283 - val_classification_loss: 0.0279 - val_bounding_box_loss: 4.2073e-04 - val_classification_accuracy: 0.9906 - val_bounding_box_mse: 4.2073e-04\n",
            "Epoch 48/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0219 - classification_loss: 0.0215 - bounding_box_loss: 3.9632e-04 - classification_accuracy: 0.9934 - bounding_box_mse: 3.9632e-04 - val_loss: 0.0272 - val_classification_loss: 0.0267 - val_bounding_box_loss: 4.7924e-04 - val_classification_accuracy: 0.9913 - val_bounding_box_mse: 4.7924e-04\n",
            "Epoch 49/65\n",
            "937/937 [==============================] - 11s 11ms/step - loss: 0.0193 - classification_loss: 0.0189 - bounding_box_loss: 3.8018e-04 - classification_accuracy: 0.9946 - bounding_box_mse: 3.8018e-04 - val_loss: 0.0233 - val_classification_loss: 0.0229 - val_bounding_box_loss: 3.7728e-04 - val_classification_accuracy: 0.9927 - val_bounding_box_mse: 3.7728e-04\n",
            "Epoch 50/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0197 - classification_loss: 0.0193 - bounding_box_loss: 4.0284e-04 - classification_accuracy: 0.9941 - bounding_box_mse: 4.0284e-04 - val_loss: 0.0244 - val_classification_loss: 0.0239 - val_bounding_box_loss: 5.1710e-04 - val_classification_accuracy: 0.9923 - val_bounding_box_mse: 5.1710e-04\n",
            "Epoch 51/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0193 - classification_loss: 0.0189 - bounding_box_loss: 3.8832e-04 - classification_accuracy: 0.9942 - bounding_box_mse: 3.8832e-04 - val_loss: 0.0221 - val_classification_loss: 0.0217 - val_bounding_box_loss: 3.4302e-04 - val_classification_accuracy: 0.9934 - val_bounding_box_mse: 3.4302e-04\n",
            "Epoch 52/65\n",
            "937/937 [==============================] - 13s 14ms/step - loss: 0.0192 - classification_loss: 0.0188 - bounding_box_loss: 3.9309e-04 - classification_accuracy: 0.9941 - bounding_box_mse: 3.9309e-04 - val_loss: 0.0271 - val_classification_loss: 0.0267 - val_bounding_box_loss: 3.9050e-04 - val_classification_accuracy: 0.9914 - val_bounding_box_mse: 3.9050e-04\n",
            "Epoch 53/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0181 - classification_loss: 0.0177 - bounding_box_loss: 3.9440e-04 - classification_accuracy: 0.9941 - bounding_box_mse: 3.9440e-04 - val_loss: 0.0224 - val_classification_loss: 0.0220 - val_bounding_box_loss: 3.8872e-04 - val_classification_accuracy: 0.9933 - val_bounding_box_mse: 3.8872e-04\n",
            "Epoch 54/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0177 - classification_loss: 0.0173 - bounding_box_loss: 3.7951e-04 - classification_accuracy: 0.9946 - bounding_box_mse: 3.7951e-04 - val_loss: 0.0266 - val_classification_loss: 0.0263 - val_bounding_box_loss: 3.8425e-04 - val_classification_accuracy: 0.9915 - val_bounding_box_mse: 3.8425e-04\n",
            "Epoch 55/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0179 - classification_loss: 0.0175 - bounding_box_loss: 3.8373e-04 - classification_accuracy: 0.9945 - bounding_box_mse: 3.8373e-04 - val_loss: 0.0276 - val_classification_loss: 0.0272 - val_bounding_box_loss: 3.9715e-04 - val_classification_accuracy: 0.9919 - val_bounding_box_mse: 3.9715e-04\n",
            "Epoch 56/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0173 - classification_loss: 0.0170 - bounding_box_loss: 3.7328e-04 - classification_accuracy: 0.9945 - bounding_box_mse: 3.7328e-04 - val_loss: 0.0271 - val_classification_loss: 0.0267 - val_bounding_box_loss: 3.4245e-04 - val_classification_accuracy: 0.9927 - val_bounding_box_mse: 3.4245e-04\n",
            "Epoch 57/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0178 - classification_loss: 0.0174 - bounding_box_loss: 3.8700e-04 - classification_accuracy: 0.9942 - bounding_box_mse: 3.8700e-04 - val_loss: 0.0216 - val_classification_loss: 0.0212 - val_bounding_box_loss: 3.4709e-04 - val_classification_accuracy: 0.9931 - val_bounding_box_mse: 3.4709e-04\n",
            "Epoch 58/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0170 - classification_loss: 0.0166 - bounding_box_loss: 3.6849e-04 - classification_accuracy: 0.9944 - bounding_box_mse: 3.6849e-04 - val_loss: 0.0297 - val_classification_loss: 0.0293 - val_bounding_box_loss: 3.6491e-04 - val_classification_accuracy: 0.9909 - val_bounding_box_mse: 3.6491e-04\n",
            "Epoch 59/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0167 - classification_loss: 0.0163 - bounding_box_loss: 3.7535e-04 - classification_accuracy: 0.9952 - bounding_box_mse: 3.7535e-04 - val_loss: 0.0229 - val_classification_loss: 0.0226 - val_bounding_box_loss: 3.5353e-04 - val_classification_accuracy: 0.9923 - val_bounding_box_mse: 3.5353e-04\n",
            "Epoch 60/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0167 - classification_loss: 0.0163 - bounding_box_loss: 3.7048e-04 - classification_accuracy: 0.9947 - bounding_box_mse: 3.7048e-04 - val_loss: 0.0211 - val_classification_loss: 0.0208 - val_bounding_box_loss: 3.6424e-04 - val_classification_accuracy: 0.9937 - val_bounding_box_mse: 3.6424e-04\n",
            "Epoch 61/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0164 - classification_loss: 0.0160 - bounding_box_loss: 3.8986e-04 - classification_accuracy: 0.9951 - bounding_box_mse: 3.8986e-04 - val_loss: 0.0266 - val_classification_loss: 0.0263 - val_bounding_box_loss: 3.5625e-04 - val_classification_accuracy: 0.9922 - val_bounding_box_mse: 3.5625e-04\n",
            "Epoch 62/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0164 - classification_loss: 0.0161 - bounding_box_loss: 3.7101e-04 - classification_accuracy: 0.9947 - bounding_box_mse: 3.7101e-04 - val_loss: 0.0252 - val_classification_loss: 0.0248 - val_bounding_box_loss: 3.8843e-04 - val_classification_accuracy: 0.9927 - val_bounding_box_mse: 3.8843e-04\n",
            "Epoch 63/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0158 - classification_loss: 0.0154 - bounding_box_loss: 3.7326e-04 - classification_accuracy: 0.9953 - bounding_box_mse: 3.7326e-04 - val_loss: 0.0283 - val_classification_loss: 0.0279 - val_bounding_box_loss: 4.0865e-04 - val_classification_accuracy: 0.9920 - val_bounding_box_mse: 4.0865e-04\n",
            "Epoch 64/65\n",
            "937/937 [==============================] - 11s 12ms/step - loss: 0.0160 - classification_loss: 0.0156 - bounding_box_loss: 3.8999e-04 - classification_accuracy: 0.9951 - bounding_box_mse: 3.8999e-04 - val_loss: 0.0237 - val_classification_loss: 0.0233 - val_bounding_box_loss: 3.7579e-04 - val_classification_accuracy: 0.9926 - val_bounding_box_mse: 3.7579e-04\n",
            "Epoch 65/65\n",
            "937/937 [==============================] - 10s 11ms/step - loss: 0.0148 - classification_loss: 0.0144 - bounding_box_loss: 3.7348e-04 - classification_accuracy: 0.9954 - bounding_box_mse: 3.7348e-04 - val_loss: 0.0275 - val_classification_loss: 0.0271 - val_bounding_box_loss: 3.6769e-04 - val_classification_accuracy: 0.9920 - val_bounding_box_mse: 3.6769e-04\n",
            "1/1 [==============================] - 1s 1s/step - loss: 0.0291 - classification_loss: 0.0287 - bounding_box_loss: 3.5606e-04 - classification_accuracy: 0.9912 - bounding_box_mse: 3.5606e-04\n",
            "Validation accuracy:  0.9911999702453613\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cz-b8TxU6EDj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "outputId": "4b74f2ff-749c-4776-b6a3-79e05a4b19d0"
      },
      "source": [
        "plot_metrics(\"classification_loss\", \"Classification Loss\")\n",
        "plot_metrics(\"bounding_box_loss\", \"Bounding Box Loss\")"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWsAAAELCAYAAAAfsqciAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAfPklEQVR4nO3de3wU9b3/8dfM7DU3wkVyAwGBQBCtKBcFK9iqYMG7aMG7VShKz0MFb8XW4hE4liKP1koL1l7o6bGFX6zg8VIwAoJYPahIqcFACAaCEi4JSTa7yV7m98dCuIYkSMiOvp+Pxz42Ozvznc/sY/a9k+98d9aorKy0ERGRhGa2dQEiItI0hbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwloS3soRl7Hn3bUAFP9mPht//JM2rkjk9HO1dQGSmFaOuIz6PXsxLBPD5ab9gPPo959P4s/KatO6ek6a2Gptv9m7H5bfDwaYXi8dhw7l7Kd+ijst7ZSuZ+WIy+g/4yk6DRt6StuVrzcdWUujzp//PJd/8iGXrl2Fp1NHCp+a0dYltbqhr77M5Z98yPCCZUSqqtjyq+fbuiQRQGEtzWB5vWSOuoKaLcUN08LV1Wx4+DEKBg9j5fDvUvz8b7FjMQA2/+rXfDLlkYZ5a3eU8WbvfsQiEQDev+UONs/9Ff+8+RaWnzeQ/7vzHur3VTTMX/bKUlYO/y4Fgy6ieN5vj6jl8LYPtlv28iusvOQ7FAweesT80VCIDY88zlsXXMjqkWPYuuBFVlx8abO22ZWaQufvXnrENod2lfPhxPspGHgh73x3JNv/tjhex+elFAy8kP3//rRhvoLBw9j7/gfNWtdBsbp6Cp+exYphw1kxbDiFT88iVlcPQP2+Cj68dxJvnT+EgoEX8v64Wxte763zf8eKi0ew/LyBvHPF99i79r0WrVecQd0g0qRoMMgXr79J+nnfaphW+NQMItXVDH97GfWVlay76x68nc+gy9gbmtXmzldfY+CL8/FlZbLuBxMpefEP9Hn4IWo2b+HTJ6dzwQvzSf/WuXw2Zy51X+46YVsVH37Et5e9TqBkG+/dcDMZV1xOSq+ebHluHsEdZQx/+x9Ea4Osu/eHzd7m8P797FpecMQ2f/LAFFJyezPi3VUEirfyf3feQ9KZXel40YXkPjyFDVMeYejfF/Ovx6aRc/01dBwyuNnrg3h/fOX6Txi69GUMDD6aNJnieb+l94P/Qcnv/4AvM4PvvL8GgMr1n4BhULO1hNL//h8uyl+EL6MztTvKIBpt0XrFGXRkLY36+L4f8db5Q3jr/CHsfXctPe65GwA7GuWL114nd8qDuFKSSeqSQ/e776TslaXNbrvLDdeR3KM7ls9H1vdGUV24CYAv31zGGZeOoMPggZheD70f+BGYxgnb6jX5Piyfj7S8vqTl9aV602fxtl5/k7MmTcDdrh2+rEy63X5rk3WtvebG+NHr4GGEvviCrt+/CYDgF19Q8dHH9Hl4CpbXS1q/PLrcdANlf49vc9ebx5LUrRvv3fh96nbvJvfBB5r9Why0c+n/0mvyJLwdO+Lp2IGeP7qPsiXx9k2Xm7rduwnu3InpdtNh0EAMw8CwTGL19dRs2UIsHCapSw5J3c5s8bol8SmspVED5j3HZR+9zxUbPybvp0/wwS23U7d7N/UVFdjhCL6c7IZ5/TnZ1O068RHw4TxndGr42/T5iNTWAlBXXo4vM7PhOVdSEp709JNuy39YW76szGOWPdrQJf+vYZu7jvs+74+7jWhdHXW7ynG3a4crJblhXn/2kdvc9aYbqSnaTLfbbsH0eppc19HqysuPfE2zs6krLwegxz13k9TtTNbdeS+rLr2CrfNfACC5Wzf6TnuMLc/N4+0Lv836B6YQ2lXe4nVL4lNYS5MMyyJz5OVgWlSs+whP+/YYbhehsp0N84R2foE3IwMAl99PLBhqeK5+955mr8vb+QxCX37Z8DgaDFJfWXlSdcfbOhSmoS++PMHcRzLdbrrcdAPBHTuoKdqMN6Mz4f37idQEDmvv0DZHAgEKZ/wXXcbewJbnnj+pmr2dOx/7mnbuDIArJZm+jz/K8BXLOH/+82z7/Z8a+qazrx7DhX/9b0asfAswKJo9p8XrlsSnsJYm2bbNrrcKiFRVkdzrrHh4XzmKorm/JFITIFhWxrY//Insa64CIDUvj33r1hHcuZNwdTVb5y9o9royRl3B7hUrqVj3IbH6ejb/8jmIndxVfDOvHMXW+S8Q3r+f0Je7KP3zX5q9rB2NUpb/d0yfD3/XLvizsmh//nkUzZlLtK6O6k2fsWPxy2RfMwaAwqdn0e6cs+k/8z85Y8RwPv3p9BO3H4kQratruMUiEbLGfI/iefOp37uP+n0VbHn+N2RfHX9Ny99eSeDzz7FtG1dqCoZlgmlSs7WEve/9k1hdPabXg+Xzgqm39deRTjBKoz6aeH88FAwDf3Y25zwzk9TevQHo99NpfPrUDFZ95wosr5cuN91IlxuvB6DTxUPJ+t6VvDvmOjzt0+kx4R7KC1Y0a52pvXvT78mf8MlDDxMNBul+1x14MzNOqv6ekyfx6U+ns+rSK/CecQbZV49hR/7fT7jM2quuBwMwTJLP6sGAeb9q6Ib51rO/4N8/nc7KYcNxpbWj13/cT6dhQ9n1VgF7Vq9h2P++AkDfxx9h7dXXs3PJqw0fYEf78J4jT3aeNWkiPe//IZGaGt696loAMkaNpOf98flqP/+cT596mvC+ClxpaXQdP46OFw6hetNnFP1iLjXFxZguF+kDBnD20yf+oBBnMvTjA/JNUfqXv/LFa68z5H8WtnUpIi2m/5fkaytUvpuKDz/CjsWo2VrCtt//gYzLL2vrskROSrO6QUaPHs26detwueKzZ2VlsW7dulYtTOSrssP1/PsnPyO4owxXWipZo6/kzFu+39ZliZyUZnWDjB49mptvvpnbb7/9dNQkIiJHUTeIiIgDNPvIetOmTdi2Te/evXniiSf49re/fcJl0tLSsG2duxQRaanq6upjpjUrrNetW0efPn3weDzk5+fzyCOPsHr1anr06NHoMqmpqYTD4a9WsYjIN4xlWQQCgWOmN6sbZODAgaSmpuL1ehk/fjxDhgxh2bJlp7xIERE5vpPqszYMQ10cIiKnUZNhXVlZSUFBAaFQiEgkwqJFi1i7di2XXabxqiIip0uT46wjkQhPP/00mzdvxjRNcnNz+ctf/kKvXr1OR30iIkIrft1cJxhFRFruK51gFBGRtqWwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcQCFtYiIAyisRUQcQGEtIuIACmsREQdQWIuIOIDCWkTEARTWIiIOoLAWEXEAhbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwlpExAEU1iIiDqCwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcYAWhXVxcTEZGRlMmDChteoREZHjaFFYT506lfPPP7+1ahERkUY0O6zz8/Np164dl1xySWvWIyIix9GssK6qqmLmzJnMmDGjtesREZHjaFZYz5gxg9tuu42cnJzWrkdERI7D1dQMGzZsYNWqVbzzzjunox4RETmOJsN6zZo1lJaW0r9/fwACgQDRaJRNmzYpwEVEThOjsrLSPtEMtbW1VFdXNzx+7rnnKC0t5dlnn6VTp06NLpeamko4HD51lYqIfANYlkUgEDhmepNH1klJSSQlJTU8Tk5OxufznTCoRUTk1GryyPpk6chaRKTlGjuy1tfNRUQcQGEtIuIACmsREQdQWIuIOIDCWkTEARTWIiIOoLAWEXEAhbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwlpExAEU1iIiDqCwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcQCFtYiIAyisRUQcQGEtIuIACmsREQdQWIuIOIDCWkTEARTWIiIOoLAWEXEAhbWIiAMorEVEHKBZYT1hwgT69OlD165dueCCC1i4cGFr1yUiIocxKisr7aZmKiws5KyzzsLr9VJUVMSYMWNYtGgR5513XqPLpKamEg6HT2mxIiJfd5ZlEQgEjpnerCPrvLw8vF4vAIZhYBgGJSUlp7ZCERFpVLP7rKdMmUJWVhaDBg0iIyODyy+/vDXrEhGRwzSrG+SgaDTKBx98wJo1a3jggQdwu92NzqtuEBGRlvtK3SCHN3LRRRexc+dOXnzxxVNWnIiInNhJDd2LRCLqsxYROY2aDOvdu3eTn59PTU0N0WiUgoIC8vPzGT58+OmoT0REaEaf9Z49e7j99tvZuHEjtm3TtWtXJk6cyB133HHChtVnLSLSco31WbfoBGNLKKxFRFrulJxgFBGRtqGwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcQCFtYiIAyisRUQcQGEtIuIACmsREQdQWIuIOIDCWkTEARTWIiIOoLAWEXEAhbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwlpExAEU1iIiDqCwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcYAmw7quro7JkyfTv39/unTpwsUXX8zy5ctPR20iInJAk2EdiUTIycnhtddeo7S0lCeeeIK77rqLzz///HTUJyIigFFZWWm3dKGhQ4fy6KOPcs011zQ6T2pqKuFw+CsVJyLyTWNZFoFA4JjpLe6zLi8vp7i4mLy8vFNSmIiINK1FYR0Oh7n33nsZN24cubm5rVWTiIgcpdlhHYvFmDhxIh6Ph9mzZ7dmTSIichRXc2aybZvJkydTXl7O4sWLcbvdrV2XiIgcpllh/dBDD1FUVMQrr7yC3+9v7ZpEROQoTY4GKS0t5dxzz8Xr9eJyHcr2uXPnctNNNzW6nEaDiIi0XGOjQZo8sj7zzDOprKxslaJERKR59HVzEREHUFiLiDiAwlpExAEU1iIiDqCwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB1BYi4g4gMJaRMQBFNYiIg6gsBYRcQCFtYiIAyisRUQcQGEtIuIACmsREQdQWIuIOIDCWkTEARTWIiIOoLAWEXEAhbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwlpExAEU1iIiDqCwFhFxAIW1iIgDKKxFRBxAYS0i4gAKaxERB2hWWC9YsIARI0bQuXNnJk2a1No1iYjIUVzNmSkzM5OpU6fy9ttvEwwGW7smERE5SrPC+uqrrwZg/fr1lJWVtWpBIiJyLPVZi4g4gMJaRMQBFNYiIg6QcGG9dq3Bm28mXFkiIm2qWScYI5EIkUiEaDRKNBolFArhcrlwuZq1eIvMnm2xfbvBqFGxU962iIhTNesQdvbs2WRmZjJ37lwWLVpEZmYms2fPbpWC8vJsiooMIpFWaV5ExJGMyspKuzUaTk1NJRwOt3i5P//Z5N573WzYUE9ubquUJiKSsCzLIhAIHDM94TqH+/WLB/SnnxptXImISOJIuLDu0yce1oWFCmsRkYMSLqxTUqBbN1tH1iIih0m4sAbIy4uxaZPCWkTkoIQM6379bD77TCNCREQOSsiwzsuzqa832LpVR9ciIpDAYQ06ySgiclBChnXfvhq+JyJyuIQMa40IERE5UkKGNWhEiIjI4RI2rDUiRETkkIQN64MjQkpKdHQtIpLQYQ06ySgiAgkc1hoRIiJySMKG9cERIRprLSKSwGEN8REhCmsRkQQPa40IERGJS+iw7ttXI0JERCDBw1q/GiMiEpfQYX1wRIj6rUXkmy6hwzolBc48U9cIERFJ6LAG6NdPI0JERBwQ1jZFRRoRIiLfbAkX1ks+W8LCDQsbHvfta1NXpxEhIvLNllBhbds2f9rwJya8PoFffvBLQCNCREQgwcLaMAxeuu4lru9zPY++/ShPvvMkffrEAHj5ZZNgsI0LFBFpI662LuBoXpeXP1/zZ9L/kc4za59hX3AfE374axb81sMHH5g8+2yEK6+MtXWZIiKnVUIdWR9kmRbPj3qeqRdO5YWPX6Di0ltZ+loNXq/Ndde5ufFGFyUlbV2liMjpY1RWVtqt0XBqairhcPgrt/Ps+8/y4xU/Jisli+tzx8KGW/jDrIHEogajR8e47roYo0bFSEk5BUWLiLQxy7IIBALHTE/4sAZYvnU5v1v/O17f8jrhWJie7frSYcd4il+7hn2bzsHng5EjY4weHePcc21yc22Skk7JqkVETitHh/VB+4L7ePmzl3lp40u8u+NdADp5cjhj/xV8ueZ7VHx4GYTSMQyb7t3jl1jt18+mXz+bs8+26dPHxuc7pSWJiJxSX4uwPtyOqh0sL1nOsq3LKNhWQFVdFQBpVmfSImdh7u9JbVlPKjb3JlreB/b1xqxvR69eNj162OTkQEZOCH/n7fg7lTOk+zn06JJEx45gJmRPvoh8E3ztwvpw4WiY93e+z9oda9lasZWtlfFbWVUZNoc2L8nujC/Qi1A4TMhbSixp12GN+GHLSMyia8nYP4bs9u3p0AHat7fp2DF+36EDtGtn0759/D49HdLT49OTksDQUHAR+Yq+1mHdmFAkxLbKbWzet5nNFZvj9/s243P56JLahezkrqREuxKuTmfNzhV8ULWU/XYZhm2RGhhAJGITJkjUCBIzg2BGIOaGmAuiB+7r0iDYESPUEV+sA0l0IiXaleRwD9LtHqSb2fh9Fj4f+P3g99t4fFH8fhufx4XHAx6Pjdsdfz4pCZKT7QP34PJEwQphuOrBVYfbHSPd345Unx+Xy8Dl0oeEyNfJVwrriooKJk+ezIoVK+jQoQNPPvkkY8eOPeEyiRDWLWXbNh9++SFLipawbuc6vC4vfpcfn8uH30oiErYI1kWoDUWorQsTrAtTVV/N/vBeaqL7CLKXenP/EW0aMTdWMIOYWY9tBbGtIFgHLnQS8UA4GeqT4/fY4A6CKwiuUPxvM3r8YiMeCLWHYAcItcOIJEEkCTOSjBHxY1gxDE8NeGvAU43tDmDaLsyYHzPmw7K9WLYft52ClxR8ZjI+MxWP5cUwo/H1GlEwI1iGhWW4cRluLDxYhkWtsYdqY0f8Zu4gZOzDb3ckxc4ixcgkjSySjI64LAuX4cJlunBbLsJGDQF2UUM5NfZuauzduA0PSVY7kqxUkqw0/FYqbtONxYF1Gm5cphuXaWJZBm7LxOUysUwLk/jNwMQ0TALR/ewP76EqspvK8B5qo1V08HUiIymLzORMMlMy6Zx8BsmeFJLdySS5kkh2JwMGoUiIUKTuwH2IqB3Ftm1sYgfubXxuH0luP0luH0keH363D4/Lwu2y8LgsvG4XGDaRWOSIW9SOErNjxOwY0ViMWCyGcaC7zSD+aWsaJh7Lg9flxWvFb4ZhUB+tpz5aT120jvpoPbZ97FvWNOLbb5kWlmFhGsf25UXtKPXResLRMOFYmHA0/v60zPj8lmHhMl0N+73f5ccyrRa/j8LRMDXhGoLhIF6Xl2R3csO2HGTbNnXROmrDtdRF6w57baLEiDW8LgYGhmFgGiZJ7iRSPal4LM8R66sN17IvuI99wX2EY2HSfemkedNI96bjttwnrDVmx6ipryEYCR7xGliGhU28xrpIXcNr7zJd+F1+kt3JJHuScZkubNuO7zPREMFwkGAkSNe0rsfU2VxfKax/8IMfEIvFeO655/jXv/7FzTffzD/+8Q/y8vIaXeZkw3ravHVs/bKC9BQfHdI8dEz30indS2qSC7/XTZLXjc9jkeRz47ZMLMuMv3ktE9M0sCwD0zAwzQP3h/1tGGCaRsORqG3bDX8fuj+0Q8WXOfKwtamj2PpoPdurtlNSWcK2/dvYVrmNXYFdeK0Dwe/24Xf5icWgpq6WqlCAmroANfW12DEDK+bHtH0YUR9GxIcZ82FEvRDzYES9RCMmtbH9BGIV1MYqqLUrCNlVhKk9cAsSNgIYtgt3LAUrlowrmoIZTSZGhIgRIkqIqFFHxKglYtYQMWuIuqrj/zm0RE0GRnUXzJouEOyA7d+LnfwFdvIXkPLloQ+lo0XdEOh84HYGWGHw7gdv1aGbFW78g6o5ajtA7Rnx/3yS9kDqTnDVnXx731BGzI0R84ARwyYGRhTbOBCmMU/8eduNabuJGfXEXAFss/7YhmwTK5qMaXuJmUGiZi0YJ/dPvRHz4IqmYtoewq4KYmao0XmtWBJWzI9huzBxYdhuDNsiatYSNquIWseGYkvEt/vYnCu4bgPD+uSeVJsnHdaBQIDu3bvz3nvv0atXLwAmTJhAdnY2P/vZzxpd7mTDuvu0a/ky9c0WL3fa2MdJ6+bsdMdbrilNtXt0m43Nf3C+1qjhRPWccifZfrPqOs48zX19T+U6T0pLQu/wdTa13NH1NTb/aeqHa8396yQ/OIDj1jXn7BXcf/2Ak2qusbBu8uvmW7ZsweVyNQQ1wDnnnMOaNWuatdKW2v5fr7Z4GRGRrwuzkeFoTYZ1IBAgNTX1iGlpaWnU1NSccLnq6uoWlCciIifS5Iji5OTkY4K3qqqKFH2/W0TktGkyrHv16kUkEqG4uLhh2saNG094clFERE6tZh1ZX3XVVcycOZNAIMA///lP3njjDW6++ebTUZ+IiNDMS6TOmTOHYDBI7969ueeee5gzZ46OrEVETqNW+wajiIicOrpkkYiIAyisRUQcIKHCuqKigltuuYXs7Gz69+/P4sWL27qkRi1YsIARI0bQuXNnJk2adMRzq1atYtCgQWRlZTFmzBhKS0vbqMrjq6urY/LkyfTv358uXbpw8cUXs3z58obnE71+iH+Ltk+fPnTt2pULLriAhQsXNjznhPoBiouLycjIYMKECQ3TFi9eTP/+/cnOzmb8+PFUVFS0YYXHN3r0aDIyMsjJySEnJ4eBAwc2POeE+gHy8/MZPHgw2dnZnHfeeaxduxZI7H0nocJ66tSpeDweioqKeOGFF5gyZQqFhYVtXdZxZWZmMnXqVG699dYjpu/du5fbbruNadOmUVJSwoABA7j77rvbqMrji0Qi5OTk8Nprr1FaWsoTTzzBXXfdxeeff+6I+gEefPBBNmzYwPbt23nppZd4+umnWb9+vWPqh/j+fv755zc8Liws5MEHH2T+/PkUFRWRlJTElClT2rDCxs2ePZuysjLKyspYt24d4Jz6V6xYwZNPPsnzzz/Pjh07eP311+nevXvC7zsJ8+vmgUCApUuX8t5775GSksJFF13EqFGj+Nvf/nbCa5C0lauvvhqA9evXU1ZW1jD91VdfpW/fvlx77bUAPPbYY/Ts2ZOioiJyc0/uwi6nWnJyMo8//njD41GjRnHmmWeyfv16KioqEr5+4IjRSMaBC26VlJSwfv16R9Sfn59Pu3btGDx4MCUHfv158eLFjBo1imHDhgEwbdo0Bg8eTHV19THfIk5ETql/1qxZPPLIIwwaNAiA7OxsAP74xz8m9L6TMEfWjV2DJFGPrBtTWFhI//79Gx4nJyfTo0ePhN6O8vJyiouLycvLc1T9U6ZMISsri0GDBpGRkcHll1/uiPqrqqqYOXMmM2bMOGL60bX36NEDj8dzxBfSEsX06dM566yzGDlyJKtXrwacUX80GuXjjz9m7969DBgwgH79+vHwww8TDAYTft9JmLA+2WuQJJpAIEBaWtoR0xJ5O8LhMPfeey/jxo0jNzfXUfXPmTOHHTt28MYbb3DVVVfh9XodUf+MGTO47bbbyMnJOWJ6Y7Un2nV2pk+fzvr16yksLOSOO+5g3LhxlJSUOKL+8vJywuEwS5Ys4Y033mD16tVs2LCBX/ziFwm/7yRMWH9drkFyvO2orq5OyO2IxWJMnDgRj8fD7NmzAWfVD/ErO1500UXs3LmTF198MeHr37BhA6tWreK+++475rnGak+kLgSAgQMHkpqaitfrZfz48QwZMoRly5Y5on6/3w/ET1BnZmbSsWNH7rvvvhPWnyj7TsKE9dflGiR5eXls3Lix4XEgEKCkpCThtsO2bSZPnkx5eTkLFy7E7Y7/ooZT6j9aJBJpqDOR61+zZg2lpaX079+f3Nxcfv3rX7N06VIuueSSY2rftm0bdXV19OzZsw0rbpphGNi27Yj609PTycnJOeJHRQ7+nej7TsKEtdOuQRKJRAiFQkSjUaLRKKFQiEgkwpgxYygsLGTJkiWEQiF+/vOfc/bZZyfECYrDPfTQQxQVFfHXv/614WgDcET9u3fvJj8/n5qaGqLRKAUFBeTn5zN8+PCEr//OO+/k448/ZvXq1axevZq77rqLK664gpdffpmxY8fy5ptvsnbtWgKBADNnzuSqq65KqCPTyspKCgoKGvb3RYsWsXbtWi677DJH1A8wfvx4FixYwO7du6msrOQ3v/kNI0eOTPh9J6G+bl5RUcH999/PypUrm/1bj21l1qxZPPPMM0dMe/TRR3n88cdZuXIlDz/8MNu3b+eCCy5g3rx5dOvWrY0qPVZpaSnnnnsuXq8Xl+vQgKC5c+dy0003JXz9e/bs4fbbb2fjxo3Ytk3Xrl2ZOHEid9xxB0DC13+4WbNmUVJSwoIFC4D4iIrp06ezb98+hg8fzrx582jfvn0bV3nInj17GDt2LJs3b8Y0TXJzc5k2bRqXXnopkPj1Q/w8zWOPPcbixYvx+Xxce+21PPXUU/h8voTedxIqrEVE5PgSphtEREQap7AWEXEAhbWIiAMorEVEHEBhLSLiAAprEREHUFiLiDiAwlpExAH+P6tP2loxa6kPAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3FBn4V5-Krkt"
      },
      "source": [
        "## Intersection over union\n",
        "\n",
        "Calculate the I-O-U metric to evaluate the model's performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YFqJxt3_VrCm"
      },
      "source": [
        "def intersection_over_union(pred_box, true_box):\n",
        "    xmin_pred, ymin_pred, xmax_pred, ymax_pred =  np.split(pred_box, 4, axis = 1)\n",
        "    xmin_true, ymin_true, xmax_true, ymax_true = np.split(true_box, 4, axis = 1)\n",
        "\n",
        "    smoothing_factor = 1e-10\n",
        "\n",
        "    xmin_overlap = np.maximum(xmin_pred, xmin_true)\n",
        "    xmax_overlap = np.minimum(xmax_pred, xmax_true)\n",
        "    ymin_overlap = np.maximum(ymin_pred, ymin_true)\n",
        "    ymax_overlap = np.minimum(ymax_pred, ymax_true)\n",
        "\n",
        "    pred_box_area = (xmax_pred - xmin_pred) * (ymax_pred - ymin_pred)\n",
        "    true_box_area = (xmax_true - xmin_true) * (ymax_true - ymin_true)\n",
        "\n",
        "    overlap_area = np.maximum((xmax_overlap - xmin_overlap), 0)  * np.maximum((ymax_overlap - ymin_overlap), 0)\n",
        "    union_area = (pred_box_area + true_box_area) - overlap_area\n",
        "    \n",
        "    iou = (overlap_area + smoothing_factor) / (union_area + smoothing_factor)\n",
        "\n",
        "    return iou"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jFVovcUUVs1"
      },
      "source": [
        "### Visualize predictions\n",
        "The following code will make predictions and visualize both the classification and the predicted bounding boxes.\n",
        "- The true bounding box labels will be in green, and the model's predicted bounding boxes are in red.\n",
        "- The predicted number is shown below the image."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w12OId8Mz7dF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "outputId": "93fa2e11-9933-4d83-b885-280c7a9327f1"
      },
      "source": [
        "# recognize validation digits\n",
        "predictions = model.predict(validation_digits, batch_size=64)\n",
        "predicted_labels = np.argmax(predictions[0], axis=1)\n",
        "\n",
        "predicted_bboxes = predictions[1]\n",
        "\n",
        "iou = intersection_over_union(predicted_bboxes, validation_bboxes)\n",
        "\n",
        "iou_threshold = 0.6\n",
        "\n",
        "print(\"Number of predictions where iou > threshold(%s): %s\" % (iou_threshold, (iou >= iou_threshold).sum()))\n",
        "print(\"Number of predictions where iou < threshold(%s): %s\" % (iou_threshold, (iou < iou_threshold).sum()))\n",
        "\n",
        "\n",
        "display_digits_with_boxes(validation_digits, predicted_labels, validation_labels, predicted_bboxes, validation_bboxes, iou, \"True and Predicted values\")"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "157/157 [==============================] - 1s 6ms/step\n",
            "Number of predictions where iou > threshold(0.6): 9957\n",
            "Number of predictions where iou < threshold(0.6): 43\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "R59VEMPlrX3o"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}