C3W3_Assignment_segmentation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "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"
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/souvikg544/AdvancedComputerVision/blob/main/C3W3_Assignment_segmentation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k6x_sGPQocpw"
      },
      "source": [
        "# Week 3 Assignment: Image Segmentation of Handwritten Digits\n",
        "\n",
        "<img src='https://drive.google.com/uc?export=view&id=1-WBX7w_R9abwdGmAUBFWWEcJ0LkMppq2' alt='m2nist digits'>\n",
        "\n",
        "In this week's assignment, you will build a model that predicts the segmentation masks (pixel-wise label map) of handwritten digits. This model will be trained on the [M2NIST dataset](https://www.kaggle.com/farhanhubble/multimnistm2nist), a multi digit MNIST. If you've done the ungraded lab on the CamVid dataset, then many of the steps here will look familiar.\n",
        "\n",
        "You will build a Convolutional Neural Network (CNN) from scratch for the downsampling path and use a Fully Convolutional Network, FCN-8, to upsample and produce the pixel-wise label map. The model will be evaluated using the intersection over union (IOU) and Dice Score. Finally, you will download the model and upload it to the grader in Coursera to get your score for the assignment."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Install this package to use Colab's GPU for training\n",
        "!apt install --allow-change-held-packages libcudnn8=8.4.1.50-1+cuda11.6"
      ],
      "metadata": {
        "id": "ptN6wOp1zqBW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "503096bb-3ae5-4c23-ef34-75ad811a9e0d"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "libcudnn8 is already the newest version (8.4.1.50-1+cuda11.6).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "0 upgraded, 0 newly installed, 0 to remove and 30 not upgraded.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cnr0kbM0g2LD"
      },
      "source": [
        "## Exercises\n",
        "\n",
        "We've given you some boilerplate code to work with and these are the 5 exercises you need to fill out before you can successfully get the segmentation masks.\n",
        "\n",
        "* [Exercise 1 - Define the Basic Convolution Block](#exercise-1)\n",
        "* [Exercise 2 - Define the Downsampling Path](#exercise-2)\n",
        "* [Exercise 3 - Define the FCN-8 decoder](#exercise-3)\n",
        "* [Exercise 4 - Compile the Model](#exercise-4)\n",
        "* [Exercise 5 - Model Training](#exercise-5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZ3g9dJxSxmN"
      },
      "source": [
        "## Imports\n",
        "\n",
        "As usual, let's start by importing the packages you will use in this lab."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aifz2907kxYN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45d9cfaa-2a2d-4da3-ec13-864b10ff4982"
      },
      "source": [
        "try:\n",
        "  # %tensorflow_version only exists in Colab.\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "\n",
        "import os\n",
        "import zipfile\n",
        "\n",
        "import PIL.Image, PIL.ImageFont, PIL.ImageDraw\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_datasets as tfds\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "print(\"Tensorflow version \" + tf.__version__)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab only includes TensorFlow 2.x; %tensorflow_version has no effect.\n",
            "Tensorflow version 2.8.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7RYh6cCzXE6R"
      },
      "source": [
        "## Download the dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QUGGF3wfqYni"
      },
      "source": [
        "[M2NIST](https://www.kaggle.com/farhanhubble/multimnistm2nist) is a **multi digit** [MNIST](http://yann.lecun.com/exdb/mnist/). \n",
        "Each image has up to 3 digits from MNIST digits and the corresponding labels file has the segmentation masks.\n",
        "\n",
        "The dataset is available on [Kaggle](https://www.kaggle.com) and you can find it [here](https://www.kaggle.com/farhanhubble/multimnistm2nist)\n",
        "\n",
        "To make it easier for you, we're hosting it on Google Cloud so you can download without Kaggle credentials.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ROok0i9rMcu0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3be78a60-ad5e-4d6f-aaa1-d6974dd5e9ac"
      },
      "source": [
        "# download zipped dataset\n",
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/m2nist.zip \\\n",
        "    -O /tmp/m2nist.zip\n",
        "\n",
        "# find and extract to a local folder ('/tmp/training')\n",
        "local_zip = '/tmp/m2nist.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp/training')\n",
        "zip_ref.close()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-09-13 08:15:10--  https://storage.googleapis.com/laurencemoroney-blog.appspot.com/m2nist.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 173.194.69.128, 173.194.79.128, 108.177.119.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|173.194.69.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 17378168 (17M) [application/zip]\n",
            "Saving to: ‘/tmp/m2nist.zip’\n",
            "\n",
            "/tmp/m2nist.zip     100%[===================>]  16.57M  --.-KB/s    in 0.1s    \n",
            "\n",
            "2022-09-13 08:15:10 (164 MB/s) - ‘/tmp/m2nist.zip’ saved [17378168/17378168]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xy17LYR7XJNa"
      },
      "source": [
        "## Load and Preprocess the Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LXGMrWnkrvpK"
      },
      "source": [
        "This dataset can be easily preprocessed since it is available as **Numpy Array Files (.npy)**\n",
        "\n",
        "1. **combined.npy** has the image files containing the multiple MNIST digits. Each image is of size **64 x 84** (height x width, in pixels).\n",
        "\n",
        "2. **segmented.npy** has the corresponding segmentation masks. Each segmentation mask is also of size **64 x 84**.\n",
        "\n",
        "This dataset has **5000** samples and you can make appropriate training, validation, and test splits as required for the problem.\n",
        "\n",
        "With that, let's define a few utility functions for loading and preprocessing the dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jy_pw5I2-xLP"
      },
      "source": [
        "BATCH_SIZE = 32\n",
        "\n",
        "def read_image_and_annotation(image, annotation):\n",
        "  '''\n",
        "  Casts the image and annotation to their expected data type and\n",
        "  normalizes the input image so that each pixel is in the range [-1, 1]\n",
        "\n",
        "  Args:\n",
        "    image (numpy array) -- input image\n",
        "    annotation (numpy array) -- ground truth label map\n",
        "\n",
        "  Returns:\n",
        "    preprocessed image-annotation pair\n",
        "  '''\n",
        "\n",
        "  image = tf.cast(image, dtype=tf.float32)\n",
        "  image = tf.reshape(image, (image.shape[0], image.shape[1], 1,))\n",
        "  annotation = tf.cast(annotation, dtype=tf.int32)\n",
        "  image = image / 127.5\n",
        "  image -= 1\n",
        "\n",
        "  return image, annotation\n",
        "\n",
        "\n",
        "def get_training_dataset(images, annos):\n",
        "  '''\n",
        "  Prepares shuffled batches of the training set.\n",
        "  \n",
        "  Args:\n",
        "    images (list of strings) -- paths to each image file in the train set\n",
        "    annos (list of strings) -- paths to each label map in the train set\n",
        "\n",
        "  Returns:\n",
        "    tf Dataset containing the preprocessed train set\n",
        "  '''\n",
        "  training_dataset = tf.data.Dataset.from_tensor_slices((images, annos))\n",
        "  training_dataset = training_dataset.map(read_image_and_annotation)\n",
        "\n",
        "  training_dataset = training_dataset.shuffle(512, reshuffle_each_iteration=True)\n",
        "  training_dataset = training_dataset.batch(BATCH_SIZE)\n",
        "  training_dataset = training_dataset.repeat()\n",
        "  training_dataset = training_dataset.prefetch(-1)\n",
        "\n",
        "  return training_dataset\n",
        "\n",
        "\n",
        "def get_validation_dataset(images, annos):\n",
        "  '''\n",
        "  Prepares batches of the validation set.\n",
        "  \n",
        "  Args:\n",
        "    images (list of strings) -- paths to each image file in the val set\n",
        "    annos (list of strings) -- paths to each label map in the val set\n",
        "\n",
        "  Returns:\n",
        "    tf Dataset containing the preprocessed validation set\n",
        "  '''\n",
        "  validation_dataset = tf.data.Dataset.from_tensor_slices((images, annos))\n",
        "  validation_dataset = validation_dataset.map(read_image_and_annotation)\n",
        "  validation_dataset = validation_dataset.batch(BATCH_SIZE)\n",
        "  validation_dataset = validation_dataset.repeat()\n",
        "\n",
        "  return validation_dataset\n",
        "\n",
        "\n",
        "def get_test_dataset(images, annos):\n",
        "  '''\n",
        "  Prepares batches of the test set.\n",
        "  \n",
        "  Args:\n",
        "    images (list of strings) -- paths to each image file in the test set\n",
        "    annos (list of strings) -- paths to each label map in the test set\n",
        "\n",
        "  Returns:\n",
        "    tf Dataset containing the preprocessed validation set\n",
        "  '''\n",
        "  test_dataset = tf.data.Dataset.from_tensor_slices((images, annos))\n",
        "  test_dataset = test_dataset.map(read_image_and_annotation)\n",
        "  test_dataset = test_dataset.batch(BATCH_SIZE, drop_remainder=True)\n",
        "\n",
        "  return test_dataset\n",
        "\n",
        "\n",
        "def load_images_and_segments():\n",
        "  '''\n",
        "  Loads the images and segments as numpy arrays from npy files \n",
        "  and makes splits for training, validation and test datasets.\n",
        "\n",
        "  Returns:\n",
        "    3 tuples containing the train, val, and test splits\n",
        "  '''\n",
        "\n",
        "  #Loads images and segmentation masks.\n",
        "  images = np.load('/tmp/training/combined.npy')\n",
        "  segments = np.load('/tmp/training/segmented.npy')\n",
        "\n",
        "  #Makes training, validation, test splits from loaded images and segmentation masks.\n",
        "  train_images, val_images, train_annos, val_annos = train_test_split(images, segments, test_size=0.2, shuffle=True)\n",
        "  val_images, test_images, val_annos, test_annos = train_test_split(val_images, val_annos, test_size=0.2, shuffle=True)\n",
        "\n",
        "  return (train_images, train_annos), (val_images, val_annos), (test_images, test_annos)\n"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iPHO1YbTACcu"
      },
      "source": [
        "You can now load the preprocessed dataset and define the training, validation, and test sets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIS70_um_Y7n",
        "lines_to_next_cell": 2
      },
      "source": [
        "# Load Dataset\n",
        "train_slices, val_slices, test_slices = load_images_and_segments()\n",
        "\n",
        "# Create training, validation, test datasets.\n",
        "training_dataset = get_training_dataset(train_slices[0], train_slices[1])\n",
        "validation_dataset = get_validation_dataset(val_slices[0], val_slices[1])\n",
        "test_dataset = get_test_dataset(test_slices[0], test_slices[1])"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oKXJYZi7A0dF"
      },
      "source": [
        "## Let's Take a Look at the Dataset\n",
        "\n",
        "You may want to visually inspect the dataset before and after training. Like above, we've included utility functions to help show a few images as well as their annotations (i.e. labels)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "id": "d46YCbvPafbp"
      },
      "source": [
        "# Visualization Utilities\n",
        "\n",
        "# there are 11 classes in the dataset: one class for each digit (0 to 9) plus the background class\n",
        "n_classes = 11\n",
        "\n",
        "# assign a random color for each class\n",
        "colors = [tuple(np.random.randint(256, size=3) / 255.0) for i in range(n_classes)]\n",
        "\n",
        "def fuse_with_pil(images):\n",
        "  '''\n",
        "  Creates a blank image and pastes input images\n",
        "\n",
        "  Args:\n",
        "    images (list of numpy arrays) - numpy array representations of the images to paste\n",
        "  \n",
        "  Returns:\n",
        "    PIL Image object containing the images\n",
        "  '''\n",
        "\n",
        "  widths = (image.shape[1] for image in images)\n",
        "  heights = (image.shape[0] for image in images)\n",
        "  total_width = sum(widths)\n",
        "  max_height = max(heights)\n",
        "\n",
        "  new_im = PIL.Image.new('RGB', (total_width, max_height))\n",
        "\n",
        "  x_offset = 0\n",
        "  for im in images:\n",
        "    pil_image = PIL.Image.fromarray(np.uint8(im))\n",
        "    new_im.paste(pil_image, (x_offset,0))\n",
        "    x_offset += im.shape[1]\n",
        "  \n",
        "  return new_im\n",
        "\n",
        "\n",
        "def give_color_to_annotation(annotation):\n",
        "  '''\n",
        "  Converts a 2-D annotation to a numpy array with shape (height, width, 3) where\n",
        "  the third axis represents the color channel. The label values are multiplied by\n",
        "  255 and placed in this axis to give color to the annotation\n",
        "\n",
        "  Args:\n",
        "    annotation (numpy array) - label map array\n",
        "  \n",
        "  Returns:\n",
        "    the annotation array with an additional color channel/axis\n",
        "  '''\n",
        "  seg_img = np.zeros( (annotation.shape[0],annotation.shape[1], 3) ).astype('float')\n",
        "  \n",
        "  for c in range(n_classes):\n",
        "    segc = (annotation == c)\n",
        "    seg_img[:,:,0] += segc*( colors[c][0] * 255.0)\n",
        "    seg_img[:,:,1] += segc*( colors[c][1] * 255.0)\n",
        "    seg_img[:,:,2] += segc*( colors[c][2] * 255.0)\n",
        "  \n",
        "  return seg_img\n",
        "\n",
        "\n",
        "def show_annotation_and_prediction(image, annotation, prediction, iou_list, dice_score_list):\n",
        "  '''\n",
        "  Displays the images with the ground truth and predicted label maps. Also overlays the metrics.\n",
        "\n",
        "  Args:\n",
        "    image (numpy array) -- the input image\n",
        "    annotation (numpy array) -- the ground truth label map\n",
        "    prediction (numpy array) -- the predicted label map\n",
        "    iou_list (list of floats) -- the IOU values for each class\n",
        "    dice_score_list (list of floats) -- the Dice Score for each class\n",
        "  '''\n",
        "\n",
        "  new_ann = np.argmax(annotation, axis=2)\n",
        "  true_img = give_color_to_annotation(new_ann)\n",
        "  pred_img = give_color_to_annotation(prediction)\n",
        "\n",
        "  image = image + 1\n",
        "  image = image * 127.5\n",
        "  image = np.reshape(image, (image.shape[0], image.shape[1],))\n",
        "  image = np.uint8(image)\n",
        "  images = [image, np.uint8(pred_img), np.uint8(true_img)]\n",
        "\n",
        "  metrics_by_id = [(idx, iou, dice_score) for idx, (iou, dice_score) in enumerate(zip(iou_list, dice_score_list)) if iou > 0.0 and idx < 10]\n",
        "  metrics_by_id.sort(key=lambda tup: tup[1], reverse=True)  # sorts in place\n",
        "\n",
        "  display_string_list = [\"{}: IOU: {} Dice Score: {}\".format(idx, iou, dice_score) for idx, iou, dice_score in metrics_by_id]\n",
        "  display_string = \"\\n\".join(display_string_list)\n",
        "\n",
        "  plt.figure(figsize=(15, 4))\n",
        "\n",
        "  for idx, im in enumerate(images):\n",
        "    plt.subplot(1, 3, idx+1)\n",
        "    if idx == 1:\n",
        "      plt.xlabel(display_string)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.imshow(im)\n",
        "\n",
        "\n",
        "def show_annotation_and_image(image, annotation):\n",
        "  '''\n",
        "  Displays the image and its annotation side by side\n",
        "\n",
        "  Args:\n",
        "    image (numpy array) -- the input image\n",
        "    annotation (numpy array) -- the label map\n",
        "  '''\n",
        "  new_ann = np.argmax(annotation, axis=2)\n",
        "  seg_img = give_color_to_annotation(new_ann)\n",
        "  \n",
        "  image = image + 1\n",
        "  image = image * 127.5\n",
        "  image = np.reshape(image, (image.shape[0], image.shape[1],))\n",
        "\n",
        "  image = np.uint8(image)\n",
        "  images = [image, seg_img]\n",
        "  \n",
        "  images = [image, seg_img]\n",
        "  fused_img = fuse_with_pil(images)\n",
        "  plt.imshow(fused_img)\n",
        "\n",
        "\n",
        "def list_show_annotation(dataset, num_images):\n",
        "  '''\n",
        "  Displays images and its annotations side by side\n",
        "\n",
        "  Args:\n",
        "    dataset (tf Dataset) -- batch of images and annotations\n",
        "    num_images (int) -- number of images to display\n",
        "  '''\n",
        "  ds = dataset.unbatch()\n",
        "\n",
        "  plt.figure(figsize=(20, 15))\n",
        "  plt.title(\"Images And Annotations\")\n",
        "  plt.subplots_adjust(bottom=0.1, top=0.9, hspace=0.05)\n",
        "\n",
        "  for idx, (image, annotation) in enumerate(ds.take(num_images)):\n",
        "    plt.subplot(5, 5, idx + 1)\n",
        "    plt.yticks([])\n",
        "    plt.xticks([])\n",
        "    show_annotation_and_image(image.numpy(), annotation.numpy())\n"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hEfyChmKEFKe"
      },
      "source": [
        "You can view a subset of the images from the dataset with the `list_show_annotation()` function defined above. Run the cells below to see the image on the left and its pixel-wise ground truth label map on the right."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AFO_hIhLWYT4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 277
        },
        "outputId": "1c9c5f0e-9c2f-47d4-f343-bf39013d6999"
      },
      "source": [
        "# get 10 images from the training set\n",
        "list_show_annotation(training_dataset, 10)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x1080 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdgVkp8wZua0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 277
        },
        "outputId": "ceef0c80-f5e0-4a4e-b45d-7e884f295c71"
      },
      "source": [
        "# get 10 images from the validation set\n",
        "list_show_annotation(validation_dataset, 10)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x1080 with 10 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAAEJCAYAAAAuM9osAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeUAUZ54//ndV3003DXI0KDeIoqKoQY1HvHKOGjXmcpzE6FeTOJuN2cnM7kyundlMNvvbzGS/k2RndvY7SXQSzWU0MR5JFE08YsQjXqCiIogi0JxNN31W1+8PQguCCgh0A+/X/DGxrn4Qq6vqXc/zeQRZlkFERERERERERMFFDHQDiIiIiIiIiIioNYY2RERERERERERBiKENEREREREREVEQYmhDRERERERERBSEGNoQEREREREREQUhhjZEREREREREREFI2ZGNBUHg/OABFBItwGAWAt2Mfst60YeGajkofwE8NwOL52ZgBeu5yfMysHheBl75cV+lLMtRgW7H1XhuBhbPzcDjuUlt4bkZeNc6NzsU2lBgZf1UiUkrVYFuRr+1+l5noJtAQYrnZmDx3KS28LwMvP9MbigOdBso+PDcDDyem9QWnpuBd61zk8OjiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIsaYNERERERER9QsKhQKi2Nh3QZZleL3eALeoH/EJEN2t6+bISgmyUgpAg3oHhjZERERERETU52k0GsyaNQvZ2dkQRRHFxcX43//9XwY3PURXNAiZD7/ZannpknW4uGJNAFrUOzC0ISIiIiIioj5Np9PhwQcfxLJlyzB27FhIkoTi4mJ88cUXKCkpCXTz+rzwnROQ+q/PQACnFe+obg9toqKi8C//8i9Yu3Ytjhw5Ap/P16H9BUGAyWTCtm3bsHnzZqxduxaFhYVMQzsg9aVnoDubiJrp3+PS8o86vH/Cfy1B6IGR/j/LSgl5q38Jnm9ERERERBTsFAoFXnzxRcyZMweJiYkQRRFnz57Fq6++irKysjb30ev1GD16NOrq6pCXlwdZlnu41X1HzAdzEPPBHCic2lbrip95B1V37mpzv7Tnfglt0SBU3bUblxev7+5mBq1uDW30ej0GDx6M8ePHIzw8HCtWrIDb7e7wcZRKJTIzM2E0GnHixAlYLBbU1NR0Q4v7nqT/73GYvh8NVa0J9mFnO3UMzeVohJxN9v/Zp/R0VfOIiCiIiKKIxx57DAaDAWvWrEFVVVWgm9TvnKp+GCXWmTCqSzBh4L8FujlERL2aIAgICQnBsmXLMH/+fH9gc/DgQaxevRo5OTnweFo/28TExGD69Ol49NFHkZeXh1//+tfsNNBJsX+fj8gt06Epi2617sJTq1E94zt4ImuvLJREpLz8jwAAU+4oKK1G1I/J66nmBqVuDW1MJhNGjBiBxMREhIWFQaFQdPgYKpUKt956KwAgNTUVUVFR0Gg0Xd3UPmvA9slQ1YUGuhlERNQLiKKIsWPHQq1WQ6tt/TaMul+F/RacrvkpInXHGNoQEd0EtVqNuLg4zJ49G4sXL0ZycjJ8Ph8OHTqEdevWYdOmTaioqGixj0qlQmpqKqZOnYp58+Zh6tSpsFqtEAQOMeiMyE3TEfXFTOiK41oslyGjYv5XsMzeAe+AOv9y0a5D1BczEbllGodRNdNtoU3TsKYhQ4bAbDbDarV26hgGgwGPPPIIBEGAx+OBJLGqdLvIgOH4EAhSx4Oy5vSnk6GsM3ZRo4iIKFiJoojIyEi43W4cPXoUDQ0NgW5Sv1PlGAa7NwY6pQWRumOBbg4RUa8lCALMZjPmz5+P559/HkajEZIk4fTp01izZg2++OILXL58ucU+CoUCQ4YMwX333Yd58+ZhxIgRsNvtOHz4cIdLfPR7Pz6LJrz5GFQ1pparRB9sw0+j+Nm3Iauv9HJSWEMQenAkkl5f1tOtDXrdFtpotVpEREQgMjISAOB2uzs0DlAQBOh0OiQnJ2Ps2LGQZRmXLl1CXV1dm13Y6CqSiGHLX4Ugi50+hLLWiMG/+WdoL8b6l8mCD96w+q5oIRERBRGj0Yh58+ZBpVJh9erVcLlcgW5SvyDLgFMaAEDAjgv/jfKGcRgSvha3Jz4R6KYREfVKoijCZDJh4sSJeO655xAa2jjqoL6+Hn/605+wdetWlJeXt9hHEAQMHDgQK1euxN13342YmBg4nU6cOXMGn3/+OUObjvAByrpQDHvi31t1IJBFCe7oKuS//ZsWy0WnGqb9ozH4+V+2Opykc8Cn69/3JN0W2kyZMgXLly/HvHnz4PF48NVXX3Wol0xoaCgmTJiAl156CfHx8SguLsZzzz2H7du3s55NT5CBrDl/g8KlabZIhivWgqOf8UaSiKivEEURGo0GaWlpeOmll7Bhw4ZAN6lfkSHineNFkHFzPWOJiKhRfHw8li1bhieffBIm05VeHmVlZThw4ECrwAZofPb885//jEmTJsFoNMLhcODw4cN48skncerUqZ5sfu8mA0qrEWPv+nubq52JpTj24T8CTX05fhwBFbP2XsT/z8/aOJyMon/+X1TO2tlNDe4dOt8N4wamTJmCuXPnAgC8Xi/+8Ic/dKiHTExMDCZNmoSxY8eivr4eTz31FL744gsGNgFUN+EHHF3380A3g4iIulBMTAwef/xx7N27F+Hh4fjhhx/4RpGIiHqlpmm958yZg7CwsBbrYmJicNtttyEhIQGieOUxWBAEvPzyy5gyZQqMRiOsVivWr1+PpUuXMrDpoJCTqRh9z7vXXK89H4fsieuQPWkdRJf6hsfLe/dXqLznmy5sYe/UbT1t3G43nE4ndDodAHRqqm9RFCEIAlwuF/bs2QOn09kdTaV2KHtgMy79n48BJWsKERH1JU3XW4VCgfr6enz99decIYOIiHql5cuX4+GHH0Z6enqr4sEmkwm/+93vkJ6ejjVr1uDgwYPQaDR4+OGHsXDhQuj1euTn52PNmjX47LPPUFxcHKCfojcTIErXjhgECBAkJWRcKZuS9OoKRGyb1GrbY2ufhjOxFBA51Xq3hTbbt29HfHw8lixZ0mqdKIoYOHAgBg0a5F8mCEKLmjeJiYkYOHAgAECWZQY2XUi0azH4uV/deDuPyv/fkqGhRWVvIiLq/XQ6He6++24sWrQIdXV1eOutt1BWVtahGnTUeS6vCV8VrYLcrOPziMj/hxGRfwtgq4iIeqfs7GzMmzcPKSkpUKvVsFqtOH78OA4dOoQnnngCarUaAwYMwH333Yfo6Ghs27YNDQ0NeOaZZ2AymWC1WvHRRx9h8+bNKCoq6rIJcFJTU7Fo0SIcO3YMubm5KC0t7ZLjBhvTvtEY9LeH2r394F/9BhB90J9OgdJm8C+XFRJO/+EVOJIudUmHgcH1OqTafuxIAhlfx9Sgt01M1W2hzaVLl3Du3DkAjSHNtGnTYLPZIMsyVCoVRowYgaysLP/2oii26I0TGhqKxMTE7mpevxRyKhWD/roQokuNsH1jA90cIiIKMJVKheTkZAwbNgwWiwWbNm2C2+0OdLP6DUlW40L9nS2WhWtPIVJ3IkAtIiLqvX7+858jMzMTBoMBTqcTeXl5ePPNN3H27FkolUrMmDEDycnJGDRoEGbMmIGEhAQ4HA4MHz4cALB582Zs374dhYWFXXItFEURZrMZK1aswKxZszB+/HiYzWbk5OSgqKioz/VqVVdEwHh8aItllxd9BimkAab9WTAeHeZfLkBA2P7RrY7hNdhw+WefoW7i4S4JVtLqdRhq1SPW2Vin1QcZY2saZ0bOM9nhVPSO4eDdFtq0+BClEo8++qi/po1SqcTgwYMxdOiVX+rVPW2acFx91wkpSEFIQUqgm0FEREFCq9X6hzFXVFTgzJkzAW4RERFR58yaNQthYWHwer04c+YMNm/ejHXr1gEA3nzzTVgsFjzwwANISUlBdHQ0zGaz/1nT6XTiww8/xMmTJ+FwOLqkPWq1GlOnTsVjjz2GsLAwpKamwmAwQKVS4fPPP0dJSUmXfE4wK3v4C7jNVXCZKyE6NQg5nXrNbT3hdaiZfAClS9d1yWcPbFAjsy4EUc1q54gQ/KGNQyGhKMSJBmXw5w09EtooFArMnj37uts0hTZer9ffFU2hULQoEkVERERdx2w2Izw8HHV1dcjLy4PdbgfQ+HJFq9VCFEVIkuS/Lvt8PvbE6UZ65WWoRSvcUgic3sg2t9EoaqFRcrgyEdHV8vLykJGRgerqanz66adYvXq1f92ZM2fwxz/+EYIgYMGCBUhPT4dK1VgKQpZl2Gw2FBYWwuVyXbMzQXuJogidToeEhAQsX74c4eHh/vpxU6ZMgUajQU1NDdasWXPTP3OwkiHDHVsBWdF4/1A5Zwe84XVIfnUF1Ja2r2+O5BKULv0Y6tJouGMrOt/TRgYMXgWmVYTDIF17ZsbJlWFwidU4Zwz+Miw9EtpcXQRKluVWJ0LTsuLiYlRWVkKhUMBsNiM+Pp7BTQ+TIUNWeiF4lRB624A/uimiKPoLgF+t6Rz1+Xysd9ENGv9GO3K+yTw76aZlZWUhNTUVbrcblZWV8Hq9EEURSUlJmDZtGkJDQ2GxWFBaWgqFQoGqqiocO3YMACBJEnvDdrE7k5YiNmQfTtc8jB0X/qfNbcbFvIKx5tf8f1aI7Z+Zk4ioL1u2bBkee+wxHDhwAPv37281tXdDQwP+8Ic/oKGhAYsXL0ZGRoZ/XXh4OFauXIlVq1a1eInRUYIgwGw2Y+rUqXjqqacwceLEFutlWcYtt9yCp59+Gh9++GGX1c0JBrIgw6f88ZokAEc+/XmLmjS1kw/h5Fu/Reai/wvR2zqGCD08Alnz/xc+pQcHv1kIWeXteHAjN06P/dCFaCj60J1yt4U2VqsVBQUFyM3Nxbhx41qsy8nJadX1rCnR3Lx5M/Ly8hATE4Of/exn+NWvfsWbwh7m07lw8JuHccttH0Hh0gS6OdRDkpOT8fDDD+P+++9HVlZWq7cMe/bsQV5eHrZv3866F91BaYQ84JZ2by5UfQ9IXdN9l/qv2bNnY9y4cfjhhx/w2WefQalU4tlnn8VLL70EjUbjD3CbQlun0+nvzv3WW29h06ZNuHDhQiB/hD7ls7NbbrhNbtlzyC17DgCgFBx4YlQU2sjZiYj6nXPnzuHFF1+87jYNDQ0wmUyIjLzS26OpF8zy5csxc+ZMvPnmm/jggw9QVVXV4TbMmzcPixYtwrRp0xAeHt5qvd1uxw8//IC1a9f2qcAGACrn5KByTs51t3EmXcSh7T9D9rQPr7mN4FUie/InOJSzCJKxoUNtUPsELC6K6dA+vUG3hTZ1dXXYuXMnSkpKkJaW1mLd8ePHcfHixTYf+jweDyRJQkxM3/vL7lEKHw59/SiyFvwFSqux1WoZMg5/+Zi/y1oLAntR9BeCICAhIQFvvfUWMjIyEBERAY1GA7vdDpfL1SK0ycrKwtixYzF8+HDo9Xq8//77AWx53+EzpAG6WAAC+ORFPa2yshJWqxXDhw/HW2+9hVOnTuEnP/kJ1OrG8d/NvwMEQYBWq0VqauN49KysLOTm5jK06VLt+Q64sg372xERdcz48eMxbNgwGI2Nz0c+nw8WiwXR0dEQBAFJSUn47W9/i8GDB2PlypXtPm5kZCSeeOIJPPDAAxgyZAg8Hg8OHTqEN954A0Dji47Q0FB88cUXePvtt7F3795u+fkCqh2XJO2FgRi+9D9vcJiOX9tSbFpMtoRBaOf+axLK4RV98PSS6cS7LbSRZRlWqxUnTpzA2bNnW6xzOBxwu93XHWJx4cIFfPnllxg3bhwmTpyIF154AX/84x9hs9m6q8l9iwBIJhtOvflb4Bpj+bzhddc+ua761URtmgHRqcGFf3qnS5tJgaVSqfCXv/wFEyZMgNvtxu7du/H9998jLy+vVXG0adOmYdGiRRg+fDjuuusuhjZdRVAAoqr14pqjgK/ZsAeFFnLYiB5sGPUHx48fx9ixYzFmzBikpaUhLi4OOp0OR48exapVq5CWlobExEQ4HA5YLBYkJyfjnnvugSAIUCqVHL5MRES9hl6vx09/+lOMHj0aarUaDocDeXl5+N3vfocVK1YgMzMTZrMZOp0Oer2+Q8dOS0vD3LlzkZ6eDpvNhgMHDmDVqlXYvn07li5d6r9e2u121NXVweVydcePGNRCc0ci8f8uhbLecOONO0ghC9D6Wt+T7IuowwC3CkPqW/4+XQofvL0ksAG6uaaNz+eD0+mE09nx4j4OhwNlZWWwWCxQqVQYNmyYv1gUtZ8941yn9y1+9m+I/59FUFWHQW2JgK5oUBe2jAJJEASYTCbMnTsXkyZNgkqlwt/+9jfs3LkTBQUFsFgssFqtLfax2WyYNGkSRowYgdTUVAwZMgSnT58O0E/Q+/kMaY2BjTrsykJZglD/4+w9nhoI8pWhobLcclpI2ZAC2IsheBlkU+fZbDY4nU6IogiNRgOVSoWDBw/i3XffxVdffQWTyeSfiaOhoQFpaWm4++67IQgCvF4vhy93oxDVRdzSrHYNAByvfBzVzuEBahERUe8WHR2NrKwsmM1mSJKE4uJivPPOO9i9e7d/6u8JEybAaDTixIkT7TqmIAjIzs7GE088gbS0NFy+fBk5OTnYuHEjcnNzUVtbi5SUFCgUjS/RfT5fv712KuuM0J9NarW8fP5XaEgvhK4wATGfzOrwcVNsWqTXtw7ZDgyw4nyIE5o2wpzepkcKEXdGU8FTSZL8BZ0GDhwIu93OWho9QQAs87Yh9v15UFU3PlSqKyIwIGciqmd+F+DG0c1SKpWIi4vDkiVLYDAYsH//fnzyySc4fvz4NUPWpgLESqUSoaGhiI+PZ2hzM3QxgHhlCkL43ICzAoKjtH37a82AswJgaENdyOPxYO3atdi0aRPKy8tRXFwM4ErQO3bsWACAy+XC2bNnOzXen24sVH0OQwZ8hMyov/mXna2ZDwH980afiOhmiaKIu+66C/Hx8dBoNLh06RJ2796NzZs3w2az4ZtvvsGJEydw8uRJGI3Gdk3HLYoiIiIisGjRIsyaNQt1dXXYtGkTNmzYgP3798PhcEAURYSFhUEURX99uP44oUdIfipCD7fuMV49bR8q5n2Nhoxz0J1NhMKh9a+TVd5W218t3q7BUGsIBjmu1GGVIeOMwYH80Aa4FH3juhm0oc3VkpOTMWbMGJSVlfEmMUD055KQ8MZihja9nCAIiIiIQHZ2NqZMmQJBEPDRRx/hzJkz1+0VN2HCBMTFxUGSJDidzk5X1e/vZABQGtBqbKLkhFhf0P4Dee2A78YXM6Lrqa+vR319PTweD5RKJTweD7799lvU19dDlmX/MKimwOaXv/wlBEFAQUEBdu3ahYsXLwb6R+iTwrUFSA//BD5ZRJUjEwCw6+JraPDG+rdRCC5E6o4FqolERL1KZGQknnzySZjNZgBAQUEBNm7ciEuXLvm3qaysxI4dO9p1PEEQYDQaMX36dCxatAgqlQqffvop3n33XRw5cqTFdkpl4yO30+lEXV1dv7yHHpAzCeZP72m1vOQf3oMzsfGFpSOtGIUvvdnuY4a7lMiuDkWku3E0jleQUatqLC2wK7oWPgEwehTQea/0tJEho0rtuboSSNDrNaFNWFgYoqKi/MURqefJCgmSPvjnsafr0+v1GD9+PH7xi18AaHyzvmPHjhteQKZNm4akpCTU1dXhxIkT2LdvX080t0+SB2R3qOiwDKFxKFUzQu0xCJw9im7S/v37MWLECGRmZmLQoEHQ6/VYuXIl1q9fj4MHD8Lr9SIyMhITJkzAP/3TPyEtLQ2yLOM///M/cfr0aXg8nG76ZgiQoRatcPuMaB7kFlvvgc0dj9mp9+Gj022/KDGoS/DAkBk91FIiot5LEATMmDEDUVFRcLvdcLvdOHfuHA4cONDpY2q1WowYMQJvvPEGwsPDcfjwYfzhD3/AuXMtS1MolUpERERAEAQUFhYiNzcXZ86cudkfqU+Q9A2Qb6KuzKzLEdA3q91aq/JifXxli20mVZqQ0HCl944kAOvjKjs+lXiA9ZrQJicnB++++y5qamoC3ZR+q27cEZz+08sd26mt81BoY3kvO3F6s4SEBIwfPx4ZGRnwer14++23UVhYeN2Hr7CwMH9htrNnz+L777/vwRb3ce3pIquJYhFi6hZlZWV477334Ha78corr0AURSxevBgLFy5EfX09gMaC5RqNBmq1GrIs4/z58zh27Fi/fFPY1XSqSiwbOQh/OVILGSKaXwyrnCOwOq+t3nfyVf9PRETXI8sytmzZgu+++w7Cjy/N6uvrUV1d3eljxsfH48EHH0R0dDRkWcamTZta1YMURRHh4eGYOnUqRFHErl27cP78+Zv6WXoz+arr1uEvH4NP28myJ/3sEthrQpvOUiqVWLp0KTIyMvDaa6+htLQUMTExGDNmDLKysvDtt9/2zSnXgsSsyxEwO6/0jnKLPryfWI7HimIgyo1fmofD63EknHU5eprX60VhYSFWrlx5w7fl8+bNw7Bhw2AwGHDp0iUcPny4h1rZ9wn1BYDjMvrd1YeCRklJCdasWYP6+nq8+uqrMBgMUKlUGDBgAIDGN5SyLEOSJJw+fRrjx4+Hy+Xql2Pyu4MAH54YFY3VeSfh8EbfcPvsmFcx1vxH8DuDiKj9rFar/2UEgJu6homiiMGDB2PZsmWQZRnV1dX47//+71YlPARBgE6n8/85Pz8f5eXlnf7c3qxkxRpcfPyDFstkdSd768rAkvMxUMr9561/nw1tBEFAeHg4li9fjpUrV0Kj0WDbtm2w2WywWCwoLS3FkiVLsGjRIjz55JPIz89HbW0tJEkKdNP7jHsvRiLSrWpxQkk//vf6QRbMKY1EiKTAyNoQpNfrUa/0YuvAzife1D7nz5/HqlWrsH//fhQUFLRreMPSpUsRHR2Ns2fPYu/evTh+/HgPtLS/kFlclAJKlmWUl5cjJycHhYWFGDlypP9NZJP6+nrk5ubi97//fadmhKRrEwRAKThxf/oMfHn+77A4xlx3e1HwQinyd9BfabVazJ07F9HR0Th27BiKioqwYsUKzJ07FwBQUVGBjz76CFu3bu3Xb/S7S6Jdi/FVoTfcThJkfBpnYU/yINOVLxsUCgW0Wi0kScInn3wCm83W6vh6vR4rVqyAIAg4fPgwDhw4gIqKii5rQ6+ilCAru+45WyELEJqdYEV6B76LtF5nj94tqEOb8vJyvPnmm9iwYQMuX74Mm639vTF0Oh2GDBmCJUuWIDo6GoIg4I477kBxcTHy8vJw/vx5fPDBB1i7di1eeeUV5Ofn4y9/+QtOnToFl8vVjT9V71L8y/8HsaExIfZEdGxoWqhX0XYCKgBWtQSf0PjFpvUpoPUBIV4RM8rDsCO6lhe5buR0OlFUVISKiooWbxyuJTIyEoMGDYJarUZ+fj6OHz8Oh4O1VG6GUNdsGknv9X8HstYMWR/XbIEMwZrfONsUUReRJAmXLl3Cyy+/jCVLliA7Oxvnzp1DZWUlzp07h6NHj6KwsLBFcUXqWibNeSjF63+3jjW/htSwDT3UIgomKpUK6enp+MUvfoHMzEzo9Xp8/fXX2LNnD0aPHo309HQAjUM2RFGEXq/Hl19+iby8PPaK6wK3VBsR5lbC4FUgzHPjxycfZNxeHg4A2BdZB7uSL2f6GkEQ/C846urqWp1nBoMB48aNw4IFCwAA69atQ0lJCbxeTiLRHdyiDJuqZSg02WJCpEvl/7NdIWFvVF1PN61LBHVoY7fbceDAgQ4XiWqaHefWW2/F4MGDATQ+qHo8Hvh8jV+a9fX1OHz4MGprazFx4kSkp6fD4/Hg448/xuHDhzlW/0d1Ezpxgy4DI2tDoPJ1LHlRySJSbDpUqb04HmZDB3enDmgqwnYjgiBg+PDhMBgMUCgUKC8v77fdOruKAAAuS7u3l5UGQGVqudBpYe8c6nIOhwPbt2+H1+vFnj17cOnSJdTW1uLixYs4f/487Ha7/xpK3SM9/GPEhuy/5vqhA9YiXNuBWeaoW0RFRaGmpgZmsxkmkwmiKF5zW6vVivLy8pt6IahWqzFs2DA88cQTuO+++2AwGCCKIoqKinDixAkcPHgQHo8HISEhuOWWWzBixAgolUoIgoCysjJUVlbe+EN6kQEuJeKbFRZtj1OhdrgUnQ+vYh1qxDo1N97wRyIEpNgbX3oeGlAPO6/ZfZpKpWrxZ4VCgaioKEyaNAmJiYmoqqrCd999h7q63hkY9DoyMLIuBKk2HTS+K9/PXlFGUUjv7Kka1KFNZ4WHhyMrKwt33HGHf1lRURH27t3rf+CUZRl2ux2bN2/GnDlzEBERgUcffRQ+nw9utxv5+fnt6oVAbRtXHQrxqu4yHsGHsmbFpsq1bqgaRGibnUwiBIyvDkWN2oNSnRvem6goTjdPo9HgJz/5CQwGA5xOJ8rKym6qaBt1jKw0AIpmN6ayDHhqwFoW1B1kWYbNZsOmTZuwadOmQDenX8qM+lugm0DXIQgCkpKSMGXKFBQXFyMjIwNxcXGtHtiau3DhAnJzc1FQUNCpBzalUonY2FgsWLAAy5cvbzF00ePx4MKFC9i/fz927dqF8PBwREREIDU1FePGjUN9fb1/XV9hcisxuF6PUXWGDu3XoJRQonfBqeh4eGJ2qFs8+DWRIeOy1o3mncq1kogI97X/PVDfIwgCEhMTW4S3MTExuPXWW3HbbbdBkiR89dVXKCws5GiOHiDIjSHruKqWz6IOUUK5pvf2Uu+ToU1mZiYeeugh3HnnnZBlGQ6HAxs2bMC+ffv8D5yyLMNiseDnP/85DAYDZs2ahZCQEMydOxchISFYu3Ytdu/ezelMu1CdSsJXsVce+HeYazGtPAxJdi3UcsuL4d1lEfhiYCUqNG5I136BRd1IqVQiKSkJTz75JDQaDY4dO4aDBw9yjHwPkg1pgGZAswU+iDUcnkJE1NMUCgXCwsKwYsUKPPLII7Db7RgwYACMRuN1e9qUlZVhz549eO+997Bt27YOPbQpFArExMTgzjvvxIoVK/zLJUmC2+3GqVOnsH37dgBAXl4eAGDkyJF45JFHEBsbi6SkJNx+++3YvYsRVwEAACAASURBVHt3rx8ipfM2Pn6NqTFgsE3f4f2nV4Tj26haFBoc8LT3haAM6CURd5aFQ+dTtLnJloFVLXqGJ9m0uLN8QItttJIIhQ+8n+2jRFHEPffcA41GA4fDAZPJhDvvvBMrV67E8OHDUVJSgn/+539GWVlZrz8Pg5lSFqCVRPggY/blyBbr3IIPxSEu7IquDVDrbl6f/PoICwvzT78mSRLWr1+P119/HRZL6yEJLpcLr732GoqLi+HxeBAfH4+FCxfi97//PbKzswPQ+l5Obvsflfzj/672jbkWx8Psba6bUxqJJLuOnQoCxGg04umnn0ZISAgA4JNPPkF+fn6AW9V/8J89EVFwUCgUiI+PxyuvvIJFixYhMjISycnJNxwaBTS+cZ8/fz7++te/YubMmTfcvrn4+Hg89NBD+Pd//3eEh4f7Z3KzWCz4/PPPsXv37lb7vPfeezh//jzcbjdiYmKQnZ0No9HY4Z852DxQEoWfFcd0KrBpMtUShqwaQ/susD/ez/602NxmYNP2XS0gC431bJprvJ/t2HAuCn6yLPuHDCuVSqSlpUGn0+GZZ57Biy++iMzMTNTV1eHf/u3fcPnyZQY23SzFrsOs0og2y6IeDbP16sAG6IOhTUZGBmbOnIns7Gw4nU7s3r0br776Kmpra695shw8eBBPP/00zp07B6BxSMiYMWOwatUqhIeH92Tzez2tJOL/FMa2OmHOGBzYENf2mOpD4fXYZm67yPGMijCMq+79Nxu9jVarRVpaGu6//34AQGVlJQ4cOICysrIAt6z/kCMnAmp+/xARBVpkZCRuv/12LFu2DGazudXsajciiiIiIiLw4osv4t5774VGc+PaKGq1GnfccQcWL17c4l60tLQUTz75JJ566ils2bKl1X4nT57EiRMnUF1dDb1eD7PZ3K7P6y+yag24u2zADbe71v1sE48o428pl1tVqinWO/FJfPvr1lHv5PP5cObMGaxatQpAY02b7777DjU1NXjhhRcQHx+PvLw8PPXUU/5tqPsNcCvxaFFMoJvRLfpUaKPRaPDss8/ipz/9KTQaDYqKivDCCy/gzJkzNyyeeObMGVy8eBF2ux2CIECpVCIyMhKjRo3q8MW5v4pyqvDAxSgIaDkF24EBVnwXWXftGaGu89crQIDQ1gxU1K3UajViYmL8N4obN27E2bNn0dDQEOCW9TPNv3u8DRCqvgtcW4iI+qHJkyfjhRdewK9//Wv/bDEdvS9suq/MyspCRkbGdWvgNAkPD8eQIUMwZMiQFp/3zDPPYPfu3aitvfZb46aXlH3h/lWQgUVF5jZrynTqeB2YnvTq+9km1SoPPoqvaLx/vXq1gGv0waG+pqSkBB988AGs1sZpphUKhf/c3r17N1555RV89tlngWxin7YmsRwOseVsUVefsxsGWfBeYhmOh/X+CYb6VE0bURQRFRUFk8kEu92OS5cu4dixY5CkG88JX1ZWhv/6r/9CQ0MDZs6cCYPBgJCQELz66quYOXMmH1bbQZQF6KSWXUj3RtbhfIgD7htU7L+sc2NHdA1mVLTuWZBq00EA8H2ktSubS9cRFRWF22+/3d+N+/333++yWaPMZjPuuusuPProo/j0008xc+ZMHD58GOXl5XC73f7AaObMmRAEAbt370ZJSQny8/NRUFDQ5jDH/kGG4OuaGls+UyYgdu7rX6g5ypmriKjfGDp0KG677TYMGjSo1bry8nKcPHkShYWFrdb95Cc/QXR0tP86KggCVCoVli1bhrfffhs2m+26n3vrrbdi+PDhUCpbflcXFxfD4XBcs/e4yWTCgAED+lTvGr0kdihs6W4+AXBcYwrvGIcaE6pCe7hFFAgNDQ3Iz8/H6tWrsXz5cmi1Whw6dAhbt27Fjh07cPz4cTidvXOmoqD34zn4dWw1JlvCWhX/liFjS2wVqtWePlNLqk+FNvHx8f5pEH0+H5xOZ7vDFrfbje+//x4ZGRlISkrCqFGjoFAokJWVhdtvvx1ff/01T7xOqFJ70HCNC1tzLoUPF/RO5A6wIrva2OLibJAUrMTfgwRBQHR0NG677TYAjUOjurrivSiKiI2NxZIlSzB06FAMHToUVqsVkiRBoVAgNDQUGRkZAICBAweiuroahYWF+OKLL/Dhhx92WTuCkQxANqQCQjd+PatCAUUnb+gFgQV3gtSAAQMwY8YMxMXF4U9/+hPHzwdAfrUCLkmAWe/DwBCGm73d5MmTMXXqVCQmJkKtVrdYd/HiRezatQs7duxos95bbm4uHnroIYwbN85fG65p9imFou2itk30ej2mTJmCYcOGAWicJaqwsBAffvghLl68CK/Xe819Y2JiEBsb6//M3kzlEzD2BkPkZcjIHWDF1Z2ydZICo2o7NsNUE6On8/tqJRHRLvWNN6Rez+fzoaqqCu+99x7OnTsHlUqF4uJi5OXl4cKFC3zh3wPKtR4cCatHyFWdBmQApTp3q++F3qxPhTYZGRkwmUwAAJvN5q9R0151dXXYs2cPUlJSkJKSAqPRCJVKhXHjxuHbb79laNPN3AoZx8JsiHCpkGzXtpoynHpGWFgY0tLSkJ6eDp/Ph9zcXDQ0NHTZA6DNZsORI0ewdu1aPPTQQ7h06RIUCkWr+lEFBQUAGscJjxw5EsOGDYPD4cCuXbtQWlraJW0JWvp4QGj2akByAq6qrju+qxLQRgFiJ24sNVGQXRYI8o17MFL3abrWSZIEWZYhyzLi4+Px+OOPIz4+HqtXr75uLTe6OTUuAVZ362vU6RolnJIAm0eCUpARrefff2+VmJiI+++/HxMnToTBYIAsy/B4PLh8+TIA4Pz589i1axd27tyJoqKiVvsfOHAAKSkpyMzM7HCAotPpkJ6ejtjYWACNoc25c+fwpz/9CfX19dcd8n/LLbdg4MCB0Gg0qKysRH5+fq+cZlgriUi2aTGyHVN7Hwuzt3o4C/GKCPUokGzXdfiz9V4Fhllb/84q1W7UqSTUq64dmlH/4na7cejQIRw6dCjQTem3zhn7x/N5nwpt0tLS/BXyKyoqkJOT0+FjHDx4EIMGDcKdd94Jo9EIQRA6VOmfbo5PAHJiarCkMAZiX4pHe5G4uDiMGjUKWq0WkiThq6++gt1u77KHP7vdjiNHjiA/Px81NTUwGAzXHXdvNBqxYMECJCYmYvDgwcjOzsbnn3/eJW3pNTx1EG1nu+xwYv1p+AQFoGpHkW9BASiuzHohm4ZBqNwPSL1/fHBvo1QqYTQaYTQakZWVBaDxfAIaw5u0tDRMnz4dVqsVycnJOHbs2HXfyFPH1bsF+GSgoEaBQuu1b6Eu2hSQfEC0vmuGNFLPmzp1KmbOnInExEQAjbONFhUVYdOmTf5tCgoKUFXVdqDu8/lgs9lgt9sRGRnZ5jbX0lQDp3mPHLfbjbq6uuvup9PpcN999/k/Lz8/H2vWrPHX3OhNwt1KTKkMa7W8QSHBJd64F5td6cPO6Fokn+94aHMtp0MdyDO1fe0L8YpQ+cRWb/wBwKr0wt3eacaJiNrQp0KbpreNQGMxqM50Db06pGl+TOoBMnCD8jfUg2RZvmE37s5yu93485//fMPtRFGEIAh48MEHIYpit7WnvxGt7Zu+XdZEQg4b2c2toetp+ncfHx+PefPm4Z577sH06dMhy7K/N43H44HP54MgCDAYDIiIiOALhy4iy4D043Up56IaDi9fKPQHer0eSqUSgiDA7XajqKgIv/nNb7Bx48Z2H2P//v0YOXKkP/jpiOYvM2RZvmFvb4VCgfHjx2P69OkwmUyQZRnl5eU4duxYhz87WHkFGQcG1ON0aPANO5liCUNCQ9vTen8VW40aNQN0Iuq8PhXaWK1WeDyNb7USExOxaNEifPzxxx06RmpqKkaNGoXo6Gj/stra2hvOPkVdQyEDS8/HBlXBuf5KlmXU1NTg73//O9xud8DakZCQgKlTpyIhIYFTjlO/NHbsWDz44IOYM2cO4uLioNU2Phg0Demtq6uDwWBAUlISoqOjcebMGeTm5vqvh3Rz3D5g/bmmGlC8NvUXUVFR/mK+NpsNx48f71BgAwDDhw/316XpqKYXhj6fDxaLBa+//vo1t1UqlRg5ciS2bdvmD2svXryIgoKC684y1dtsGliJCg2/14io/+lToc3HH3+M+fPnd+oCqdFokJCQgCVLluD+++9HaGiov8BUe6r8081JsGswozz8x9kTeVMcSHl5eXj++efx29/+FrIs+4dfBMoTTzyBpKQkOBwOHD16FNu2bQtoe3qCYNndcgF7+/VbYWFh+Md//EfMmzcPWq0WDQ0N+Otf/4o//vGPcLvdqK2thdfrxcKFC/Ef//EfAACn0wmbzcZeol2g2ikgp0SNa4U1RpUPdyU2htobzmkg/Tisd2i4F5kRfLPemz3yyCOIj4/v1L533XUX7rjjDsyYMQPJycn+5bIsY926dR2qkVhbW4uDBw/ihx9+aHO9RqPB0KFD8e677/p75zidTmzbtg1bt24N+DW8y7XjFjHJpsW0irAuvZvcEluFUl3btYHuvxCFME/bj1TvJZbBoeCLXyK6OX0qtPF6vf4eMTqdDikpKZg2bRq++eaba+6jVCoxefJkLFy4EGPGjEF8fDxMJhMEQYDL5cKqVatgtVp589tJUyvCcHBAPc4ZHW2un2QxIcaphtonQC233ZX/tLEBh8Pru7OZ1IzP54PL5QqKwoUGgwFDhw6FXq/3zwjX1wNUAQCCpMivrBsEOSShxTKh+iAgtX0+U9dTKBQwGAzQ6/WorKzEl19+iVdeeQUVFRWQZRmCIGDOnDmYP38+DAYDLl68iOeee469Q7uIDMB7VX217GgPInSNf78Or4DtFxoLekvNbhNEAVBydFqvplKpOjzEUKFQQBAEDB06FHfffTeSk5P9s07Jsoz6+nqsWrWqQ7PK6HQ6JCQkIC4uDhcuXGixLiIiApMmTcIzzzyDwYMH+5efOnUKOTk5OHLkSIfa39tNtphgvsE9ZWdNspha38/KwPxLkTB5lK0mz5AEGRsGWRoDG76LJKKb1KdCG7fbjYKCAmRlZSEmJgZxcXF49tlnMXHiRHz33Xf+YU5JSUkYNmwYFAoFVCoVJk+ejKFDhyIyMhIqVePU0l6vF+Xl5Vi3bh0kKTgeoHojk1eJzLoQxDe0Pb3wIIemzaJtzTlFH+pV/B30R1FRUcjIyIBer/cXQ2aA2nNkUQ0oriri6LVDAAOBQPB4PKiurvbPnqZUKjF79mwsWrQIWVlZOHfuHN566y18//33PE+6UYhKRrhGRqVDwNlaBWrdLR8O08O8SDDwmtVf6HQ6DBo0CKNHj0ZWVhbi4+ORkZGBxMRE/1BGSZJQWVmJ119/HQcOHOjQkGO1Wg2z2Yz09PQWoc2oUaNwzz33YNasWRg5cqR/KFd+fj7Wr1+PI0eOwOHoBwG7DEy1hEGQ23dPWaR34oSp4y9/TF4ltL4r57rC11jHJtKlarOHuAygWu1lYENEXaJPhTZerxd79+7FiBEjMHDgQBgMBkyfPh1DhgzB8OHDYbVaIUkSEhISkJ6eDqVSCVEUkZCQ0KLgm81mQ2FhIbZs2YK8vDze/LZTg1LCKWMDhtbrWyyPdqkR7erE1MIASnROlGsDV0+FAiskJMQfpl6+fLnvT/VNdBVJkuB0OuF2u6FQKKDT6SCKInw+H8aOHYuHHnoIEydOhMPhwI4dO7Bhw4ZeOVNMb3LJLkKjkGH3Crhkb/mAmGiUkBIqIVzL+4a+RKPRIC4uDrfddhtMJhPMZrP/vrEptBk1ahSGDx+O2NhY/zqHw4Hy8nIUFBTgwIED+OCDD64521RzPp8PDocDbrcbarUaJpMJ06ZNw7fffgu1Wo2UlBTcd999mDt3LjIzMwE09uS5cOEC1qxZgy+//BIXL17svr+QAEm26RDpUrVYJkDA4Hpdq54ubbmgd+JUqB2l+s7dV8Y61JDReG4rZQHpNn2b27lEH04bg69YMhH1Xn0qtAGAffv2ITs7G+PGjUNoaCh0Oh1SU1ORmprarv29Xi+Ki4uxYcMG/PnPf+4fbym6SL1KQu4Aa6vQprMq1R4cC7PhUicvrtT7mc1miKIIj8eDQ4cO4eDBg4FuElGPcrvdqKioQG1tLbRaLRISEhAfHw+n04mFCxdi8uTJEAQB+/btw2effQaLxRLoJvcpSgEYoPWh2nnlDfuZWiVkGdApWwczIyK8CFUzsOkLHA4HJEmCQqGAXq/HsGHD8PTTTyMuLg4ZGRn+oVOCIEChUECtVkOWZTQ0NMDpdKKhoQFFRUU4cOAAcnJysHPnznYPO3a5XLhw4QIqKysxcOBA6PV6zJ49G1u3boXBYMAdd9yB2bNnIy0tDUBjYONyubBx40a88847qKys7JNDJEfVGTq1X7nGDRnA0TAbLutufE/pEX2o0LhbvXBMseuQYr/+FOJO0YdLOhe+j2R4TkRdp8+FNmVlZdi/fz+ysrIwZcoU6HTX/3Jt4vP54PF4UFFRgW+++QbvvfceKisru7m1fZDQeMHS+ISbKijsFH3IMdegjlMk9luiKGL+/PlQq9WwWCzYu3cvDh8+HOhm9RuyoACEZr0IZBmQPQD4QNqTGhoakJeXh6KiIowbNw4TJkzA4sWLYbfbsWDBAjQ0NCAnJwfr1q3Drl27At3cPsekkTFtkBvrz7WcyvdsXfPbJxnqHzMdjoToOwoKChAZGYmwsDCIogiTyYT58+e32q7p/rG+vh5erxfHjx9HUVER8vLy8O233+LkyZMdrsVmt9uRk5ODlJQUREVFQa1WY/jw4XjnnXeg1WphNpv9w/mbApuzZ8/iX//1X1mHEYAEGR7xSmi1aWAlpA6UuKnWePFlTDUeLY7p0Od6BB8u6J34xtx3ZuwiouDQ50IbWZaxZcsWnD9/HosXL8bTTz/tX9fUXfXqi5ksy6iqqsK2bduwceNG7N27l8MwOsmp8OHvSWVYVhgLQO5QcCM3exhcm1gOr9i/bzr6M0EQYDAYMGLECCiVSmzZsgWHDh3qe7NgBDHZNBzQRDZb4oNg2cOH0gDYuXMnMjMzkZ2dDaPRiF/+8pfQ6/WwWCx4/vnnsWPHDlRXVwe6mX1c0/Xo6jNAhlIAFqQFvnA7da23334bdXV1mDBhAuLi4vw1Y65WXl6O77//Hh9//DEKCwtRUlLiLxR+M3bt2oWoqChERERg/PjxEEXR37Omufr6euTm5uKNN95AXV3dTX1msGm6L2zPvWTze8iiECdyYmp6/POPhNvwQ3jfniyBiAKjz4U2QGN38mPHjuH555/H3//+d3z++ecYOHCgP7QpKyvDpk2b8Lvf/Q5Dhw7F4cOHIUkSXC4XvF5vv39D0RXeTrmMRcVm6G9QEK45q0rCJ/EVAMAyp/2cUqnEkCFDMHHiRIiiiMuXL7NOB/VbZ8+exZ49ezBx4kRkZWVBr9dDFEW8/PLL+OabbxjYdDO1CDw42IVPzmha9TMLVcu4J5FDePuiTZs2YcuWLUhOTsaMGTOwYMECDBo0yL/+jTfeQHl5OS5cuIAzZ874Xyp01T1kXV0dVq9ejYMHD+If/uEfsGzZslbbXLp0CZ9//jl+/etfd2hGqt7gstaNt1MuQ5CBpedjbxicfJBQgQZlYwHwrvgNOBU+vJ18+cfPvrGvY6pRrGd4S0Tdo0+GNkDjRdPhcCAvLw8TJ06EQnElPJAkCQ6HA7W1taiurobb7WZQ05WExgvmhjgLBLn97+V9ggwfX+MTGodGRUdHQxAECILA85P6NaVSCa1W6586GGi8xkmSxHOjB3h8wNbi1oFNE5HXrT6p6Rw7f/481q5di88++6zFvWR9fT0kSYLX6+22F36SJOHkyZN47bXXIAgCli5dCkEQUFBQgKNHj2LLli3YunVr3+yFKlx5gfdBQsUNN7crJXTglrPdn/9hQgXmX4yEznftl5CfD6xEpcbN8ZFE1G36bGjTxOPx4NKlS9dc396icNRxdiX7y1DnaDQa3HvvvS1mdSPqjxQKBe6++27Mnj0bCQkJ/uWyLGPatGnYs2cPrFYrPB5PAFvZd1ndAg5WKNHgbfu7qMEjYHepClMG8u+/r5IkCTabrcN1abqKx+NBcXExXn/9daxfvx5A4yyntbW1KC8v7/v1FwXAppIC+tk55hoorpMIVWrcHaqZQ0TUUX0+tCGi3kepVPofUG02G0pLSwN2w0wUSDNnzsRDDz2EMWPGoLy8HBs3bkRycjJuvfVWjB8/HuPGjUN1dTUuX74c6Kb2SR4fUN5w7TfsXllAmZ1Pa9S9PB4PTp06hVOnTgW6Kf1SZ6cIJyLqKrzTIKKgIooi9Ho9jEYjAKCqqgqFhYWoreVsDD1FVoUDYrOpTn0S4KoKXIP6qYSEBPzsZz/DzJkzAQBfffUV3njjDbz//vv+9ZMnT8bAgQMD2cw+y+4BLI6Wt0lmvQSNgkPSiIiIqOcwtCGioKLX65Geno7k5GQAwPnz51FaWgqHwxHglvUfsmkooAq9ssDnglh3gsP1e1BoaCgWLlyImTNnQqFQYPv27Vi1ahUOHjyItWvX+rfLyMhAVFRUAFvaN7kkoLhegR8sqh+XyAhR+nBrjAexeh9UzWY3lAHYPAJYXoiIiIi6A4dHEVFQiY6OxoIFC2A2myFJEt5++22UlZUFuln9QtPkpi0XyuiauTiovZRKJR5//HH86le/gtPpxIsvvogNGzbAYrEAAJxOp39btVoNlUoFURTh87GOWFfwycARixKF1qZbJBmiAMxOdkMUgFtjPThiUeJkTeN6SRbwxXk1HkhzQclkk4iIiLoYe9oQUdAICwvD6NGjce+99wIA8vPzsWXLFtTU1AS4Zf2HHD0VELVXFrgqIVTtD1yD+hlBEGAymbB06VLs27cPixYtwocffugPbADA5/Nh69atcLvdGDVqFLKysmA2mwPY6r5le4kahdYrdWzUIvBgmos9zYiIiCggGNoQUdAwGAwYNGgQYmJiIMsydu7cyVlxAuGqWbv4sNpztFotsrOzkZqaCpfLBY/HA6PRiJCQEP82sizj9OnT8Pl8/hnWONNaV7vy9+n2AevPXXvKbyIiIqLuxOFRRBRURFGELMuwWCz49NNP4XK5At0koh7jdrtx6tQplJaWYsqUKYiNjYXVaoXNZvPXdRIEAaNHj4ZKpUJtbS1qa2tbDJmiribA7ZOxrUTtj3LsHoZkRERE1DMY2hBR0KipqUFOTg6eeuop2O12nDhxApIkBbpZ/YpQX9BygcQwoCdJkoSysjK8/PLLmDNnDjQaDdLT0xEeHg6v1+vfTqVSYdeuXcjNzcX+/fths9kC2Oq+JSPci9O1yqtmjhJQ7Ww7qBEFGWOivBCZ4xAREVE3YGhDREHDbrfj+PHjOH78eKCb0i8JAOAoDXQz+j2n04mPPvoIFRUVMBqNyMzMRHR0dIttPB4Pdu3ahR9++AElJSVwu90Bam3fE2/0wePzwqBq3whyhQAMDmO4TERERN2DoQ0REVGQsdvt2LRpEwDggw8+CHBr+p8Ukw8pJs7GRURERIHHQsREREREREREREGIoQ0RERERERERURBiaENEREREREREFIQY2hARERERERERBSGGNkREREREREREQYihDRERERERERFREGJoQ0REREREREQUhBjaEBEREREREREFIYY2RERERERERERBSJBluf0bC4IFQHH3NYcoqCXKshwV6Ea0hecm9XNBeW7yvCTiuUkUpHhuEgWnNs/NDoU2RERERERERETUMzg8ioiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2IiIiIiIiIiIIQQxsiIiIiIiIioiDE0IaIiIiIiIiIKAgxtCEiIiIiIiIiCkIMbYiIiIiIiIiIghBDGyIiIiIiIiKiIMTQhoiIiIiIiIgoCDG0ISIiIiIiIiIKQgxtovlNEgAAIABJREFUiIiIiIiIiIiCEEMbIiIiIiIiIqIgxNCGiIiIiIiIiCgIMbQhIiIiIiIiIgpCDG2I/v/27jw+qvpc/PjnnFmz7xtZICEJhC2AIEYJgqLIUkStuFah1fbWen/WXq+99dZq9dp6tXVtr9UqKII7KuACiLJj2AKyB0gICYQsZN9mMjPn/P6IGYgEFZvkDJnn7SsvnXPOzDyJc+ac85zn+3yFEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIH2Q+l40VRdF7KhDx3YJiFYLjFKPD8FsNxzRaanSf/B8g+6axZN80lq/um7JfGkv2S+NV7NZO6roeY3Qc3yT7prFk3zSe7JuiK7JvGu9s++Y5JW2EsUbebOaSeyxGh+G3XpvpMDoE4aNk3zSW7JuiK7JfGu+J1JajRscgfI/sm8aTfVN0RfZN451t35ThUUIIIYQQQgghhBA+qM9X2iiKwujRoxkwYAANDQ3s3buX8vJyNE0zOjS/0VSo03qic7Vj9MUKiirld0IIIYQQQgghxNn0+aSNyWTijjvuYO7cuRQWFvLoo4/y0Ucf0dTUZHRofqPic40TH3dO2kS9Z0KROi8hhBBCCCGEEOKs+nzSBkDXdXRdZ/DgwYwbN459+/axa9cuo8MSwnBmsxlFUTCbz/wq0DTN++PxeAyIrm8zu1Q4h3Z7uqLjsUh/PiGEEEIIIfyJXyRtTjd27Fi2b98uSRvh9yIiIrj55ptJT09n7ty5BAcHoyjtQ9bq6urIz89nz5497Nu3j9dffx2HQ5q9dqc7HxmNvfn7fwXXxLXy2m+/6sGIhBBCCCGEEL6mzydtdF3n+PHj6Hr7HeqsrCxGjx7NqlWrKC8vNzg6/5V3q4fRz5uwx0pfGyOkpKRwww038PDDD6OqKhZL507xYWFhXHrppYwfPx5N08jNzeUPf/gDxcXFxgTcRynI518IIYQQQghxdn2+q4jH42HevHmsXLmSxsZGQkJCGD16NJdddpnRofk1zcE5DQ0R3SswMJCkpCTsdjtWqxVFUbxVNkeOHOHTTz9l+fLlVFdXY7PZmDp1KrfeeisZGRkGR+6/wqrt3PjsMKPDEEIIIYQQQvSiPl9pA1BeXs4777xDdnY2wcHBDBw4kAkTJrBq1SoqKyuNDq/Pi52oors0yld2ztIcmaeRfKNKcKpUG/S28vJy3n77bb766szhNrW1tVRVVaEoCiNGjODBBx8kMjKSGTNmsH//fo4fP05LS4sBUfuX1bOOMDwvjujyQADMbpX40mCueiOdlbML0cyS9RRCCCGEEKKv84ukja7rrFu3jsbGRnRdJzIykszMTOLj4yVp0wtCMhVAxd2icXLDqQvN6jyduCt0kKRNr6urq2Pz5s1s3br1jHUdjYdVVeXgwYNMmDCBmTNnkpWVRWpqKiEhIZK06Qa7x1VidZrOun7fmCp0BYZuiSHueDAAqqaQtS2aVT8uQpNSNSGEEEIIIfo8v0jaABw7dgyn0wmA3W4nPj6eIUOGSEPiXhKSqZB0ncrJDTILka/weDzfOiuUpmlUVlaycuVKpk6dSnBwMImJiURHR1NRUdGLkfZNG2aUfOc2O3PLCamzepM2QgghhBBCCP/S53vanK6lpQWXy4Wu6yQmJjJ37lysVqvRYfk1Twt4nFIx4Ku+OR14ZmYm6enpBkbUx+lgbzJ3+jG7/OprWgghhBBCCHEav6m0AXjssce47777yM3NJTAwkBEjRjB16lSWLFlidGh+q+CvGik3q6TcIEOkfEHHTFImk4m2tjYURWH06NGYTO3DeDqmABc9QAd7i5m7/jDW6EiEEEIIIYQQPsKvbuF+9tln7N+/n9bWVhRFISAggGHDZDaW3hKUCuNeP3sPD2Esi8XCnXfeyRdffMGRI0dYtWoVixcvZu7cudhsNgDa2tpwuVwGR9o3xR0L4hcPXWB0GEIIIYQQQggf4ldJG13X+fLLL9mxY4c3aXPDDTd4pzoWPUtRFBTJ2fism266idtuu41Ro0YRGRnJhRdeyGWXXYaqqiiKQmlpKYcPH5bm3T1FB5PmV1/JQgghhBBCiO/gV8OjoH2q446LTkVRCA6WBp9CACQnJxMdHe2tqun4d4empiYaGhpwOBxGhCcAt1lj6dwCPGbN6FCEEEIIIYQQvcDvkjZOp5O2tjajwxDC55SUlFBaWkpYWBhWqxVdb28QHRISgslkIjAwkKCgIKxWqyRuDKLokHA0mJLMenSZ8lsIIYQQ4rylKArR0dH88pe/JD8/ny+//JLq6mqjw/Irh2uvodoxFACr2sCouOcMjqhrfpe0+Saz2Ux4eDh1dXXei1TRu1qP6zQe0gnJkGFqRtq6dSuxsbEUFRVhsVhwu90oisLFF19Meno6kZGRZGVlMWDAAAoKCmR/6WbOAA/Fg+oYUBAOwNGMOjwWnciKAMKr7QCYPCoXrUyiKqGFo4PrcNmk4kYIIYQQ4nykqioDBgzg97//PZ988gknTpygrq4Oj8djdGh+o7Duag7VXQ+A3VRNhL2A/qEr8LXuKX7dQKFjeFRubi4Wi8XocPxW1Vqd0nfl4tNoBw4c4KWXXuK+++7j5z//OXfeeSc///nPWbRoEU6nk+DgYC6//HImTpyI3W43Otw+py7Gwce3HaQ+0kF9pINPbznMh3cc4NCIzndcFBRmvjaI4HqrQZEKIYQQQoh/lcViYdSoUei6Tk5ODsnJyWe0JxA9p6mtHy4tyPvY4Yni46K3AR/L2OCHSRtd170/qqoSGhrKa6+9RmhoqNGh+TcdNLdUbhitsbGRhoYG7wxRuq6zevVq73CosWPHctVVVzFkyBAjw+wzVI+C6v76x6PgDPDwyu938Mrvd9AS2v7/QFN1NFX2DSGEEEKIvsJkMpGQkMAzzzyDyWSioqKCiooKWlpajA7NL3g0C0sKl1LcMO20pTomxTdnyfW7pM2OHTtYv349JSUl3mUBAQFkZmYSEBBgYGT+rWaLTv6/SylgbzObzcTExJx1BjVd19m0aRM1NTXeUs3ExERGjx7dm2H2WbP/NpR77h/HPfeP48bnhnW5zcZppXxyy6FejkwIIYQQQvQEq9XKqFGjWLBgAVZre+X0Cy+8QFFRkcGR+Y+Xd5dS6xjcaVmQpYxfZMegKL53s9TvkjZOp5Nt27axZMkS7zKz2cy8efN48MEHGT58uIHR9X2mQBi30ITSRTclxwnYMtctvVJ6QVBQEOPGjeOdd95h//79zJs3j6ysLO+B45s+//xz6uvreznKvm3un0YSXxqM8vU/sceD+Oljo87cUMEXqzSFEEIIIcQPMHDgQK6//nrGjh2L2+3mj3/8I++++653hmPRc9yanX/uKsWlBdPVCbav9bLp4HdJG4CoqChSU1OB9r42iqIQERFBaGjoWS9aRfdQFAXz2WZZ18Hd1Kvh+K34+HhmzJjBxIkTiYiIYMaMGdxxxx1kZ2d3qjhTFIXc3FwmT54sQwi7mb3VjKqdOjKomkJorY0bnx2GclrRWfaGOC75JNmACIUQQgghRHcaOHAg1157Lbfeeisej4fnn3+eefPmUVtbKzeue4nTE8HpCZvMiLf4ceZEZqRdb1xQ38EvZ49yuVy0trZ2WrZhwwZWrFjRadiU6F2WMOh/q1/mEXudx+PB4XAQEhKCrutERkbyox/9iPDwcLZs2UJBQQG1tbX069eP3NxcEhISMJvN1NXVsW/fPrZv3270r9AnqZpCwtFgLl+chv51H5uE4hAiTsrQTSGEEEKI81lYWBiTJ09m6tSpWK1WFi9ezGuvvcbx48eNDs0vtLhiyDvx0BnLgyzlxAdtNSCi788vkzYVFRXs3buXhoYGbDYbu3bt4s0332T9+vXU1dUZHZ5fssVAzASF+CsladMbamtr2bp1K3l5eeTk5ADtmf/Q0FCysrIoLCz0Jm369++P1WpFURROnDjBrl272L9/v8G/wfnvwKiTDNoRTWBz55nrFBRG5MWd9Xk6OvsvOInTLj2ghBBCCCHOB4qikJOTw5QpU0hPT+fw4cO8+uqr7Nmzx+jQ/EJjWzIHa2azr3qud1lq2FJspnpiA33/ZrRfJm2OHTvGunXrGDNmDKGhocybN49ly5bhdDqNDs1vBKWCfto1Z9gwhQG3mYwLyM/U19ezadMm/va3vxEbG0tUVBShoaHExMQQExPDuHHjUBSlU5mmx+OhoKCAffv2nVGpJs7d6muLiS8JPiNp832sur4It1XrgaiEEEIIIUR3Cw4OZvbs2eTk5NDW1sbWrVv54osvjA7Lb1S1jOTLE490WnZRwiNEBZy6Ee3RLNQ42mfIjQrYg6r4zg1Sv0zatLS0sG7dOtatW2d0KH5JURRG/sUvP3o+pbm5meXLl3PixAluu+02pk2bRkREBGazGVVV0XUdXdfRNA23201NTQ2rV69m61bfLh88n7hsGk6bG5NHxez+7iozHZ02m+8cQIQQQgghxHcbM2YMY8eOJSoqiry8PNavX+9dp6oqFosFq9WKyWTC5XLR3NxsYLR9i1uz4dI6txqwqA0oSvsNUI9mxa3baHb14+2CTQDcNiSLYOsxVMU3bpLKlbMQfkrXderr670JzMmTJ3PTTTcxadIk+vfv793mwIEDLF++nEWLFnHw4EGpsulG7/1yHwDD8mK54p2079zeZdX4+58laSaEEEIIcb4ICQnhueeeIz09nYMHD/LBBx/w7rvvetenp6fzs5/9jMmTJ9OvXz9WrVrFXXfdRWNjo4FR9x3byu9nW8V/dVo2d1g6VlMzug5fVd3FprLHOq1fsG8/12dOIC7IN4ZOSdJGCAHAF198wdq1a1FVFeW0+e50Xcfj8eDxeKSrfQ/Ze2El+y+oMjoM4eNMJhN2ux1A7sAZJDTgK1Qlgda2R3C6/2Z0OEIIIXycoijMmTOH5ORkGhsbeeutt1i8eDEAZrOZyZMnM2/ePG+1u6IoXHzxxfzud7/jgQceMDj6vm/V0X9ysNZ3Z43qIEkbIQQAmqahab5RAuhvdBU8qiTERNesVivp6elMnDiRK6+8EoAtW7awcuVKXC4XqampZGZmEhkZSUlJCZs2beK2226jpqYGTdM4fPgwO3bs4NChQwb/JucnhVBCAtYAoCrJKIoFu/U/sFl+ek6v09A6AWjq/gCFEEL4JFVViY2N5b/+678ICgpi5cqVbNiwgbKyMoKDg8nNzeX//u//iI6O7nTT1G63ExUVZXD0fcPqkuc5XHe197FJcXDj4HFY1BaWFb5HWdN4dM69v2Rv8+mkTWhoKGPHjiUlJYXc3FzKy8tZvXo1Bw4c4OTJkzJMoxesK/0Lza6ELtdN7n8nFlNLL0ckhBD+IzU1lRkzZpCbm8vgwYNJTEwEYPDgwUyePBlN0wgJCSE0NBSbzUZTUxPXXnstGRkZOBwOdF1n//79WCwWSdr8AKqSSoD1cUxqxjeWR4MSfU6vpWBCUrNCCOE/LBYLOTk5xMbGomka27Zt4+jRo4SFhXHJJZdw7733kpycDMCGDRsICwsjKSmJuro6mam1mzS5+uH0nJ4A0wm3Heazo69Q1nQJLi3EsNjOhU8mbSwWC/3792f8+PFMnz6duLg4Ro0aRXV1NZmZmWzZsoV169aRl5dndKh9kkezsLPqbgAO1l6Pw9P1iell+l29GZYQQviV2NhYbrnlFmbMmMGgQYMICTl1YhEWFuYdG9/U1ER9fb13+GJQUBBbt26lsrISj8fDsWPHKCkpMerXOG+ZlKFYLXOwmqcZHYoQQojzjMViITExkdmzZ6MoCtu2bWPbtm24XC5ycnKYM2cO48aNo6Wlhbfffptdu3Yxa9Ys+vXrR0lJiUyY0w32nPwZ9c5U72ObqZahUfPIr7yXw3XXoOk2A6M7Nz6XtAkPDyc9PZ3LL7+ca6+9ljFjxnjXNTc3M336dAYMGEBTU5MkbXqAyxPI8aZcviz7H6NDEUIIvxUWFsbUqVOZO3cuMTExlJeXs3//fqKiokhLS6O4uNh7UldVVYXHc2pWMV3X2bNnD4WFhXg8Hpqbm6Uy9RypSgZWy83YLf921m00vRKP9v3vhOq4uyM0IYQQ5wG73U5mZibTp08HYPHixRQUFJCSksLMmTOZMWMGmqaxefNmHnvsMS644AIiIiLQNI2CggJ27txp8G9w/tte8R80tvX3PjarLSSGrGdZ4QfAqf6dwZZS7OYaTrZme5clBG3EavKdRtA+lbSx2WxceumlzJ07l9zcXMLCwtA0jaamJpqbm/nss8+YPHmydypi0b3cmp3Klgv4qOh9o0MRQgi/FRAQQG5uLn/5y18ICAjg8OHDvPrqqyxfvpzLLruM3//+9/z973/nhRdewOl0Gh1un6MQhd16Pzbzjd5l7ecd5e3rlUjAicu9jJa2XxsUpRDtzcmtViuKotDS0nm4utlsJjAwkICAABobG89YL/5FmoKlOrzTIk9gK1qQo/2BDpaTEd517pBmdHtbb0bY53VMk202n7qctdvtWCyWThNqdNy8aG5uJiAgAJfLhdvd80l0u91OcnIyQUFBQPuEHxaLhWnTpnHZZZfhdrspKyvjkUceobm5mV/96lekpKSwa9cuduzY4fN9JnUdWj3fvV0Hi9qeJmnT2v8dYEAWotmVyLLCD89YPiBsOYnB61lRvMC7bFrajQSYa3ozvG/lM0kbRVGYPHkyjz/+OOnp6SiKgsfjobq6mr///e88/fTTBAYGsnjxYsxms5yodjNdVyiqn8HK4te6WOtBga/H4pt6NS4hhPAnAQEBjB8/nnnz5hEeHs6SJUt46aWXyMvLo6GhgeLiYoqKili+fLnRoaIoivfn9Jsp5/tNlWD7u5hNY72P238fN/WtQwA3wbYPcGlrcLqeNSzG9r+w8q3bKNJBp08zmUxkZGQwZswYgoKC+Oc//9npIi89PZ077riD2bNn8+c//5kXXnjBwGj7GB1MjUGMnj6/0+LSXyyi7Gft0zgrTiujps9D+Xo/PfQ/f6Hmyg29HmpflpCQwPDhwxkyZIh32bRp07jooosICAhA13XcbjcnTpzg2Wef5fnnn2f27Nls3bqV4uLiHk9kqqqKzdZ5+M2cOXO49tpriYuLY/Pmzdxzzz20tbWxbNkyhg8fzvbt23nxxRf58MMzEwu+RNdB02FJkY3vOhZ1yI52EWTW2VRuxaTo/DjdiQIo3+/pPWrPyTvZc/LOrx/pKGg+dwz1iaSNoijMmjWLF154gaioKBRF4eDBgyxevJjXXnuNwsJCdF0nICCAvXv3smXLFt577z2jw+5Tviz7I/mV93a57qoBt5EWvpSShiukCkcIIXpQYGAgkyZNIiKi/Q7tkiVL2LFjBw0NDQA4HA6fSNiEh4dz//33c91115GWlkZNTQ2ffPIJtbW1PPzwwzQ2Np73yZsOOrXUt6QC7RfETc5rjQ0IqLSNZkf4/zvr+qi2fYytfaIXIxK9yW638+CDD3LLLbcQExPDwYMHWb16NQcPHuy0na7reDweudHZzQIPDWDYT54yOgy/lpqayr333sttt91GYGCgd/npNxKgPbmZlJTEE088wT333ENsbCyNjY3MmzePRYsWsXfv3h6LMTw8nEsuucT7eODAgYwfP56kpCRMJhMDBgzgj3/8I9OmTcNkMrFv3z4ef/xx1q5d6/P7bKunI2Hz/X118lTawaPD24dsXJ/uxOwDSZvTKbj55cgoFM6hjKgXGJ60URSFqKgo/vu//5vw8HAURWHLli0sWLCAt956q9OJ36RJk/j444/Zs2cPzc3NBkfedyw/8hrFDVMB9Yx112VcTkzgDlTlVMZRVdq4fehgrKaGXo5UCCH6tpaWFtasWcN//ud/oigKjz32GPfddx9tbW2Ul5fzySefsH79evbs2WNonEOHDmXMmDFomsb+/fsxm81MmTKF4OBg0tLSeOSRR9i/f3+f6KWjEE5YQEGnZQ7XEzjd/zQooq8pZx6zO9RYB7Ex6hEuqf5DLwYkesvFF1/MuHHjSEhI4PDhwzzxxBMUFhZ2ua2qqt7hGaK7KCh65/3v8B+fpvbSzQbF41/+7d/+jVmzZpGdnU1QUFCnoVDfdPq6xMREFEUhMjKS0NBQrFZrj8ZZU1PDmjVrmD17NgBPPfUUUVFR2Gw2FEUhMTHRO6vUxx9/zOOPP86+fft8fihjVavC+jIr37fC5hTlG//tezd2As0nuGHwxSh4fKIC6HSGJ23MZjPJyckMGjQIs9lMWVkZb7/9NkuWLOk0GwZAXl4eLS0tNDU19Zk7eL7A6YnArX3zgK4zc+DVRAd+hVk9le0NNJczJfU2As0VPvdhFkKI853T6WTLli3cfvvtPPTQQwQGBhIdHY3dbic9PZ2kpCRaW1sNT9oUFhby6KOPomkaDocDi8VCWloaTz31FLm5uWRkZFBcXHxeJm1a2u7FbnnAO2uUoqgoSnznjRTfuAhWdBdja54EYHfYnbSaYwDQFQttaqiRoYkeNGDAAMLDw2lra+PIkSOsWbOmUzPy09ntdgYNGtTLEfofT2gTWqDD6DD8Qnp6OhkZGURGRnrbaTQ0NOByuQC8lTYdw5NCQkK8FTgd6+12+xlDl7pbbW0ty5cv55lnnuGee+4hPj4ek8mEoii43W6ampooLCzk2WefJT8/n+LiYhwOh89f42q6gtNzflwEThlwO+uPPUFFy4Xful1G+LsMi34Zk9pGkKWyl6I7N4YnbSwWC9nZ2QQEBKAoCl9++SXbtm2jvLz8jA/tiRMn0DTN5z/M5ztVcZKT8DBJIWtRlVONuiLsBYxLeJTE4I0GRieEEH2XpmnU1dXxySefoKoqdrudgIAABg8ezMUXX0xycjJhYWFGh8nJkyepq6vD5XLh8XhQVZXCwkIWLVrEv//7vzN69Gi2bNlCTY3vNPH7vjzaVzhd/8Dtae8/oSiBBFh/b3BUnQW7jzGo4U0UPES4DqAA6U0fUBw0hUZL/+98vji/7du3j5qaGsxmM/Hx8eTm5vLOO+90ua3JZCI4OLiXIxSiZ4SHhzNgwABCQ0MxmUw4HA4KCwt5/fXXqaurA04lbex2O/369SMnJ4fc3NxOrzNs2DCGDBnSozMRu91ujh8/zsKFC/F4PGRnZ5OZmUlsbCwNDQ18+eWXLFq0iNWrV583x8qKFoVDdV33N00O9hBl79w8eedJM+dekdN94oO2Yv+WZsKjYp8h0FxBbNB2n7++NTRpoygKwcHBTJo0CWjv7r1x40aOHj3aZWLmbHcRxA93pH4qLa64TstUxcWouOfO2DbUdpShtld7KTLhbwIDA8nIyKB///4cO3aMgoICGQbZizy6maK6mWcsD7aUkRDccyc1omt1dXUsXLgQaJ9Zcdy4cdhsNpKTk33ixoXb7e40+4amadTW1rJ06VLuvvtucnNzeffddzly5IiBUf5wbm01bm3114+CMKlDsJhmoXzLkKTeFOSpJLXl007LEh0bqLKNkKSNjzCZTCQmJpKYmEhQUBA1NTXk5+d3y2t3JG2sVisDBgzgmmuuYfHixXKefJo2TwhHG67otCwhKI9ga1mPvF/IjiE4EypoTTvWI68v2pnNZqxWK6qqoigK1dXVfP755/zzn/+kvr6+07Y2m42UlBQqKyvJzc3t1OsmLS2NtLS0Ho/X7Xaza9cuTp48yUUXXUR2djb9+vWjvr6ejRs3snjx4h6PoTu5NQVnF18zcYEe0sM8xAedStroOtQ6VY41qXh04xI3/YI3YlG7vp4YEfN/hFiP93JEP4yhSRuTyURUVBRTp04F2u/cdXywRe9YU/osza5E72NVcRJhO2RgRMIfBQUFMXToUO644w6uueYaPvvsM+bPn09eXp4Mh+wFbs1GdeswVhS/fsa61LClTJekjaGcTicVFRWUlfXMxUZ30XXd2zB55MiRPlER1D2aaXbOITywmq56vwnxTaqqkpyczNVXX82UKVOIiYlh1apV3Za00XUdh8OB0+kkMDCQQYMGERcX1+k7wmq1eqcD77jA7RgyoihKn65cb/OEcLzpkjOOaVNTbyLYurRH3rPfguvwBDhoTXu3y/XWqkjMNWFoAQ6s5TGg6Dj6HzeyCOG8dPLkSUpLS3E42oei1dTUsH37dhobG73bBAUFoart39WNjY0cOtR+XdOxD2iaRn19vfd41dM8Hg+lpaWUlpby7rtdfz7OF4nBGmYVvjjWudpmYKiHyK+rbDwaNLnaP9hDI91UtFgxMp98QVzfaBpueKWNzWYjKioKgKVLl1JUVOTdEUXvC7MVccPg8UaHIfyIoihMnDiRuXPnkpubS2RkJLNnz+a6667juuuuY+XKlbS1tRkdZp+l6SZOto7gvYNrjA5FfIuOE01ov+HhixRFISamvafKvn37Op1EC+FPIiIi+O1vf8uMGTOIiIggPz+fjz/+uNtev7W1lX379nHkyBEGDx5Mamoq119/PS+88AJutxtN00hKSiIlJQVVVQkNDcVms+F0Or2NUBsaGnrtorU3eTQLRfXTWXX0lU7LTYqj22aD0RUNzeZEdXbuiaK4zaiO9ua2irNzk9v+z/4Ua0U0DRd+xaDfPIhu8rBHU2eTAAAbzElEQVTti5vR7E5J3JwjXde9P0lJScyaNYvPP/+c2tpaAC6//HJCQkKA9mnBp0+fDrRXhHo8Hqqrq3njjTdYurRnEnj+aFO5lQtiXKSFeahxKHx+7Lv6BemY5HN/TgzvaXO6jqyoEMJ/JCQkcPfdd5OTk+Mdd6/rOtXV1WzatMnbWE70jIO1s1l11OBZcMR3qqqq4tChQ7S1tXHJJZfw9NNPGx3SGQIDA3nmmWcwmUy8/PLLHD161OiQhOh1VquVl19+mUmTJmG321m2bBl/+tOf2LFjR7e9h9vtpqCggOLiYgYPHkxwcDAPPfQQmZmZLFy4kMOHD1NaWsrhw4eZOXMmEyZMIDU1FYBHH30UVVVZsGABS5cu9SaD+4rNJ/5AfuW9Zyy/cfA4wm2Hu+U9WjOOkv/pXMZc9kan5YmvzCbxldnex8o3sjHxb/2I+Ld+1L7OY2LMpW+Rv/I23OGS4P6hIiIimDZtGhkZGTQ1NQHtlZ52u73LSrKNGzfyv//7v2zevNnbA0d0j+1VZrZXfb/UglmBH6c7ZVKbc+BTSZvZs2fzzjvvUFVVdV7OONEX1Doymbe7iJ8O7/lxnkIAvPHGG4wePZrAwEAURcHlclFWVsaLL75IbW1tny3f9i1dHzXHxD3OmPgnezkW0ZXW1lbveP0RI0YYHM2ZwsPDmT59Ov3796e+vp5NmzadN40V+4ovIx+iwTLA6DD8mqqq/OpXv2LSpEmEhITw/PPP88orr7B3795uf68VK1agaRqqqnLFFVcQGhrKT3/6U2677TbvtMEJCQlAe0L16aefJjs7m/DwcFRVZceOHaxcudLnpxf+YU4/pun8dFgqAeaTPX6B+M0kzXet/67tRdc++OADhg8fTmRkpHcYYFZWlnd9RzVqx3Aoj8dDS0sLy5cvZ/78+WzevLlPVpkZ7/t9nkMsGlP6t0nC5hwZmrRxu91UVVWxadMmcnJyCAoK4uqrr6atrY36+npGjBjBoEGDcDqd/M///I9cvPUKEy3uaN7c37mHxdDo+YyIedGgmERfZDKZuPPOOxk2bJh39jiHw8Hu3bt58sknWbt2rezzPWx7xW/YXfXzLtdNSPoN6eHvY1ZluKovGDx4MJdddhlhYWE+dZGlqiqpqanMnDmTX//619hsNh544AGOHj0qVXK9wIOZvKiHAWg2J6Ar7RcrYW2FDK+XCrrepigKV111FQEBAaxZs4ZVq1Zx+PDhHqlmcTgcrF+/nsrKSjZv3szdd99NeHg4VquVYcOGoWkaZnP7ab7ZbCYnJ4eAgABUVaW+vp7W1la/OcZaTE0oSvf+rp6AVnYv/DVD5/wF1e1T98D7vLy8PP70pz9x1113MX36dBRFOeuw4YqKCpYvX87atWtZs2YNNTU1UhjwL4q0a0xKbGP1cet3b3yaQeFuUsM8mBSwyOCac2bot4yu69TX17Nw4UIuvPBCTCYTU6dOJSMjA5fLRVxcHJGRkbS1tVFSUsI777wjO1o3y036T7ac+D01jiGnLTVR7Rjeabu9J3+KR7N1OauUEOfKarUycuRI7rzzTkJCQlAUBafTSV5eHq+//jpr1qyhurra6DD7tK3l91NQcyNNruQz1l2S+F+khS0j0FJlQGT+Ky4ujlGjRuHxeNiyZYu3siYwMJARI0Z4pyz1lWFHJpOJjIwMZsyYwU9+8hPi4uJ44403WLZsmbdM/XwTYP0rCu3DNN3aBtrcrwOBBFqfAXyrl5BTDeNAyE00mpP55i1Ls+4g2OPbjav7GovFwvDhw8nOzqa5uZkPP/yQXbt29Wifxvr6enbv3k1zczMDBw7kwgsvJDU1Fbvd3mk7RVEICgqisLAQp9PJihUrWL9+fZ/rF5dfcS/FDVd5H5sUB5NS7sak9MDvadJpySim6MHnUDSV+DeuJuhQ6vd+uq5qFD34PJ5Aua45Vy6XC03TUBSl04xQHVRVpba2lrVr17JkyRJ27drF8ePHqaysNCjivqXFpXC4/vsfD0fHuLCadCJsOuE2/0gU9wTDU8Otra2sWrWKyspK4uPjGTBgACkpKUD7CaGiKHg8HnJycvjwww8ladPN0sOX0OKKZ3/1bVS1jjzrdtWOYZQ2TZSkjfiXmc1m+vXrx0033cSIESO8B93jx4+zdu1ali9fLgmbHrav+ifsr/4JDW3fHAapMyz6ZbIiF2I31xoSmz9LSUlhzpw5KIrCwIED2bt3L/X19YwcOZKrr76a5ORkioqKeOONN777xXqYqqoMGzaMqVOnMnPmTAYOHEh+fj7z5s3j6NGj5+3Uw1bzdahK++QIJs9AFAJACcRmucm7TZv7Yzyer4wKEYAWUwzHA8ZzIuDiM9aFuIqJdXbPLEXi+zOZTKSkpBAdHU1JSQn5+flUVFT0aDWLruu0tLRw6NAhFi5cyO7du8nOzsZsNhMSEkJqaiqZmZlomsaxY8d45ZVXaGlpYePGjRw6dOi83U/PprRxkvcmpM1US1bk6wyOfLPn3lCB6qnrAFAddmKWXk7w/oxvfYoz9iS1EzaDqnNy2mppQnwOgoKCiI+PZ8iQIVxxxRWkp6d3uZ2u61RUVLBu3ToWL1583t5E8DUnmlUaXQqNbQqlTd8naaOTHuYhNdSD1bfueZyXDE/aeDweiouLKS0tJTY2FrPZ3KnETdf1by17E/+6ETEv0tSW9K1JGyG6S0REBOPHj+fGG2/0Jmxqa2tZv34969evp7y83OgQ+7wvy/5Iqzuu0zIFN3FBW8lNug+T4jYoMv8WFBREVlYWQ4YMYdy4ceTl5VFWVsZVV11FWloax44dY+XKlbzyyivf/WI9yGazkZqayuzZs5k1axaJiYns3buX119/nXXr1vWZxqZm0zjMpnFnLHe6XsStrTYgonataiTl9nEUBl/TaXmI6ygmvY0Exyb6t3xuUHT+y2QyERcXh6IoVFZWUl1djdPp7JX37qieWbNmDf3798dkMpGWlsZ1111HZmYmHo+HvXv38vzzz/vNzc9ASznjk37Xa+9Xed1ydJMH3fz18VNXCdkzqNM2bdHV1E7K4+h/vNxrcfUVqqqSkpLCrFmzuPzyyxk5ciQOh4Ndu3Z5p7JPTk4mNDQUaJ8KvKKiQhI23ehIg4mjjed2PX5BrBtVEpPdwvCkTYeOOxEdSZpv6qi6EcbRNCsOdzh2s3RbFz+MoihkZGRw9913ExsbC7RPwfjFF1/w4osvsnnzZoMj7Nt0HRyeSODMwcQWtZkfZ07u/aCE1+7du/nzn//MSy+9RHx8PNdddx2KotDW1kZpaSlr1qxhwYIFhsaoKArp6ek88MADXHHFFVitVrZt28aCBQsMj603aHotYFyvHrdi52jQFIqDpnZabtGayK77P4I9JwyKTNhsNiZNmgRAYWFhjw6LOhun08nBgweBU7Mwdvx3fX19nxsO5WuqZn1G1azPAFAcVsZOeLtTs+GTV62j9P+9ZlR45zWTycSwYcN46KGHMJvN6LrOokWLeO2119B1HYvFwqOPPsrEiRM7NSIWPUnHetrppFsHTe/8N3d6wG46YwSv+AF8JmnT2tqKpmldVtS43W4GDBiA1Wrtcuyi6A761z9n26t0jjVdytsFG7l96NBejEv0JWFhYaSmpnqnHoX2qYxfffVV9u/fb2Bk/kFHZd7uYvQzenPo0M1NGsW5q6mpYc2aNTz33HNcddVVpKeno6oqn3/+OQsWLODTTz815ELwdDabjT/84Q9cffXVuFwu3n33XebPn8/69esNjav76Oi6BijeE/72c472/aOh9SJ03ZheMTqwM/wuTtpOq4r9+nzo0qp7Meu9U9UhutZRaeNyuXjppZekf0Yv03UF3XsOq6Ogo+tnP6eVi8jzl67rNDU1UVRURH5++1BQq9XaacZRq9WK3W7HbDbjdkv1cE9QgGsHnpq2e0uFmcJ6c6ctPiyyc3Wqg0CLERH2LT6RtPF4PEyZMoV//OMfzJo1i8jISODUnYGHH36Yf/zjHzITRQ+6qN/DRAfsZuXRV7tcPzrur4xLeFSG3op/SXx8PFlZWURFRXmXzZ49m+3bt/tNybYvigrYzexBuUaH4fd0Xae8vJyHHnqIJ598kuDgYO/wwZaWFkNvWCiKQmxsLH/961+55pprcDgc/P3vf2fRokU9Mp2xUepb2vtRBFqfxmaZA4BOHfUtHf2fjDv5Xx/9BC2mzsMaVVxMrvgFCn2rN8n5xmazkZSUxKBBg3C73ezevRuz2cygQYMYMmQIWVlZOJ1O1q5dS1NTE4cPH5YLyW62YN8eGtvae2IODP+AsfGP88LOrnuzpYR+xoyB1/dmeOJfZLFYmDFjBoqi0NjYyAMPPMCSJUu86z0eDx999BE/+tGPMJvNjBo1itzcXDZs2OCtPhPifOYTSRto39kOHTrU6cKtsrKSN998k/nz50vCpoepioaidH3SNzH538kIXyx9LsS/JDw8nFmzZnH77bd7K+aOHTvGoUOHvOP+rVYrKSkpTJkyhYkTJwLw+uuvU1dXx6FDhzhxQkr/f6hWdyRvH9iI3sXQKAUwKW50HRbu/wpNO3MaR5Pq4JasUXJ3shd4PB4aGhpobGwEMLxHjKqqZGZmct999zFz5kxcLhdPPfUUCxcu5OjRo32s+rX9ONfa9gccricA0NEwMlmj056waTXFdKoxD3BXcWHNY6iSsDGc2WwmLCyMmJgY3G43t956K5MmTSIrK4uIiAgsFgu6rvOb3/yGpqYmXnjhBd59913Kysp6bP+pr6+nsrKS+vp6AgICeuQ9fImmW+gY+nu0YQonmnLQ6Pr2fmnjJF7bsx9VcXHrkBFyXDsPmEwmcnJyMJlMbNq0iW3btlFRUeFd7/F4+OCDD7jooou4+eabCQsLIykpiaFDh0rSpgfYTDpTUjpXd2ZHuwm26Hx1UspqeoLPJG0APv30UyZPnkxYWBh1dXWsWLGCV199VZpIGSzAfBKbud7oMMR5zmq1Eh0d7e1l4/F4eOutt2hoaCA5OZmBAwdywQUXcPHFFzN48GBiYmIAGDhwIA6Hgz179rB06VI++ugjI3+N85aum2hypZyxPCl4NYOjFrG08H3QFeqdaXTV80bBw7Ki95mWejNm1dghOv5A13WfSYZkZWVxww03MG3aNAICAnjjjTd48803KSkp6bM3VHRq0XXfmUGt1RSFrpwa1hjedojMxncI0GoMjEqcTlVVVFXFYrFw1113ERMTg9lsRtM0nE4nFRUVOBwOhg4dyi9/+UtSU1N588032bJlS48kZqurqykpKaGqqor+/fvTr18/pk+fzrp162hoaDA8GdyT3FoQbi3orOs9egCNrhRAY1nhB0xNvQWLqaVbY9AtLgqeeZTM+3+L2mYDIPKLHAILU3CFN1D0x2e79f38gc1mQ9d1KisrsdlsBAYGeq8RFUUhKSmJkJAQ743BpKQkhg8fzgcffGBw5H2PS4NtlRYm9Dt1DnC0wURxg0wc1FN8Kmlz+PBhXnrpJVauXElzczN79uyhoKDA6LD8RpR9HxfGP3rG8gj7AQOiEX2NqqqYzWbMZjMej4eqqiqWLl1KTEwMc+bMYdiwYWRkZJCamkpwcLD3eREREWiaRnJyMmFhYdhsNj799FNaWrr3BMtftbqjOdGUQ0nDlG/dTsdEScMUtpT/DpPiIj38faIC9vVSlMJISUlJXHjhhURERLBp0ybmz59PUVFRn03Y+LpI516SW1cT6ZLzI1/TMSNiZmYmRUVFrF69moMHD+J0Oqmrq8PlcjF+/HhmzZrFtGnTcDqduFwutm/f3u2xtLW1UVlZSUlJCWlpaaSnp/OLX/yCgoICmpub+3TSpjOdMXH/i6q0f1+VNY3nWNOkr9eplDRe+XWVTjcz6dRfnI9uOvV3tpfFYy+Lxxl7svvfr4/TdZ3a2loSEhIYNmwYN910E+PGjetUTTZ+/HguuOAC7HY70F6dYzb71KVun6HpCmXNKrurT/19y5pV6tvOvOknuodPfZJbW1t57733jA7Db0UGHODCgMeNDkP0UfHx8URERADgcrkoLCxk586dzJkzh9tvv52kpCRMJhO6rnuHh1RWVhIREUF4eDhxcXFcfvnlhISEcOjQIXbt2mXwb3T+i7TvQ1E09lb/7Hs/J7/iPqA9mStJG/8QEhLibbC6adMm1q5d26kKyGQyYbPZMJvNhIaGenvxlJSU0NzcbGDkfVNk2wESHFs6LauyDu9UiQOg6m1Et8k+aoTm5maWL1/OvHnz2LlzZ6cESX5+vrc/x8SJEzly5EiPJG2gvc3Azp07ueSSS+jXrx/9+vXjkUceQVX948JKwU3/0M8YG/+/mNT2mbMO1V5LmxZMZctYg6MT58Lj8ZCfn8/gwYMZNWoUaWlp1NfXU1NTQ1VVFUFBQYwYMcJ7/Kmvr6egoIB9++Q7sOco7K3xqVRCnyZ/aSFEr8jJySErKwtonxGuqKiIlpYWfve73xEXF4fJZELTNNra2qiqqmLLli2sW7eO7OxsLrzwQpKSkggODmb48OFMnTqVPXv2+NGdwp4xNPoVbKZ6Vh19+Yx1AeYKzGp7jzFNN9PsSuq0vtUdjcMdgd3sO0NIRM9QFMV7kRccHEy/fv06JW06kjrBwcFkZmYSFhaGrussXLiQoqIio8Lus9xqIC2m6E7Ldob/PzyqrdMym6eGSVW/7s3Q/FbHzQaXy4XZbOb48ePMnz+fr7766ozjVEFBAY8++iiZmZkkJiYSHx/fYzPclJSU8MUXX3DzzTcTHx/f7a/vy1SljXDbYWYM/HGn5RkR7xNoruKzoy/T9PVxrdGVjFlt9SZ2upMzoRJ7SSKqWy65/hUul4uFCxdy6aWXEhsbS2hoKOHh4fTv3/+MbZ1OJ9u3b+ett95i2bJlBkTbN9lMOlZVp037vk2gdILMMlNbd5FvECFEr+goG/8mk8nkHX/c0tLC7t27+dvf/sZbb73l3WbEiBHMmTOHq6++moSEBGbPns0rr7zCyZNSYtwTVKWNyf1/Qf/QzwCocwxk4f7OlU3rj/2VprZkLkn8byNCFL2ooqKC/fv3k5GRwY9//GNyc9tnGuvouxMcHEx0dDSqqnLkyBHuueceamtrZcrjbqTqHjyYQVEoDppKcdDULrdTdA8d05Orukwe0FtcLhdVVVXeoUhOp5O2tjYURfHekDg90VlaWkprayvJyclkZ2eTlJREcXFxt8fV2NjIkSNHKCsr6zQza19kUlyARkdPtjBrETcMuhiP1j70SVVc3ovHfsEbmJU+zXtce+vAZm4YdDExgV91e1y737qHYbc+RUBRsneZbpbm4efK7XbzxRdfcP/99/OLX/yC7OxsQkJCutw2Pz+fJ598kjVr1sgw3m50QaybIIvOV1XfM32gwIzUNlRJ2nQLSdoIIXpFQ0PDtw6VqK2tZf78+TzxxBNnJGPKyso4ceIETU1NmEwmIiMjsVrPnOFIdI9bs0YSYj1qdBjCR6xbt46ioiL27t3LPffcw7Bhw1AUhYaGBnbu3MmuXbuoqKhg0aJFMmyxByjA5Mqfsy76r7SaY7512xH1/yDesbl3AhNeLpeL8vJy8vLySEtLIyUlhaeeeoqGhgZ27drFkiVL2Llzp3f72NhYbDYbJpMJk8nUo8OVDhw4wNixfX8o0E+GDGVp4TJKGy8DoNY5iBe+OlUJekvWSCLshwEoaZzMssLea0675/Xf9Np79XWLFy9m8eLFRofhtwaFexgULklHI0jSRgjRK9auXcu4cePIzc3Fbrczfvx4srOzvSerDoeDmpoaqqurz3juDTfcwPXXX8/gwYNpampiw4YNMv13N/jy+KOgnF66rzN32EACzVXfWc46KfkuMiPf6dH4hO84fvw4Tz75JM8//7y3ak7XddxuN5qmeYc2ip6hABdXP4jOt++YZt3xHVuInlJXV8dvf/tbkpOTueiii5gwYQIbN26ktLT0jGGCjz/+OEOHDqWsrIzdu3dz/Phxg6LuO9qPWadXEX3LnqAr376+u8lOKfoIGepkHEnaCCF6xcmTJzlw4ACHDx9m4MCBJCYm8swzz1BaWsrixYvZsWMHeXl5Z5RuT5s2jRkzZpCWlobZbMbpdFJUVNRnS7x7k1sP7HyOC9hNtSinJXKON45n/fEnz3iuxdSM5eueN6Lv03Udh8OBwyHTvRvFosuMeb5M0zQqKyt57rnnUBSF0aNHA5CSksJll13G5s2bsdvtzJkzhyuvvBKA999/n7ffflsSnt0kN+k+tpffT0HtTWesW178Omal/fvL6QnvtO7qgTMItx3qlRiFEOKHkKSNEKJXOBwOtm7dyqeffsqcOXMIDg5m7Nix1NfXA2A2m5kwYQJXXXUVhw4dYtCgQQQFBTFq1KhOY5ebmpp6bKaNvsxqauTSpF+z9thTdIz578q6Y39FUU6VvjY4B3CydUQvRCiEEOc3t9vN+vXrCQgI4O677yYxMZGZM2cyYcIEjh8/jtlsZvTo0TgcDt5++23ef/99Dh48KDchukmk/SDDY17EpDrYVz2307rqLo5jCm4mJP0H/YI39kgTYiGE6C6StBFC9Apd1zlw4AAfffQRcXFx5OTkkJSUREBAAGPGjCEpKYno6Giio6M5ePAgWVlZBAUFERQUhN1uR9M0CgsLWbFiBV991f3NAvs6s+pgWPTLVLaM4mDtbDx6QBdbKeyt/mmvxyaEEH1FVVUVK1asICoqiiuvvJKsrCxSU1MZOXIkDoeDsrIyli9fzuLFiykoKKC1VSoWu1N80FYUNBzuKIrqZ551O4vaREbEuwyLflmGfAghfJ4kbYQQvaahoYFNmzZRU1PDT37yE+8sNCaTicTERKB9touEhATq6uqoq6vzPre5uZm1a9cyb948SktLDYn/fKcoOpf3v4tGVzIOd+S/9Fp2k0z1LYQQXTl58iQvvvgiBQUFTJo0iYyMDHRdp6amhry8PN577z0aGxulwqaHxAVt55LE39HQlnLWbYIs5VyWcncvRiWEED+cJG2EEL2qpaWF/Px88vPzjQ7Fb81K/5HRIQghRJ/mdDpZsWIFK1asMDoUvxRmK+bGwZcYHYYQQnSLnptjUAghhBBCCCGEEEL8YJK0EUIIIYQQQgghhPBBkrQRQgghhBBCCCGE8EGStBFCCCGEEEIIIYTwQZK0EUIIIYQQQgghhPBBkrQRQgghhBBCCCGE8EGStBFCCCGEEEIIIYTwQZK0EUIIIYQQQgghhPBBiq7r339jRakCjvZcOEL4tP66rscYHURXZN8Ufs4n903ZL4WQfVMIHyX7phC+qct985ySNkIIIYQQQgghhBCid8jwKCGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIHyRJGyGEEEIIIYQQQggfJEkbIYQQQgghhBBCCB8kSRshhBBCCCGEEEIIH/T/AWaL6qSCNoaSAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KkpgIcE2FeKI"
      },
      "source": [
        "You see from the images above the colors assigned to each class (i.e 0 to 9 plus the background). If you don't like these colors, feel free to rerun the cell where `colors` is defined to get another set of random colors. Alternatively, you can assign the RGB values for each class instead of relying on random values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QFv2k8xabRb8"
      },
      "source": [
        "## Define the Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_ylpyqJDQiF"
      },
      "source": [
        "As discussed in the lectures, the image segmentation model will have two paths:\n",
        "\n",
        "1. **Downsampling Path** - This part of the network extracts the features in the image. This is done through a series of convolution and pooling layers. The final output is a reduced image (because of the pooling layers) with the extracted features. You will build a custom CNN from scratch for this path.\n",
        "\n",
        "2. **Upsampling Path** - This takes the output of the downsampling path and generates the predictions while also converting the image back to its original size. You will use an FCN-8 decoder for this path."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHlBUZvsDybt"
      },
      "source": [
        "### Define the Basic Convolution Block"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T-XO9xkN1OR3"
      },
      "source": [
        "<a name='exercise-1'></a>\n",
        "\n",
        "#### **Exercise 1**\n",
        "\n",
        "Please complete the function below to build the basic convolution block for our CNN. This will have two [Conv2D](https://keras.io/api/layers/convolution_layers/convolution2d/) layers each followed by a [LeakyReLU](https://keras.io/api/layers/activation_layers/leaky_relu/), then [max pooled](https://keras.io/api/layers/pooling_layers/max_pooling2d/) and [batch-normalized](https://keras.io/api/layers/normalization_layers/batch_normalization/). Use the functional syntax to stack these layers.\n",
        "\n",
        "$$Input -> Conv2D -> LeakyReLU -> Conv2D -> LeakyReLU -> MaxPooling2D -> BatchNormalization$$\n",
        "\n",
        "When defining the Conv2D layers, note that our data inputs will have the 'channels' dimension last. You may want to check the `data_format` argument in the [docs](https://keras.io/api/layers/convolution_layers/convolution2d/) regarding this. Take note of the `padding` argument too like you did in the ungraded labs.\n",
        "\n",
        "Lastly, to use the `LeakyReLU` activation, you **do not** need to nest it inside an `Activation` layer (e.g. `x = tf.keras.layers.Activation(tf.keras.layers.LeakyReLU()(x)`). You can simply stack the layer directly instead (e.g. `x = tf.keras.layers.LeakyReLU()(x)`)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "azEEVytHR0Kn"
      },
      "source": [
        "# parameter describing where the channel dimension is found in our dataset\n",
        "IMAGE_ORDERING = 'channels_last'\n",
        "\n",
        "def conv_block(input, filters, kernel_size, pooling_size, pool_strides):\n",
        "  '''\n",
        "  Args:\n",
        "    input (tensor) -- batch of images or features\n",
        "    filters (int) -- number of filters of the Conv2D layers\n",
        "    kernel_size (int) -- kernel_size setting of the Conv2D layers\n",
        "    pooling_size (int) -- pooling size of the MaxPooling2D layers\n",
        "    pool_strides (int) -- strides setting of the MaxPooling2D layers\n",
        "  \n",
        "  Returns:\n",
        "    (tensor) max pooled and batch-normalized features of the input \n",
        "  '''\n",
        "  ### START CODE HERE ###\n",
        "  # use the functional syntax to stack the layers as shown in the diagram above\n",
        "  x = tf.keras.layers.Conv2D(filters, kernel_size, padding='same', data_format=IMAGE_ORDERING)(input)\n",
        "  x = tf.keras.layers.LeakyReLU()(x)\n",
        "  x = tf.keras.layers.Conv2D(filters,kernel_size,padding='same')(x)\n",
        "  x = tf.keras.layers.LeakyReLU()(x)\n",
        "  x = tf.keras.layers.MaxPooling2D(pool_size=pooling_size,strides=pool_strides)(x)\n",
        "  x = tf.keras.layers.BatchNormalization()(x)\n",
        "  ### END CODE HERE ###\n",
        "\n",
        "  return x"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uGtlHuM6KCRg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48913d0e-b43b-413b-f131-d1bbdecbf0b5"
      },
      "source": [
        "# TEST CODE:\n",
        "\n",
        "test_input = tf.keras.layers.Input(shape=(64,84, 1))\n",
        "test_output = conv_block(test_input, 32, 3, 2, 2)\n",
        "test_model = tf.keras.Model(inputs=test_input, outputs=test_output)\n",
        "\n",
        "print(test_model.summary())\n",
        "\n",
        "# free up test resources\n",
        "del test_input, test_output, test_model"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 64, 84, 1)]       0         \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 64, 84, 32)        320       \n",
            "                                                                 \n",
            " leaky_re_lu (LeakyReLU)     (None, 64, 84, 32)        0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 64, 84, 32)        9248      \n",
            "                                                                 \n",
            " leaky_re_lu_1 (LeakyReLU)   (None, 64, 84, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 32, 42, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 32, 42, 32)       128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 9,696\n",
            "Trainable params: 9,632\n",
            "Non-trainable params: 64\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mmf_ZaMP2rV3"
      },
      "source": [
        "**Expected Output**:\n",
        "\n",
        "Please pay attention to the *(type)* and *Output Shape* columns. The *Layer* name beside the type may be different depending on how many times you ran the cell (e.g. `input_7` can be `input_1`)\n",
        "\n",
        "```txt\n",
        "Model: \"functional_1\"\n",
        "_________________________________________________________________\n",
        "Layer (type)                 Output Shape              Param #   \n",
        "=================================================================\n",
        "input_1 (InputLayer)         [(None, 64, 84, 1)]       0         \n",
        "_________________________________________________________________\n",
        "conv2d (Conv2D)              (None, 64, 84, 32)        320       \n",
        "_________________________________________________________________\n",
        "leaky_re_lu (LeakyReLU)      (None, 64, 84, 32)        0         \n",
        "_________________________________________________________________\n",
        "conv2d_1 (Conv2D)            (None, 64, 84, 32)        9248      \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_1 (LeakyReLU)    (None, 64, 84, 32)        0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d (MaxPooling2D) (None, 32, 42, 32)        0         \n",
        "_________________________________________________________________\n",
        "batch_normalization (BatchNo (None, 32, 42, 32)        128       \n",
        "=================================================================\n",
        "Total params: 9,696\n",
        "Trainable params: 9,632\n",
        "Non-trainable params: 64\n",
        "_________________________________________________________________\n",
        "None\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4-jJbC91EXTV"
      },
      "source": [
        "### Define the Downsampling Path"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2ueOTmc3HxJ"
      },
      "source": [
        "<a name='exercise-2'></a>\n",
        "\n",
        "#### **Exercise 2**\n",
        "\n",
        "Now that we've defined the building block of our encoder, you can now build the downsampling path. Please complete the function below to create the encoder. This should chain together five convolution building blocks to create a feature extraction CNN minus the fully connected layers.\n",
        "\n",
        "*Notes*: \n",
        "1. To optimize processing or to make the output dimensions of each layer easier to work with, it is sometimes advisable to apply some zero-padding to the input image. With the boilerplate code we have provided below, we have padded the input width to 96 pixels using the [ZeroPadding2D layer](https://keras.io/api/layers/reshaping_layers/zero_padding2d/). This works well if you're going to use the first ungraded lab of this week as reference. This is not required however. You can remove it later and see how it will affect your parameters. For instance, you might need to pass in a non-square kernel size to the decoder in Exercise 3 (e.g. `(4,5)`) to match the output dimensions of Exercise 2. \n",
        "\n",
        "2. We recommend keeping the pool size and stride parameters constant at 2."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F2VNB99LRwQr"
      },
      "source": [
        "def FCN8(input_height=64, input_width=84):\n",
        "    '''\n",
        "    Defines the downsampling path of the image segmentation model.\n",
        "\n",
        "    Args:\n",
        "      input_height (int) -- height of the images\n",
        "      width (int) -- width of the images\n",
        "\n",
        "    Returns:\n",
        "    (tuple of tensors, tensor)\n",
        "      tuple of tensors -- features extracted at blocks 3 to 5\n",
        "      tensor -- copy of the input\n",
        "    '''\n",
        "   \n",
        "    img_input = tf.keras.layers.Input(shape=(input_height,input_width, 1))\n",
        "\n",
        "    ### START CODE HERE ###\n",
        "    \n",
        "    # pad the input image width to 96 pixels\n",
        "    x = tf.keras.layers.ZeroPadding2D(((0, 0), (0, 96-input_width)))(img_input)\n",
        "\n",
        "    # Block 1\n",
        "    x = conv_block(x, 32, kernel_size=(3,3), pooling_size=(2,2), pool_strides=(2,2))\n",
        "    \n",
        "    # Block 2\n",
        "    x = conv_block(x, 64, kernel_size=(3,3), pooling_size=(2,2), pool_strides=(2,2))\n",
        "\n",
        "    # Block 3\n",
        "    x = conv_block(x, 128, kernel_size=(3,3), pooling_size=(2,2), pool_strides=(2,2))\n",
        "    # save the feature map at this stage\n",
        "    f3 = x\n",
        "\n",
        "    # Block 4\n",
        "    x = conv_block(x, 256, kernel_size=(3,3), pooling_size=(2,2), pool_strides=(2,2))\n",
        "    # save the feature map at this stage\n",
        "    f4 = x\n",
        "\n",
        "    # Block 5\n",
        "    x = conv_block(x, 256, kernel_size=(3,3), pooling_size=(2,2), pool_strides=(2,2))\n",
        "    # save the feature map at this stage\n",
        "    f5 = x\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "  \n",
        "    return (f3, f4, f5), img_input"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HVQm1W0CNICS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eeea932a-328a-4b97-c827-db45079f706d"
      },
      "source": [
        "# TEST CODE:\n",
        "\n",
        "test_convs, test_img_input = FCN8()\n",
        "test_model = tf.keras.Model(inputs=test_img_input, outputs=[test_convs, test_img_input])\n",
        "\n",
        "print(test_model.summary())\n",
        "\n",
        "del test_convs, test_img_input, test_model"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_2 (InputLayer)        [(None, 64, 84, 1)]       0         \n",
            "                                                                 \n",
            " zero_padding2d (ZeroPadding  (None, 64, 96, 1)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 64, 96, 32)        320       \n",
            "                                                                 \n",
            " leaky_re_lu_2 (LeakyReLU)   (None, 64, 96, 32)        0         \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 64, 96, 32)        9248      \n",
            "                                                                 \n",
            " leaky_re_lu_3 (LeakyReLU)   (None, 64, 96, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 32, 48, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 32, 48, 32)       128       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 32, 48, 64)        18496     \n",
            "                                                                 \n",
            " leaky_re_lu_4 (LeakyReLU)   (None, 32, 48, 64)        0         \n",
            "                                                                 \n",
            " conv2d_5 (Conv2D)           (None, 32, 48, 64)        36928     \n",
            "                                                                 \n",
            " leaky_re_lu_5 (LeakyReLU)   (None, 32, 48, 64)        0         \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 16, 24, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_2 (Batc  (None, 16, 24, 64)       256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_6 (Conv2D)           (None, 16, 24, 128)       73856     \n",
            "                                                                 \n",
            " leaky_re_lu_6 (LeakyReLU)   (None, 16, 24, 128)       0         \n",
            "                                                                 \n",
            " conv2d_7 (Conv2D)           (None, 16, 24, 128)       147584    \n",
            "                                                                 \n",
            " leaky_re_lu_7 (LeakyReLU)   (None, 16, 24, 128)       0         \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 8, 12, 128)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_3 (Batc  (None, 8, 12, 128)       512       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_8 (Conv2D)           (None, 8, 12, 256)        295168    \n",
            "                                                                 \n",
            " leaky_re_lu_8 (LeakyReLU)   (None, 8, 12, 256)        0         \n",
            "                                                                 \n",
            " conv2d_9 (Conv2D)           (None, 8, 12, 256)        590080    \n",
            "                                                                 \n",
            " leaky_re_lu_9 (LeakyReLU)   (None, 8, 12, 256)        0         \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 4, 6, 256)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_4 (Batc  (None, 4, 6, 256)        1024      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " conv2d_10 (Conv2D)          (None, 4, 6, 256)         590080    \n",
            "                                                                 \n",
            " leaky_re_lu_10 (LeakyReLU)  (None, 4, 6, 256)         0         \n",
            "                                                                 \n",
            " conv2d_11 (Conv2D)          (None, 4, 6, 256)         590080    \n",
            "                                                                 \n",
            " leaky_re_lu_11 (LeakyReLU)  (None, 4, 6, 256)         0         \n",
            "                                                                 \n",
            " max_pooling2d_5 (MaxPooling  (None, 2, 3, 256)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_5 (Batc  (None, 2, 3, 256)        1024      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2,354,784\n",
            "Trainable params: 2,353,312\n",
            "Non-trainable params: 1,472\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sxklZe_D3jOI"
      },
      "source": [
        "**Expected Output**:\n",
        "\n",
        "You should see the layers of your `conv_block()` being repeated 5 times like the output below.\n",
        "\n",
        "```txt\n",
        "Model: \"functional_3\"\n",
        "_________________________________________________________________\n",
        "Layer (type)                 Output Shape              Param #   \n",
        "=================================================================\n",
        "input_3 (InputLayer)         [(None, 64, 84, 1)]       0         \n",
        "_________________________________________________________________\n",
        "zero_padding2d (ZeroPadding2 (None, 64, 96, 1)         0         \n",
        "_________________________________________________________________\n",
        "conv2d_2 (Conv2D)            (None, 64, 96, 32)        320       \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_2 (LeakyReLU)    (None, 64, 96, 32)        0         \n",
        "_________________________________________________________________\n",
        "conv2d_3 (Conv2D)            (None, 64, 96, 32)        9248      \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_3 (LeakyReLU)    (None, 64, 96, 32)        0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d_1 (MaxPooling2 (None, 32, 48, 32)        0         \n",
        "_________________________________________________________________\n",
        "batch_normalization_1 (Batch (None, 32, 48, 32)        128       \n",
        "_________________________________________________________________\n",
        "conv2d_4 (Conv2D)            (None, 32, 48, 64)        18496     \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_4 (LeakyReLU)    (None, 32, 48, 64)        0         \n",
        "_________________________________________________________________\n",
        "conv2d_5 (Conv2D)            (None, 32, 48, 64)        36928     \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_5 (LeakyReLU)    (None, 32, 48, 64)        0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d_2 (MaxPooling2 (None, 16, 24, 64)        0         \n",
        "_________________________________________________________________\n",
        "batch_normalization_2 (Batch (None, 16, 24, 64)        256       \n",
        "_________________________________________________________________\n",
        "conv2d_6 (Conv2D)            (None, 16, 24, 128)       73856     \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_6 (LeakyReLU)    (None, 16, 24, 128)       0         \n",
        "_________________________________________________________________\n",
        "conv2d_7 (Conv2D)            (None, 16, 24, 128)       147584    \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_7 (LeakyReLU)    (None, 16, 24, 128)       0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d_3 (MaxPooling2 (None, 8, 12, 128)        0         \n",
        "_________________________________________________________________\n",
        "batch_normalization_3 (Batch (None, 8, 12, 128)        512       \n",
        "_________________________________________________________________\n",
        "conv2d_8 (Conv2D)            (None, 8, 12, 256)        295168    \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_8 (LeakyReLU)    (None, 8, 12, 256)        0         \n",
        "_________________________________________________________________\n",
        "conv2d_9 (Conv2D)            (None, 8, 12, 256)        590080    \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_9 (LeakyReLU)    (None, 8, 12, 256)        0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d_4 (MaxPooling2 (None, 4, 6, 256)         0         \n",
        "_________________________________________________________________\n",
        "batch_normalization_4 (Batch (None, 4, 6, 256)         1024      \n",
        "_________________________________________________________________\n",
        "conv2d_10 (Conv2D)           (None, 4, 6, 256)         590080    \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_10 (LeakyReLU)   (None, 4, 6, 256)         0         \n",
        "_________________________________________________________________\n",
        "conv2d_11 (Conv2D)           (None, 4, 6, 256)         590080    \n",
        "_________________________________________________________________\n",
        "leaky_re_lu_11 (LeakyReLU)   (None, 4, 6, 256)         0         \n",
        "_________________________________________________________________\n",
        "max_pooling2d_5 (MaxPooling2 (None, 2, 3, 256)         0         \n",
        "_________________________________________________________________\n",
        "batch_normalization_5 (Batch (None, 2, 3, 256)         1024      \n",
        "=================================================================\n",
        "Total params: 2,354,784\n",
        "Trainable params: 2,353,312\n",
        "Non-trainable params: 1,472\n",
        "_________________________________________________________________\n",
        "None\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LbjYEQU8Eq-T"
      },
      "source": [
        "### Define the FCN-8 decoder"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ux5nAU155E5O"
      },
      "source": [
        "<a name='exercise-3'></a>\n",
        "\n",
        "#### **Exercise 3**\n",
        "\n",
        "Now you can define the upsampling path taking the outputs of convolutions at each stage as arguments. This will be very similar to what you did in the ungraded lab (VGG16-FCN8-CamVid) so you can refer to it if you need a refresher. \n",
        "* Note: remember to set the `data_format` parameter for the Conv2D layers. \n",
        "\n",
        "Here is also the diagram you saw in class on how it should work:\n",
        "\n",
        "<img src='https://drive.google.com/uc?export=view&id=1lrqB4YegV8jXWNfyYAaeuFlwXIc54aRP' alt='fcn-8'>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "giYEct_Se5Xj"
      },
      "source": [
        "def fcn8_decoder(convs, n_classes):\n",
        "  # features from the encoder stage\n",
        "  f3, f4, f5 = convs\n",
        "\n",
        "  # number of filters\n",
        "  n = 512\n",
        "\n",
        "  # add convolutional layers on top of the CNN extractor.\n",
        "  o = tf.keras.layers.Conv2D(n , (7 , 7) , activation='relu' , padding='same', name=\"conv6\", data_format=IMAGE_ORDERING)(f5)\n",
        "  o = tf.keras.layers.Dropout(0.5)(o)\n",
        "\n",
        "  o = tf.keras.layers.Conv2D(n , (1 , 1) , activation='relu' , padding='same', name=\"conv7\", data_format=IMAGE_ORDERING)(o)\n",
        "  o = tf.keras.layers.Dropout(0.5)(o)\n",
        "\n",
        "  o = tf.keras.layers.Conv2D(n_classes,  (1, 1), activation='relu' , padding='same', data_format=IMAGE_ORDERING)(o)\n",
        "\n",
        "    \n",
        "### START CODE HERE ###\n",
        "\n",
        "  # Upsample `o` above and crop any extra pixels introduced\n",
        "  o = tf.keras.layers.Conv2DTranspose(n_classes , kernel_size=(4,4) ,  strides=(2,2) , use_bias=False )(f5)\n",
        "  o = tf.keras.layers.Cropping2D(cropping=(1,1))(o)\n",
        "\n",
        "  # load the pool 4 prediction and do a 1x1 convolution to reshape it to the same shape of `o` above\n",
        "  o2 = f4\n",
        "  o2 = ( tf.keras.layers.Conv2D(n_classes , ( 1 , 1 ) , activation='relu' , padding='same'))(o2)\n",
        "\n",
        "  # add the results of the upsampling and pool 4 prediction\n",
        "  o = tf.keras.layers.Add()([o, o2])\n",
        "\n",
        "  # upsample the resulting tensor of the operation you just did\n",
        "  o =  (tf.keras.layers.Conv2DTranspose( n_classes , kernel_size=(4,4) ,  strides=(2,2) , use_bias=False ))(o)\n",
        "  o = tf.keras.layers.Cropping2D(cropping=(1, 1))(o)\n",
        "\n",
        "  # load the pool 3 prediction and do a 1x1 convolution to reshape it to the same shape of `o` above\n",
        "  o2 = f3\n",
        "  o2 = tf.keras.layers.Conv2D(n_classes , ( 1 , 1 ) , activation='relu' , padding='same', data_format=IMAGE_ORDERING)(o2)\n",
        "\n",
        "  # add the results of the upsampling and pool 3 prediction\n",
        "  o = tf.keras.layers.Add()([o, o2])\n",
        "\n",
        "  # upsample up to the size of the original image\n",
        "  o = tf.keras.layers.Conv2DTranspose(n_classes , kernel_size=(8,8) ,  strides=(8,8) , use_bias=False )(o)\n",
        "  o = tf.keras.layers.Cropping2D(((0, 0), (0, 96-84)))(o)\n",
        "\n",
        "  # append a sigmoid activation\n",
        "  o = (tf.keras.layers.Activation('sigmoid'))(o)\n",
        "  ### END CODE HERE ###\n",
        "\n",
        "  return o"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lQHioDlR5K1_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fdcedb17-1814-4fdb-e78c-dfd4a303ed4d"
      },
      "source": [
        "# TEST CODE\n",
        "\n",
        "test_convs, test_img_input = FCN8()\n",
        "test_fcn8_decoder = fcn8_decoder(test_convs, 11)\n",
        "\n",
        "print(test_fcn8_decoder.shape)\n",
        "\n",
        "del test_convs, test_img_input, test_fcn8_decoder"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(None, 64, 84, 11)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C1qTwTX-5fwH"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```txt\n",
        "(None, 64, 84, 11)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJOhQz86Qk6n"
      },
      "source": [
        "### Define the Complete Model\n",
        "\n",
        "The downsampling and upsampling paths can now be combined as shown below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9EJEf484312h",
        "lines_to_next_cell": 2
      },
      "source": [
        "# start the encoder using the default input size 64 x 84\n",
        "convs, img_input = FCN8()\n",
        "\n",
        "# pass the convolutions obtained in the encoder to the decoder\n",
        "dec_op = fcn8_decoder(convs, n_classes)\n",
        "\n",
        "# define the model specifying the input (batch of images) and output (decoder output)\n",
        "model = tf.keras.Model(inputs = img_input, outputs = dec_op)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2GAenp1M4gXx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89725070-f395-4670-81a8-048632b7f32f"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_2\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_4 (InputLayer)           [(None, 64, 84, 1)]  0           []                               \n",
            "                                                                                                  \n",
            " zero_padding2d_2 (ZeroPadding2  (None, 64, 96, 1)   0           ['input_4[0][0]']                \n",
            " D)                                                                                               \n",
            "                                                                                                  \n",
            " conv2d_25 (Conv2D)             (None, 64, 96, 32)   320         ['zero_padding2d_2[0][0]']       \n",
            "                                                                                                  \n",
            " leaky_re_lu_22 (LeakyReLU)     (None, 64, 96, 32)   0           ['conv2d_25[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_26 (Conv2D)             (None, 64, 96, 32)   9248        ['leaky_re_lu_22[0][0]']         \n",
            "                                                                                                  \n",
            " leaky_re_lu_23 (LeakyReLU)     (None, 64, 96, 32)   0           ['conv2d_26[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_11 (MaxPooling2D  (None, 32, 48, 32)  0           ['leaky_re_lu_23[0][0]']         \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " batch_normalization_11 (BatchN  (None, 32, 48, 32)  128         ['max_pooling2d_11[0][0]']       \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_27 (Conv2D)             (None, 32, 48, 64)   18496       ['batch_normalization_11[0][0]'] \n",
            "                                                                                                  \n",
            " leaky_re_lu_24 (LeakyReLU)     (None, 32, 48, 64)   0           ['conv2d_27[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_28 (Conv2D)             (None, 32, 48, 64)   36928       ['leaky_re_lu_24[0][0]']         \n",
            "                                                                                                  \n",
            " leaky_re_lu_25 (LeakyReLU)     (None, 32, 48, 64)   0           ['conv2d_28[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_12 (MaxPooling2D  (None, 16, 24, 64)  0           ['leaky_re_lu_25[0][0]']         \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " batch_normalization_12 (BatchN  (None, 16, 24, 64)  256         ['max_pooling2d_12[0][0]']       \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_29 (Conv2D)             (None, 16, 24, 128)  73856       ['batch_normalization_12[0][0]'] \n",
            "                                                                                                  \n",
            " leaky_re_lu_26 (LeakyReLU)     (None, 16, 24, 128)  0           ['conv2d_29[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_30 (Conv2D)             (None, 16, 24, 128)  147584      ['leaky_re_lu_26[0][0]']         \n",
            "                                                                                                  \n",
            " leaky_re_lu_27 (LeakyReLU)     (None, 16, 24, 128)  0           ['conv2d_30[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_13 (MaxPooling2D  (None, 8, 12, 128)  0           ['leaky_re_lu_27[0][0]']         \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " batch_normalization_13 (BatchN  (None, 8, 12, 128)  512         ['max_pooling2d_13[0][0]']       \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_31 (Conv2D)             (None, 8, 12, 256)   295168      ['batch_normalization_13[0][0]'] \n",
            "                                                                                                  \n",
            " leaky_re_lu_28 (LeakyReLU)     (None, 8, 12, 256)   0           ['conv2d_31[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_32 (Conv2D)             (None, 8, 12, 256)   590080      ['leaky_re_lu_28[0][0]']         \n",
            "                                                                                                  \n",
            " leaky_re_lu_29 (LeakyReLU)     (None, 8, 12, 256)   0           ['conv2d_32[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_14 (MaxPooling2D  (None, 4, 6, 256)   0           ['leaky_re_lu_29[0][0]']         \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " batch_normalization_14 (BatchN  (None, 4, 6, 256)   1024        ['max_pooling2d_14[0][0]']       \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_33 (Conv2D)             (None, 4, 6, 256)    590080      ['batch_normalization_14[0][0]'] \n",
            "                                                                                                  \n",
            " leaky_re_lu_30 (LeakyReLU)     (None, 4, 6, 256)    0           ['conv2d_33[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_34 (Conv2D)             (None, 4, 6, 256)    590080      ['leaky_re_lu_30[0][0]']         \n",
            "                                                                                                  \n",
            " leaky_re_lu_31 (LeakyReLU)     (None, 4, 6, 256)    0           ['conv2d_34[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_15 (MaxPooling2D  (None, 2, 3, 256)   0           ['leaky_re_lu_31[0][0]']         \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " batch_normalization_15 (BatchN  (None, 2, 3, 256)   1024        ['max_pooling2d_15[0][0]']       \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_transpose_3 (Conv2DTran  (None, 6, 8, 11)    45056       ['batch_normalization_15[0][0]'] \n",
            " spose)                                                                                           \n",
            "                                                                                                  \n",
            " cropping2d_3 (Cropping2D)      (None, 4, 6, 11)     0           ['conv2d_transpose_3[0][0]']     \n",
            "                                                                                                  \n",
            " conv2d_36 (Conv2D)             (None, 4, 6, 11)     2827        ['batch_normalization_14[0][0]'] \n",
            "                                                                                                  \n",
            " add_2 (Add)                    (None, 4, 6, 11)     0           ['cropping2d_3[0][0]',           \n",
            "                                                                  'conv2d_36[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_transpose_4 (Conv2DTran  (None, 10, 14, 11)  1936        ['add_2[0][0]']                  \n",
            " spose)                                                                                           \n",
            "                                                                                                  \n",
            " cropping2d_4 (Cropping2D)      (None, 8, 12, 11)    0           ['conv2d_transpose_4[0][0]']     \n",
            "                                                                                                  \n",
            " conv2d_37 (Conv2D)             (None, 8, 12, 11)    1419        ['batch_normalization_13[0][0]'] \n",
            "                                                                                                  \n",
            " add_3 (Add)                    (None, 8, 12, 11)    0           ['cropping2d_4[0][0]',           \n",
            "                                                                  'conv2d_37[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_transpose_5 (Conv2DTran  (None, 64, 96, 11)  7744        ['add_3[0][0]']                  \n",
            " spose)                                                                                           \n",
            "                                                                                                  \n",
            " cropping2d_5 (Cropping2D)      (None, 64, 84, 11)   0           ['conv2d_transpose_5[0][0]']     \n",
            "                                                                                                  \n",
            " activation_1 (Activation)      (None, 64, 84, 11)   0           ['cropping2d_5[0][0]']           \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 2,413,766\n",
            "Trainable params: 2,412,294\n",
            "Non-trainable params: 1,472\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wAAXygZtbZmu"
      },
      "source": [
        "## Compile the Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sC-9m1R_5tjV"
      },
      "source": [
        "<a name='exercise-4'></a>\n",
        "\n",
        "### **Exercise 4**\n",
        "\n",
        "Compile the model using an appropriate loss, optimizer, and metric.\n",
        "\n",
        "_**Note:** There is a current issue with the grader accepting certain loss functions. We will be upgrading it but while in progress, please use this syntax:_\n",
        "\n",
        "```\n",
        "loss='<loss string name>'\n",
        "```\n",
        "\n",
        "*instead of:*\n",
        "\n",
        "```\n",
        "loss=tf.keras.losses.<StringCassName>\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZpWpp8h4g_rE"
      },
      "source": [
        "### START CODE HERE ###\n",
        "model.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), metrics=['accuracy'])\n",
        "### END CODE HERE ###"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "510v0aVDXv1f"
      },
      "source": [
        "## Model Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1udK8qps6PcG"
      },
      "source": [
        "<a name='exercise-5'></a>\n",
        "\n",
        "### **Exercise 5**\n",
        "\n",
        "You can now train the model. Set the number of epochs and observe the metrics returned at each iteration. You can also terminate the cell execution if you think your model is performing well already."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8HoZwpGWhMB-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49b5aa8b-e0f9-4c18-dc68-827787404f8c"
      },
      "source": [
        "# OTHER THAN SETTING THE EPOCHS NUMBER, DO NOT CHANGE ANY OTHER CODE\n",
        "\n",
        "### START CODE HERE ###\n",
        "EPOCHS = 50\n",
        "### END CODE HERE ###\n",
        "\n",
        "steps_per_epoch = 4000//BATCH_SIZE\n",
        "validation_steps = 800//BATCH_SIZE\n",
        "test_steps = 200//BATCH_SIZE\n",
        "\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"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "125/125 [==============================] - 14s 38ms/step - loss: 0.1267 - accuracy: 0.8614 - val_loss: 0.0667 - val_accuracy: 0.9431\n",
            "Epoch 2/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0339 - accuracy: 0.9424 - val_loss: 0.0541 - val_accuracy: 0.9431\n",
            "Epoch 3/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0304 - accuracy: 0.9424 - val_loss: 0.0433 - val_accuracy: 0.9430\n",
            "Epoch 4/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0271 - accuracy: 0.9427 - val_loss: 0.0327 - val_accuracy: 0.9432\n",
            "Epoch 5/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0253 - accuracy: 0.9435 - val_loss: 0.0257 - val_accuracy: 0.9441\n",
            "Epoch 6/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0239 - accuracy: 0.9450 - val_loss: 0.0230 - val_accuracy: 0.9468\n",
            "Epoch 7/50\n",
            "125/125 [==============================] - 5s 38ms/step - loss: 0.0219 - accuracy: 0.9484 - val_loss: 0.0216 - val_accuracy: 0.9497\n",
            "Epoch 8/50\n",
            "125/125 [==============================] - 5s 38ms/step - loss: 0.0198 - accuracy: 0.9538 - val_loss: 0.0192 - val_accuracy: 0.9566\n",
            "Epoch 9/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0174 - accuracy: 0.9611 - val_loss: 0.0172 - val_accuracy: 0.9652\n",
            "Epoch 10/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0148 - accuracy: 0.9684 - val_loss: 0.0139 - val_accuracy: 0.9709\n",
            "Epoch 11/50\n",
            "125/125 [==============================] - 4s 36ms/step - loss: 0.0126 - accuracy: 0.9740 - val_loss: 0.0132 - val_accuracy: 0.9736\n",
            "Epoch 12/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0109 - accuracy: 0.9783 - val_loss: 0.0106 - val_accuracy: 0.9796\n",
            "Epoch 13/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0098 - accuracy: 0.9808 - val_loss: 0.0098 - val_accuracy: 0.9810\n",
            "Epoch 14/50\n",
            "125/125 [==============================] - 4s 36ms/step - loss: 0.0088 - accuracy: 0.9831 - val_loss: 0.0090 - val_accuracy: 0.9826\n",
            "Epoch 15/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0081 - accuracy: 0.9846 - val_loss: 0.0088 - val_accuracy: 0.9835\n",
            "Epoch 16/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0074 - accuracy: 0.9860 - val_loss: 0.0077 - val_accuracy: 0.9853\n",
            "Epoch 17/50\n",
            "125/125 [==============================] - 4s 36ms/step - loss: 0.0070 - accuracy: 0.9867 - val_loss: 0.0078 - val_accuracy: 0.9853\n",
            "Epoch 18/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0067 - accuracy: 0.9872 - val_loss: 0.0074 - val_accuracy: 0.9858\n",
            "Epoch 19/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0063 - accuracy: 0.9880 - val_loss: 0.0085 - val_accuracy: 0.9843\n",
            "Epoch 20/50\n",
            "125/125 [==============================] - 5s 36ms/step - loss: 0.0060 - accuracy: 0.9884 - val_loss: 0.0075 - val_accuracy: 0.9857\n",
            "Epoch 21/50\n",
            "125/125 [==============================] - 4s 36ms/step - loss: 0.0060 - accuracy: 0.9883 - val_loss: 0.0068 - val_accuracy: 0.9872\n",
            "Epoch 22/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0054 - accuracy: 0.9896 - val_loss: 0.0062 - val_accuracy: 0.9880\n",
            "Epoch 23/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0051 - accuracy: 0.9899 - val_loss: 0.0068 - val_accuracy: 0.9872\n",
            "Epoch 24/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0050 - accuracy: 0.9900 - val_loss: 0.0061 - val_accuracy: 0.9883\n",
            "Epoch 25/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0049 - accuracy: 0.9903 - val_loss: 0.0061 - val_accuracy: 0.9885\n",
            "Epoch 26/50\n",
            "125/125 [==============================] - 4s 34ms/step - loss: 0.0049 - accuracy: 0.9903 - val_loss: 0.0063 - val_accuracy: 0.9881\n",
            "Epoch 27/50\n",
            "125/125 [==============================] - 4s 34ms/step - loss: 0.0051 - accuracy: 0.9898 - val_loss: 0.0127 - val_accuracy: 0.9800\n",
            "Epoch 28/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0054 - accuracy: 0.9894 - val_loss: 0.0071 - val_accuracy: 0.9866\n",
            "Epoch 29/50\n",
            "125/125 [==============================] - 4s 34ms/step - loss: 0.0045 - accuracy: 0.9909 - val_loss: 0.0054 - val_accuracy: 0.9891\n",
            "Epoch 30/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0044 - accuracy: 0.9912 - val_loss: 0.0054 - val_accuracy: 0.9894\n",
            "Epoch 31/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0042 - accuracy: 0.9915 - val_loss: 0.0057 - val_accuracy: 0.9890\n",
            "Epoch 32/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0041 - accuracy: 0.9916 - val_loss: 0.0054 - val_accuracy: 0.9893\n",
            "Epoch 33/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0041 - accuracy: 0.9916 - val_loss: 0.0055 - val_accuracy: 0.9891\n",
            "Epoch 34/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0041 - accuracy: 0.9917 - val_loss: 0.0058 - val_accuracy: 0.9890\n",
            "Epoch 35/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0040 - accuracy: 0.9918 - val_loss: 0.0053 - val_accuracy: 0.9897\n",
            "Epoch 36/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0041 - accuracy: 0.9916 - val_loss: 0.0072 - val_accuracy: 0.9875\n",
            "Epoch 37/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0047 - accuracy: 0.9907 - val_loss: 0.0054 - val_accuracy: 0.9897\n",
            "Epoch 38/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0043 - accuracy: 0.9912 - val_loss: 0.0059 - val_accuracy: 0.9890\n",
            "Epoch 39/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0039 - accuracy: 0.9921 - val_loss: 0.0051 - val_accuracy: 0.9898\n",
            "Epoch 40/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0038 - accuracy: 0.9922 - val_loss: 0.0058 - val_accuracy: 0.9889\n",
            "Epoch 41/50\n",
            "125/125 [==============================] - 4s 34ms/step - loss: 0.0037 - accuracy: 0.9924 - val_loss: 0.0051 - val_accuracy: 0.9902\n",
            "Epoch 42/50\n",
            "125/125 [==============================] - 5s 38ms/step - loss: 0.0036 - accuracy: 0.9925 - val_loss: 0.0052 - val_accuracy: 0.9897\n",
            "Epoch 43/50\n",
            "125/125 [==============================] - 5s 39ms/step - loss: 0.0036 - accuracy: 0.9925 - val_loss: 0.0055 - val_accuracy: 0.9894\n",
            "Epoch 44/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0036 - accuracy: 0.9926 - val_loss: 0.0050 - val_accuracy: 0.9903\n",
            "Epoch 45/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0036 - accuracy: 0.9925 - val_loss: 0.0053 - val_accuracy: 0.9898\n",
            "Epoch 46/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0036 - accuracy: 0.9926 - val_loss: 0.0053 - val_accuracy: 0.9899\n",
            "Epoch 47/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0035 - accuracy: 0.9927 - val_loss: 0.0050 - val_accuracy: 0.9904\n",
            "Epoch 48/50\n",
            "125/125 [==============================] - 5s 38ms/step - loss: 0.0034 - accuracy: 0.9929 - val_loss: 0.0056 - val_accuracy: 0.9898\n",
            "Epoch 49/50\n",
            "125/125 [==============================] - 4s 35ms/step - loss: 0.0034 - accuracy: 0.9929 - val_loss: 0.0061 - val_accuracy: 0.9885\n",
            "Epoch 50/50\n",
            "125/125 [==============================] - 4s 34ms/step - loss: 0.0034 - accuracy: 0.9929 - val_loss: 0.0050 - val_accuracy: 0.9905\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BLNzLB3peeNG"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "The losses should generally be decreasing and the accuracies should generally be increasing. For example, observing the first 4 epochs should output something similar:\n",
        "\n",
        "```txt\n",
        "Epoch 1/70\n",
        "125/125 [==============================] - 6s 50ms/step - loss: 0.5542 - accuracy: 0.8635 - val_loss: 0.5335 - val_accuracy: 0.9427\n",
        "Epoch 2/70\n",
        "125/125 [==============================] - 6s 47ms/step - loss: 0.2315 - accuracy: 0.9425 - val_loss: 0.3362 - val_accuracy: 0.9427\n",
        "Epoch 3/70\n",
        "125/125 [==============================] - 6s 47ms/step - loss: 0.2118 - accuracy: 0.9426 - val_loss: 0.2592 - val_accuracy: 0.9427\n",
        "Epoch 4/70\n",
        "125/125 [==============================] - 6s 47ms/step - loss: 0.1782 - accuracy: 0.9431 - val_loss: 0.1770 - val_accuracy: 0.9432\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eih-Q7GoXzJe"
      },
      "source": [
        "## Model Evaluation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2bTkaFM2X1gr"
      },
      "source": [
        "### Make Predictions\n",
        "\n",
        "Let's get the predictions using our test dataset as input and print the shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zENjQuK0luH5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4a2accc-1b5d-4708-8128-ec0558bdc34b"
      },
      "source": [
        "results = model.predict(test_dataset, steps=test_steps)\n",
        "\n",
        "print(results.shape)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(192, 64, 84, 11)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IReKPT_DZHjA"
      },
      "source": [
        "As you can see, the resulting shape is `(192, 64, 84, 11)`. This means that for each of the 192 images that we have in our test set, there are 11 predictions generated (i.e. one for each class: 0 to 1 plus background)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OBPBqnHyaSaG"
      },
      "source": [
        "Thus, if you want to see the *probability* of the upper leftmost pixel of the 1st image belonging to class 0, then you can print something like `results[0,0,0,0]`. If you want the probability of the same pixel at class 10, then do `results[0,0,0,10]`.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jwFiR9WAf0Av",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5529662d-bcf5-4d9f-d6ed-23b86eb9d754"
      },
      "source": [
        "print(results[0,0,0,0])\n",
        "print(results[0,0,0,10])"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.3411337e-08\n",
            "0.9989411\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wKDsqzKEf28V"
      },
      "source": [
        "What we're interested in is to get the *index* of the highest probability of each of these 11 slices and combine them in a single image. We can do that by getting the [argmax](https://numpy.org/doc/stable/reference/generated/numpy.argmax.html) at this axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0_Uj_uuV9TQt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b26f0ed-110d-4d2e-bcff-0bdbbdf681e5"
      },
      "source": [
        "results = np.argmax(results, axis=3)\n",
        "\n",
        "print(results.shape)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(192, 64, 84)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ClaGbOLhdKD2"
      },
      "source": [
        "The new array generated per image now only specifies the indices of the class with the highest probability. Let's see the output class of the upper most left pixel. As you might have observed earlier when you inspected the dataset, the upper left corner is usually just part of the background (class 10). The actual digits are written somewhere in the middle parts of the image."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBeBwvHQd2pZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d347cf98-a392-4e7a-9f25-be016a67a2e9"
      },
      "source": [
        "print(results[0,0,0])\n",
        "\n",
        "# prediction map for image 0\n",
        "print(results[0,:,:])"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "[[10 10 10 ... 10 10 10]\n",
            " [10 10 10 ... 10 10 10]\n",
            " [10 10 10 ... 10 10 10]\n",
            " ...\n",
            " [10 10 10 ... 10 10 10]\n",
            " [10 10 10 ... 10 10 10]\n",
            " [10 10 10 ... 10 10 10]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V3FxyNgrg7IE"
      },
      "source": [
        "We will use this `results` array when we evaluate our predictions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hpKDUuAWX5Pj"
      },
      "source": [
        "### Metrics\n",
        "\n",
        "We showed in the lectures two ways to evaluate your predictions. The *intersection over union (IOU)* and the *dice score*. Recall that:\n",
        "\n",
        "$$IOU = \\frac{area\\_of\\_overlap}{area\\_of\\_union}$$\n",
        "<br>\n",
        "$$Dice Score = 2 * \\frac{area\\_of\\_overlap}{combined\\_area}$$\n",
        "\n",
        "The code below does that for you as you've also seen in the ungraded lab. A small smoothing factor is introduced in the denominators to prevent possible division by zero."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gKTpLmly_RXb"
      },
      "source": [
        "def class_wise_metrics(y_true, y_pred):\n",
        "  '''\n",
        "  Computes the class-wise IOU and Dice Score.\n",
        "\n",
        "  Args:\n",
        "    y_true (tensor) - ground truth label maps\n",
        "    y_pred (tensor) - predicted label maps\n",
        "  '''\n",
        "  class_wise_iou = []\n",
        "  class_wise_dice_score = []\n",
        "\n",
        "  smoothing_factor = 0.00001\n",
        "\n",
        "  for i in range(n_classes):\n",
        "    intersection = np.sum((y_pred == i) * (y_true == i))\n",
        "    y_true_area = np.sum((y_true == i))\n",
        "    y_pred_area = np.sum((y_pred == i))\n",
        "    combined_area = y_true_area + y_pred_area\n",
        "    \n",
        "    iou = (intersection) / (combined_area - intersection + smoothing_factor)\n",
        "    class_wise_iou.append(iou)\n",
        "    \n",
        "    dice_score =  2 * ((intersection) / (combined_area + smoothing_factor))\n",
        "    class_wise_dice_score.append(dice_score)\n",
        "\n",
        "  return class_wise_iou, class_wise_dice_score\n"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FfWPwM4ZhHjE"
      },
      "source": [
        "### Visualize Predictions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hkbsk_P1fpRM",
        "lines_to_next_cell": 2,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 244
        },
        "outputId": "5c7e4abc-bb73-4eb6-cdbb-aa278b4759d9"
      },
      "source": [
        "# place a number here between 0 to 191 to pick an image from the test set\n",
        "integer_slider = 105\n",
        "\n",
        "ds = test_dataset.unbatch()\n",
        "ds = ds.batch(200)\n",
        "images = []\n",
        "\n",
        "y_true_segments = []\n",
        "for image, annotation in ds.take(2):\n",
        "  y_true_segments = annotation\n",
        "  images = image\n",
        "  \n",
        "  \n",
        "iou, dice_score = class_wise_metrics(np.argmax(y_true_segments[integer_slider], axis=2), results[integer_slider])  \n",
        "show_annotation_and_prediction(image[integer_slider], annotation[integer_slider], results[integer_slider], iou, dice_score)\n"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x288 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiG9K4t6X9iZ"
      },
      "source": [
        "### Compute IOU Score and Dice Score of your model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2706boF0CNNS",
        "lines_to_next_cell": 2,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d88321fa-0c5c-450a-95d5-4f16cf64da7a"
      },
      "source": [
        "cls_wise_iou, cls_wise_dice_score = class_wise_metrics(np.argmax(y_true_segments, axis=3), results)\n",
        "\n",
        "average_iou = 0.0\n",
        "for idx, (iou, dice_score) in enumerate(zip(cls_wise_iou[:-1], cls_wise_dice_score[:-1])):\n",
        "  print(\"Digit {}: IOU: {} Dice Score: {}\".format(idx, iou, dice_score)) \n",
        "  average_iou += iou\n",
        "\n",
        "grade = average_iou * 10\n",
        "\n",
        "print(\"\\nGrade is \" + str(grade))\n",
        "\n",
        "PASSING_GRADE = 60\n",
        "if (grade>PASSING_GRADE):\n",
        "  print(\"You passed!\")\n",
        "else:\n",
        "  print(\"You failed. Please check your model and re-train\")"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digit 0: IOU: 0.8776254107314262 Dice Score: 0.9348248119304569\n",
            "Digit 1: IOU: 0.8786855009868381 Dice Score: 0.9354258608216024\n",
            "Digit 2: IOU: 0.8468380640345583 Dice Score: 0.917068020771216\n",
            "Digit 3: IOU: 0.839925603422287 Dice Score: 0.9129995276548288\n",
            "Digit 4: IOU: 0.7813241302969073 Dice Score: 0.8772397083810658\n",
            "Digit 5: IOU: 0.7959672327713079 Dice Score: 0.886393936645573\n",
            "Digit 6: IOU: 0.8389375083080953 Dice Score: 0.9124154622088875\n",
            "Digit 7: IOU: 0.8882363087092136 Dice Score: 0.9408105379738263\n",
            "Digit 8: IOU: 0.7991590120624554 Dice Score: 0.8883695178741807\n",
            "Digit 9: IOU: 0.8102985297578605 Dice Score: 0.8952098412920253\n",
            "\n",
            "Grade is 83.5699730108095\n",
            "You passed!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vvw0HLY2kV3w"
      },
      "source": [
        "## Save the Model\n",
        "\n",
        "Once you're satisfied with the results, you will need to save your model so you can upload it to the grader in the Coursera classroom. After running the cell below, please look for `student_model.h5` in the File Explorer on the left and download it. Then go back to the Coursera classroom and upload it to the Lab item that points to the autograder of Week 3."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ULCfGHEKkaO0"
      },
      "source": [
        "model.save(\"model.h5\")"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QbVfJ2aLONqw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "babe57b5-3dad-4b4f-8793-62cfa6b9d48e"
      },
      "source": [
        "# You can also use this cell as a shortcut for downloading your model\n",
        "from google.colab import files\n",
        "files.download(\"model.h5\")"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_f0f5bc9d-e444-44e3-9d3b-73e00793dad2\", \"model.h5\", 29162416)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dmyvoAynkgVw"
      },
      "source": [
        "**Congratulations on completing this assignment on image segmentation!**"
      ]
    }
  ]
}