ObjectLocalization.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ObjectLocalization.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNQWot1T7reMKh5dLXyfrhC",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/madhumilan/DL-in-Computer-Vision/blob/main/ObjectLocalization.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kIqhomihVasR"
      },
      "source": [
        "Image Classification and Object Localization\n",
        "\n",
        "This notebook builds a CNN from scratch to\n",
        "\n",
        "\n",
        "*   classify an image\n",
        "*   localize it by drawing bounding boxes\n",
        "\n",
        "The dataset used is [MNIST](http://yann.lecun.com/exdb/mnist/) and sythesized to a custom dataset by:\n",
        "\n",
        "\n",
        "\n",
        "*   Placing each \"digit\" image on a black canvas of width 75 x 75 at random locations.\n",
        "*   Calculating the corresponding bounding boxes for those \"digits\".\n",
        "\n",
        "The bounding box prediction is modelled as a \"regression\" task, which means that the model will predict a numeric value (as opposed to a category).\n",
        "\n",
        "\n",
        "**Imports**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zaQq5y4CU3fE",
        "outputId": "6a4a018f-d576-4b5f-b36a-68dc0d3e4b60"
      },
      "source": [
        "import os, re, time, json\n",
        "import PIL.Image, PIL.ImageFont, PIL.ImageDraw\n",
        "import numpy as np\n",
        "try:\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "\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": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tensorflow version 2.4.1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MFmMIRw6qqUa"
      },
      "source": [
        "**Visualization Utilities**\n",
        "\n",
        "These functions are used to draw bounding boxes around the digits."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K8b_CbuWqZ7a"
      },
      "source": [
        "#@title Plot Utilities for Bounding Boxes [RUN ME]\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",
        "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)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVEmiUKyrSU7"
      },
      "source": [
        "These utilities are used to visualize the data and predictions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PTcJkFv_rCou"
      },
      "source": [
        "#@title Visualization Utilities [RUN ME]\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": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KQXTrzBPrnFO",
        "outputId": "f3dcabba-f1c5-4a0f-8688-4ceca0983854"
      },
      "source": [
        "\n",
        "# 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.experimental.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)\n",
        "\n",
        "BATCH_SIZE = 64 * strategy.num_replicas_in_sync\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."
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Initializing the TPU system: grpc://10.103.237.42:8470\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Initializing the TPU system: grpc://10.103.237.42:8470\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Clearing out eager caches\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Clearing out eager caches\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Finished initializing TPU system.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Finished initializing TPU system.\n",
            "WARNING:absl:`tf.distribute.experimental.TPUStrategy` is deprecated, please use  the non experimental symbol `tf.distribute.TPUStrategy` instead.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Found TPU system:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Found TPU system:\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores: 8\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores: 8\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Workers: 1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Workers: 1\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Running on TPU  ['10.103.237.42:8470']\n",
            "Number of accelerators:  8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTW47HdawC0I"
      },
      "source": [
        "**Loading and Preprocessing the Dataset**\n",
        "\n",
        "Define some helper functions that will pre-process your data:\n",
        "\n",
        "\n",
        "\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.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YT6YyCNHvlIW",
        "outputId": "421279cc-526c-4f1a-c6a4-4f0d43b6125a"
      },
      "source": [
        "'''\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",
        "    print(xmin)\n",
        "    ymin = tf.random.uniform((), 0 , 48, dtype=tf.int32)\n",
        "    print(ymin)\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": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tensor(\"random_uniform:0\", shape=(), dtype=int32)\n",
            "Tensor(\"random_uniform_1:0\", shape=(), dtype=int32)\n",
            "Tensor(\"random_uniform:0\", shape=(), dtype=int32)\n",
            "Tensor(\"random_uniform_1:0\", shape=(), dtype=int32)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOKkUJcAxgbT"
      },
      "source": [
        "Visualize Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 511
        },
        "id": "eqD6BySZxcAB",
        "outputId": "067b0c62-571b-4d02-cd7b-a6515f953336"
      },
      "source": [
        "\n",
        "(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\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87n-QFT5yTqU"
      },
      "source": [
        "**Define the Network**\n",
        "\n",
        "feature_extractor: these convolutional layers extract the features of the image.\n",
        "\n",
        "classifier: This define the output layer that predicts among 10 categories (digits 0 through 9)\n",
        "\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",
        "\n",
        "final_model: This combines the layers for feature extraction, classification and bounding box prediction.\n",
        "\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",
        "\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",
        "\n",
        "define_and_compile_model: choose the optimizer and metrics, then compile the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pFUr7ZlQxm-t",
        "outputId": "7a0879c8-506f-4ca3-929c-f58516ab22d5"
      },
      "source": [
        "'''\n",
        "Feature extractor is the CNN that is made up of convolutional and pooling layers\n",
        "'''\n",
        "def feature_extractor(inputs):\n",
        "  #First convolutional layer\n",
        "  x = tf.keras.layers.Conv2D(16, 3, activation='relu', input_shape=(75,75,1))(inputs)\n",
        "  x = tf.keras.layers.MaxPooling2D((2,2))(x)\n",
        "\n",
        "  #second layer\n",
        "  x = tf.keras.layers.Conv2D(32, 3, activation='relu')(x)\n",
        "  x = tf.keras.layers.MaxPooling2D((2,2))(x)\n",
        "\n",
        "  #third layer\n",
        "  x = tf.keras.layers.Conv2D(64, 3, activation='relu')(x)\n",
        "  x = tf.keras.layers.MaxPooling2D((2,2))(x)\n",
        "\n",
        "  return x\n",
        "\n",
        "'''\n",
        "dense_layers adds a flatten and a dense layer\n",
        "'''\n",
        "def dense_layers(inputs):\n",
        "  x = tf.keras.layers.Flatten()(inputs)\n",
        "  x = tf.keras.layers.Dense(128, activation='relu')(x)\n",
        "\n",
        "  return x\n",
        "\n",
        "'''\n",
        "classifier defines the classifier output\n",
        "'''  \n",
        "def classifier(inputs):\n",
        "  classification_output = tf.keras.layers.Dense(10, activation='softmax', name='classification')(inputs)\n",
        "  return classification_output\n",
        "\n",
        "'''\n",
        "This function defines the regression output for bounding box prediction\n",
        "'''\n",
        "def bounding_box_regression(inputs):\n",
        "  x = tf.keras.layers.Dense(4, name='regression_output')(inputs)\n",
        "  return x\n",
        "\n",
        "'''\n",
        "The final model\n",
        "'''\n",
        "def final_model(inputs):\n",
        "  feature_output = feature_extractor(inputs)\n",
        "  dense_output = dense_layers(feature_output)\n",
        "\n",
        "  '''The model branching happens here.\n",
        "  The dense layers output gets fed into two branches\n",
        "  classification_output and regression_output\n",
        "  '''\n",
        "  classification_output = classifier(dense_output)\n",
        "  regression_output = bounding_box_regression(dense_output)\n",
        "\n",
        "  model = tf.keras.Model(inputs=inputs, outputs=[classification_output, regression_output])\n",
        "\n",
        "  return model\n",
        "\n",
        "\n",
        "def compile_model(inputs):\n",
        "  model = final_model(inputs)\n",
        "\n",
        "  model.compile(optimizer='adam',\n",
        "                loss = {'classification':'categorical_crossentropy',\n",
        "                        'regression_output':'mse'},\n",
        "                metrics = {'classification':'accuracy',\n",
        "                           'regression_output':'mse'}\n",
        "                )\n",
        "  return model\n",
        "\n",
        "with strategy.scope():\n",
        "  inputs = tf.keras.layers.Input(shape=(75,75,1))\n",
        "  model = compile_model(inputs)\n",
        "  \n",
        "model.summary()\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"model_2\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_4 (InputLayer)            [(None, 75, 75, 1)]  0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_7 (Conv2D)               (None, 73, 73, 16)   160         input_4[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_7 (MaxPooling2D)  (None, 36, 36, 16)   0           conv2d_7[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_8 (Conv2D)               (None, 34, 34, 32)   4640        max_pooling2d_7[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_8 (MaxPooling2D)  (None, 17, 17, 32)   0           conv2d_8[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_9 (Conv2D)               (None, 15, 15, 64)   18496       max_pooling2d_8[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_9 (MaxPooling2D)  (None, 7, 7, 64)     0           conv2d_9[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "flatten_2 (Flatten)             (None, 3136)         0           max_pooling2d_9[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "dense_2 (Dense)                 (None, 128)          401536      flatten_2[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "classification (Dense)          (None, 10)           1290        dense_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "regression_output (Dense)       (None, 4)            516         dense_2[0][0]                    \n",
            "==================================================================================================\n",
            "Total params: 426,638\n",
            "Trainable params: 426,638\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QLaMUB94A7jc"
      },
      "source": [
        "\n",
        "Train and validate the model\n",
        "\n",
        "Train the model.\n",
        "\n",
        "Choose the number of epochs depending on the level of performance that you want and the time that you have.\n",
        "Each epoch will take just a few seconds if you're using the TPU."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vpNm3CIFAD5B",
        "outputId": "fd6c6dbd-c12c-40a5-ac88-2a836c8c2b30"
      },
      "source": [
        "EPOCHS = 10\n",
        "steps_per_epoch = 60000//BATCH_SIZE\n",
        "validation_steps = 1\n",
        "\n",
        "history = model.fit(training_dataset,\n",
        "                    steps_per_epoch=steps_per_epoch,\n",
        "                    validation_data=validation_dataset,\n",
        "                    validation_steps=validation_steps,\n",
        "                    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": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "117/117 [==============================] - 10s 46ms/step - loss: 2.2044 - classification_loss: 2.1655 - regression_output_loss: 0.0389 - classification_accuracy: 0.1881 - regression_output_mse: 0.0389 - val_loss: 0.8779 - val_classification_loss: 0.8438 - val_regression_output_loss: 0.0340 - val_classification_accuracy: 0.7446 - val_regression_output_mse: 0.0340\n",
            "Epoch 2/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.6780 - classification_loss: 0.6520 - regression_output_loss: 0.0259 - classification_accuracy: 0.8089 - regression_output_mse: 0.0259 - val_loss: 0.3315 - val_classification_loss: 0.3151 - val_regression_output_loss: 0.0164 - val_classification_accuracy: 0.9063 - val_regression_output_mse: 0.0164\n",
            "Epoch 3/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.3388 - classification_loss: 0.3230 - regression_output_loss: 0.0158 - classification_accuracy: 0.9033 - regression_output_mse: 0.0158 - val_loss: 0.2393 - val_classification_loss: 0.2261 - val_regression_output_loss: 0.0133 - val_classification_accuracy: 0.9322 - val_regression_output_mse: 0.0133\n",
            "Epoch 4/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.2437 - classification_loss: 0.2316 - regression_output_loss: 0.0121 - classification_accuracy: 0.9304 - regression_output_mse: 0.0121 - val_loss: 0.1872 - val_classification_loss: 0.1769 - val_regression_output_loss: 0.0103 - val_classification_accuracy: 0.9452 - val_regression_output_mse: 0.0103\n",
            "Epoch 5/10\n",
            "117/117 [==============================] - 4s 37ms/step - loss: 0.2000 - classification_loss: 0.1899 - regression_output_loss: 0.0100 - classification_accuracy: 0.9430 - regression_output_mse: 0.0100 - val_loss: 0.1627 - val_classification_loss: 0.1533 - val_regression_output_loss: 0.0094 - val_classification_accuracy: 0.9542 - val_regression_output_mse: 0.0094\n",
            "Epoch 6/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.1700 - classification_loss: 0.1614 - regression_output_loss: 0.0087 - classification_accuracy: 0.9502 - regression_output_mse: 0.0087 - val_loss: 0.1361 - val_classification_loss: 0.1287 - val_regression_output_loss: 0.0074 - val_classification_accuracy: 0.9604 - val_regression_output_mse: 0.0074\n",
            "Epoch 7/10\n",
            "117/117 [==============================] - 4s 36ms/step - loss: 0.1409 - classification_loss: 0.1341 - regression_output_loss: 0.0068 - classification_accuracy: 0.9600 - regression_output_mse: 0.0068 - val_loss: 0.1191 - val_classification_loss: 0.1130 - val_regression_output_loss: 0.0061 - val_classification_accuracy: 0.9654 - val_regression_output_mse: 0.0061\n",
            "Epoch 8/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.1241 - classification_loss: 0.1183 - regression_output_loss: 0.0059 - classification_accuracy: 0.9638 - regression_output_mse: 0.0059 - val_loss: 0.1157 - val_classification_loss: 0.1104 - val_regression_output_loss: 0.0053 - val_classification_accuracy: 0.9652 - val_regression_output_mse: 0.0053\n",
            "Epoch 9/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.1176 - classification_loss: 0.1125 - regression_output_loss: 0.0051 - classification_accuracy: 0.9646 - regression_output_mse: 0.0051 - val_loss: 0.1084 - val_classification_loss: 0.1035 - val_regression_output_loss: 0.0049 - val_classification_accuracy: 0.9652 - val_regression_output_mse: 0.0049\n",
            "Epoch 10/10\n",
            "117/117 [==============================] - 4s 35ms/step - loss: 0.1055 - classification_loss: 0.1008 - regression_output_loss: 0.0047 - classification_accuracy: 0.9687 - regression_output_mse: 0.0047 - val_loss: 0.0871 - val_classification_loss: 0.0834 - val_regression_output_loss: 0.0038 - val_classification_accuracy: 0.9728 - val_regression_output_mse: 0.0038\n",
            "1/1 [==============================] - 1s 743ms/step - loss: 0.0852 - classification_loss: 0.0815 - regression_output_loss: 0.0037 - classification_accuracy: 0.9724 - regression_output_mse: 0.0037\n",
            "Validation accuracy: 0.9723999500274658\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "id": "-WVQIbCZCJAj",
        "outputId": "caf15972-5391-448d-a8c0-d27fa7c269b9"
      },
      "source": [
        "plot_metrics(\"classification_loss\", \"Classification Loss\")\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "id": "ctMRI_MFCXkD",
        "outputId": "913df591-d8d1-4ab6-f6d3-9c6a95c1095e"
      },
      "source": [
        "plot_metrics(\"regression_output_loss\", \"Bounding Box Loss\")"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWsAAAELCAYAAAAfsqciAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAWuUlEQVR4nO3deXhU9b3H8c+ZSTJZCCAg2QhRgSAYLQYEWRQsiqigVxERqQu9LIJpHyuB1qsVtQbvfRB56lrcuNXaKty4YFELREAQl0ZBtIKBgKQQIIgZSIYsM5O5fwTCJCFkgklOfvJ+8eRh5syZc74zeXhzODMZLLfbHRAAoE1z2D0AAKBxxBoADECsAcAAxBoADECsAcAAxBoADECs0eatGXG5vv9ogyQp/9lF+vq/fm/zREDrC7N7ALRNa0ZcrsrvD8pyOmSFheuMC/up7x/mKiohwda5esyY3mLbfr9XXzmjoiRLcrhc6jxkiM57+AGFt2/frPtZM+JypWU9rC5DhzTrdvHTxpE1GpS+6Gld8eXnumzDWkV06awtD2fZPVKLG/LOG7riy881PGeFfIcPa/sTT9s9EiCJWCMETpdL8aNHqXR7fs0yb0mJNs/+nXIGDtWa4SOV//SfFKiqkiRte+IpfTlrTs26R3bv0fu9+qrK55MkfTrpdm1b+IQ+mTBJK/sN0D/vmKLKH4pr1t/z1jKtGT5SORcNVv4zf6o1S/C2j213zxtvac2lP1fOwCG11veXl2vznHu1qv/FWnflGO147kWtHnZZSI85LLaduo68rNZjLt9fpM+n36WcARfrw5FX6t+vL62eY1eBcgZcrEP/+qZmvZyBQ3Xw089C2tcxVRWV2vLIo1o9dLhWDx2uLY88qqqKSklS5Q/F+nzqDK1KH6ScARfr04m/qHm+dyx6QauHjdDKfgP04airdXDDx03aL8zAaRA0yl9Wpr3vvq+O/X5Ws2zLw1nylZRo+AcrVOl2K3fyFLm6nqlu48eFtM3Cd5ZrwIuLFJkQr9z/nK6dLy5W79n3qHTbdn0z9yH1f36ROv7sAn27YKEq9u0/6baKP/9Cl6x4V56d3+njcRMUN+oKtevZQ9uffEZlu/do+Af/kP9ImXKn3hnyY/YeOqT9K3NqPeYv756ldqm9NOKjtfLk79A/75ii6O7J6jz4YqXOnqXNs+ZoyJtL9dXv7lPSDdep86CBIe9Pqj4f7970pYYse0OWLH0xI0P5z/xJvX7za+18abEi4+P080/XS5Lcm76ULEulO3aq4C9/1eDsJYqM66oju/dIfn+T9gszcGSNBm2c+SutSh+kVemDdPCjDTp7yi8lSQG/X3uXv6vUWb9RWLsYRXdL0lm/vEN73loW8ra7jbteMWefJWdkpBKuHq2SLVslSfveX6EzLxuhTgMHyOGKUK+7fyU5rJNuq2fGTDkjI9W+z7lq3+dclWz9tnpb776vc2ZMU3iHDopMiFfKbb9odK4N191YffQ6cKjK9+5V8s03SZLK9u5V8Rcb1Xv2LDldLrXv20fdbhqnPW9WP+bkCeMVnZKij2+8WRUHDij1N3eH/FwcU7js7+qZMUOuzp0V0bmTevxqpva8Xb19R1i4Kg4cUFlhoRzh4ep00QBZliXL6VBVZaVKt29Xlder6G5Jik7p3uR9o+0j1mjQhc88qcu/+FSjvt6oPg/cr88m3aaKAwdUWVysgNenyKTEmnWjkhJVsf/kR8DBIs7sUnPZERkp35EjkqSKoiJFxsfX3BYWHa2Ijh1PeVtRQduKTIivd9+6hrz9fzWPOXnizfp04q3yV1SoYn+Rwjt0UFi7mJp1oxJrP+bkm25Uad42pdw6SQ5XRKP7qquiqKj2c5qYqIqiIknS2VN+qeiU7sq9Y6rWXjZKOxY9L0mKSUnRuff9TtuffEYfXHyJNt09S+X7i5q8b7R9xBqNspxOxV95heRwqjj3C0WccYas8DCV7ymsWae8cK9ccXGSpLCoKFWVldfcVnng+5D35ep6psr37au57i8rU6XbfUpzV2/reEzL9+47ydq1OcLD1e2mcSrbvVuledvkiusq76FD8pV6grZ3/DH7PB5tyfpvdRs/TtuffPqUZnZ17Vr/Oe3aVZIU1i5G5977Ww1fvULpi57Wdy/9uebcdOK1Y3Txa3/RiDWrJFnKm7+gyftG20es0ahAIKD9q3LkO3xYMT3PqY73VaOVt/CP8pV6VLZnj75b/GclXjdWkhTbp49+yM1VWWGhvCUl2rHouZD3FTd6lA6sXqPi3M9VVVmpbX98Uqo6tU/xjb9qtHYsel7eQ4dUvm+/Cl55NeT7Bvx+7cl+U47ISEUld1NUQoLOSO+nvAUL5a+oUMnWb7V76RtKvG6MJGnLI4+qw/nnKW3eH3TmiOH65oGHTr59n0/+ioqaryqfTwljrlb+M4tUefAHVf5QrO1PP6vEa6uf06IP1siza5cCgYDCYtvJcjokh0OlO3bq4MefqKqiUg5XhJyRLsnBH+ufIl5gRIO+mH5XdRQsS1GJiTr/f+YptlcvSVLfB+7TNw9nae3PR8npcqnbTTeq2403SJK6DBuihKuv0kdjrlfEGR119rQpKspZHdI+Y3v1Ut+5v9eX98yWv6xMZ02+Xa74uFOav0fGDH3zwENae9kouc48U4nXjtHu7DdPep8NY2+QLEmWQzHnnK0Ln3mi5jTMzx5/TP964CGtGTpcYe07qOev71KXoUO0f1WOvl+3XkP//pYk6dx752jDtTeo8O13av4Cq+vzKbVf7DxnxnT1uOtO+UpL9dHY/5AkxY2+Uj3uql7vyK5d+ubhR+T9oVhh7dsr+ZaJ6nzxIJVs/VZ5jy1UaX6+HGFh6njhhTrvkZP/RQEzWfznAzhdFLz6mvYuf1eD/vqy3aMATca/l/CTVV50QMWff6FAVZVKd+zUdy8tVtwVl9s9FnBKQjoNcs011yg3N1dhYdWrJyQkKDc3t0UHA36sgLdS//r9gyrbvUdh7WOVcM1V6j7pZrvHAk5JSKdBrrnmGk2YMEG33XZba8wEAKiD0yAAYICQj6y3bt2qQCCgXr166f7779cll1xy0vu0b99egQCvXQJAU5WUlNRbFlKsc3Nz1bt3b0VERCg7O1tz5szRunXrdPbZZzd4n9jYWHm93h83MQCcZpxOpzweT73lIZ0GGTBggGJjY+VyuXTLLbdo0KBBWrFiRbMPCQA4sVM6Z21ZFqc4AKAVNRprt9utnJwclZeXy+fzacmSJdqwYYMuv5z3qwJAa2n0fdY+n0+PPPKItm3bJofDodTUVL366qvq2bNna8wHAFAL/rg5LzACQNP9qBcYAQD2ItYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYIAmxTo/P19xcXGaNm1aS80DADiBJsU6MzNT6enpLTULAKABIcc6OztbHTp00KWXXtqS8wAATiCkWB8+fFjz5s1TVlZWS88DADiBkGKdlZWlW2+9VUlJSS09DwDgBMIaW2Hz5s1au3atPvzww9aYBwBwAo3Gev369SooKFBaWpokyePxyO/3a+vWrQQcAFqJ5Xa7Aydb4ciRIyopKam5/uSTT6qgoECPP/64unTp0uD9YmNj5fV6m29SADgNOJ1OeTyeessbPbKOjo5WdHR0zfWYmBhFRkaeNNQAgObV6JH1qeLIGgCarqEja37cHAAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMQKwBwADEGgAMEFKsp02bpt69eys5OVn9+/fXyy+/3NJzAQCCWG63O9DYSlu2bNE555wjl8ulvLw8jRkzRkuWLFG/fv0avE9sbKy8Xm+zDgsAP3VOp1Mej6fe8pCOrPv06SOXyyVJsixLlmVp586dzTshAKBBIZ+znjVrlhISEnTRRRcpLi5OV1xxRUvOBQAIEtJpkGP8fr8+++wzrV+/XnfffbfCw8MbXJfTIADQdD/qNEjwRgYPHqzCwkK9+OKLzTYcAODkTumtez6fj3PWANCKGo31gQMHlJ2drdLSUvn9fuXk5Cg7O1vDhw9vjfkAAArhnPX333+v2267TV9//bUCgYCSk5M1ffp03X777SfdMOesAaDpGjpn3aQXGJuCWANA0zXLC4wAAHsQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwALEGAAMQawAwQKOxrqioUEZGhtLS0tStWzcNGzZMK1eubI3ZAABHNRprn8+npKQkLV++XAUFBbr//vs1efJk7dq1qzXmAwBIstxud6CpdxoyZIh++9vf6rrrrmtwndjYWHm93h81HACcbpxOpzweT73lTT5nXVRUpPz8fPXp06dZBgMANK5JsfZ6vZo6daomTpyo1NTUlpoJAFBHyLGuqqrS9OnTFRERofnz57fkTACAOsJCWSkQCCgjI0NFRUVaunSpwsPDW3ouAECQkGJ9zz33KC8vT2+99ZaioqJaeiYAQB2NvhukoKBAF1xwgVwul8LCjrd94cKFuummmxq8H+8GAYCma+jdII0eWXfv3l1ut7tFhgIAhIYfNwcAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAAxBrADAAsQYAA4QU6+eee04jRoxQ165dNWPGjJaeCQBQR1goK8XHxyszM1MffPCBysrKWnomAEAdIcX62muvlSRt2rRJe/bsadGBAAD1cc4aAAxArAHAAMQaAAxArAHAACHF2ufzqby8XH6/X36/X+Xl5fL5fC09GwDgqJBiPX/+fMXHx2vhwoVasmSJ4uPjNX/+/JaeDQBwlOV2uwMtseHY2Fh5vd6W2DQA/GQ5nU55PJ56yzlnDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYABiDQAGINYAYICwUFYqLi5WRkaGVq9erU6dOmnu3LkaP358iwz0Tt47+vfhfyvcGa4IZ8TxL0eEwp3h1csdEbVvc0YozBFWa91jl50OZ4vMCQCtKaRYZ2ZmKiIiQnl5efrqq680YcIEpaWlqU+fPs0+UMb/vqD97f/RfBsMWJI/otaXVXXscrhUFXGC28OrLwecsmTJsqzjv1uWHLKkoGUOqeY2S5Yc1vF1T7TMYQVdlyWHJVmOo8uC1nUELbMsS1LQPo9dP3Z7vTlVa5nq3F69XdW+T/BjPMHy6n1Ws45ePrafY5drrtXs/+j61QskqdZ2jq6qo09prW0F36fWtmpmUs3jklT9fQm6XUHPwfFt1F7HOrqzxu57fObjz0Ot246tX+f5cRx/Ao5uL9DA4wr+njW2jePPTd3nst5zG/w9q3s96Ht4bJbj35Das5zwetCVuvs9vk7QBustD9pn0LLg/QXP09AcwRwNzNfQrMHf65rbHXVuP8HjqPtnoe73vX9qvGKiwk885Cmy3G534GQreDwenXXWWfr444/Vs2dPSdK0adOUmJioBx98sMH7xcbGyuv1Nnmgp58v05Zt5fKrUlWWV1WqVJWjsvq6KuW3vApY3qO3Vy/3H12nSpWqkld+K/j3yvrXj26n9vrV69XsR15VyS8pUP0rEFDwLwVdD15HdZad7HdZQZePLbcavl5z2Tp2GUBb9NblX2r0gN6ndF+n0ymPx1NveaNH1tu3b1dYWFhNqCXp/PPP1/r160PaaVP9+s52kto1+X4A8FPgcJz4pcRGY+3xeBQbG1trWfv27VVaWnrS+5WUlDRhPADAyTT6bpCYmJh64T18+LDatePoFwBaS6Ox7tmzp3w+n/Lz82uWff311y3y4iIA4MRCOrIeO3as5s2bJ4/Ho08++UTvvfeeJkyY0BrzAQAU4g/FLFiwQGVlZerVq5emTJmiBQsWcGQNAK2o0bfuAQDsx4+bA4ABiDUAGKBNxbq4uFiTJk1SYmKi0tLStHTpUrtHsk1FRYUyMjKUlpambt26adiwYVq5cqXdY9kuPz9fcXFxmjZtmt2j2C47O1sDBw5UYmKi+vXrpw0bNtg9km127dql8ePHKyUlRampqZo9e7Z8Pp/dYzWrkD4bpLW05meQtHU+n09JSUlavny5kpOTtWLFCk2ePFkfffSRUlJS7B7PNpmZmUpPT7d7DNutXr1ac+fO1eLFi9W/f3/t27fP7pFslZmZqS5duujbb7/VoUOHdP311+uFF17QnXfeafdozabNHFl7PB4tW7ZM9913n9q1a6fBgwdr9OjRev311+0ezRYxMTG69957lZKSIofDodGjR6t79+7atGmT3aPZJjs7Wx06dNCll15q9yi2e/TRRzVnzhxddNFFcjgcSkxMVGJiot1j2WbXrl26/vrrFRkZqbi4OI0cOVJbt261e6xm1WZi3dBnkGzZssXGqdqOoqIi5efnn5b/ypCqf2p23rx5ysrKsnsU2/n9fm3cuFEHDx7UhRdeqL59+2r27NkqKyuzezTbzJgxQ9nZ2Tpy5IgKCwu1atUqjRw50u6xmlWbifWpfgbJ6cDr9Wrq1KmaOHGiUlNT7R7HFllZWbr11luVlJRk9yi2Kyoqktfr1dtvv6333ntP69at0+bNm/XYY4/ZPZpthgwZoq1btyo5OVl9+/ZVv379NGbMGLvHalZtJtZ8BsmJVVVVafr06YqIiND8+fPtHscWmzdv1tq1azVz5ky7R2kToqKiJFV/VHF8fLw6d+6smTNnasWKFTZPZo+qqiqNGzdOY8eOVWFhoXbs2CG32625c+faPVqzajOx5jNI6gsEAsrIyFBRUZFefvllhYc374eZm2L9+vUqKChQWlqaUlNT9dRTT2nZsmWn7bnrjh07KikpqcEP1z/dFBcXa/fu3Zo6dapcLpc6deqkSZMm/eTePdVmYs1nkNR3zz33KC8vT6+99lrN0dTp6I477tDGjRu1bt06rVu3TpMnT9aoUaP0xhtv2D2abW655RY999xzOnDggNxut5599lldeeWVdo9li86dOyslJUUvvfSSfD6f3G63/va3v+m8886ze7Rm1WZiLfEZJMEKCgq0ePFiffXVV+rdu7eSkpKUlJSkJUuW2D1aq4uOjlZcXFzNV0xMjCIjI9WlSxe7R7PNnDlzlJ6erv79+2vgwIE6//zzlZmZafdYtnnllVe0atUq9ejRQ+np6QoPD9e8efPsHqtZ8dkgAGCANnVkDQA4MWINAAYg1gBgAGINAAYg1gBgAGINAAYg1gBgAGINAAb4f1il1B5B7U2tAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RDspE4gLC9XI"
      },
      "source": [
        "\n",
        "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": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "9k4tOfPPDGlL",
        "outputId": "848d629e-8c66-4d60-a5aa-9a90eb761b5f"
      },
      "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": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of predictions where iou > threshold(0.6): 5852\n",
            "Number of predictions where iou < threshold(0.6): 4148\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 11 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "femreSh1DI5d"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}