image-semantic-segmentation-with-u-net (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"1\" name='1'></a>\n",
    "## **1. Import Required Packages**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-02T12:52:33.979463Z",
     "iopub.status.busy": "2022-07-02T12:52:33.979076Z",
     "iopub.status.idle": "2022-07-02T12:52:40.511815Z",
     "shell.execute_reply": "2022-07-02T12:52:40.511079Z",
     "shell.execute_reply.started": "2022-07-02T12:52:33.979382Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import imageio\n",
    "import random\n",
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' \n",
    "\n",
    "import tensorflow as tf \n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
    "from tensorflow.keras.layers import Activation, Input, Conv2D, MaxPooling2D, BatchNormalization, Conv2DTranspose, concatenate\n",
    "from tensorflow.keras.models import Model, load_model\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.models import Model, load_model\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"2\" name=\"2\"></a>\n",
    "## **2. Data Preparation**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"2-1\" name=\"2-1\"></a>\n",
    "### **2.1. Load the images and masks from their directories**\n",
    "\n",
    "In this data preparation step, we will:\n",
    "1. Create 2 lists containing the paths of images and masks\n",
    "2. Split the lists into training, validation and test sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A. Create a list that contains all the paths to all directories in the main directory (a list that contains the path to dataA, dataB, dataC, dataD, and dataE)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-02T12:52:45.582271Z",
     "iopub.status.busy": "2022-07-02T12:52:45.581792Z",
     "iopub.status.idle": "2022-07-02T12:52:45.587808Z",
     "shell.execute_reply": "2022-07-02T12:52:45.586764Z",
     "shell.execute_reply.started": "2022-07-02T12:52:45.582236Z"
    }
   },
   "outputs": [],
   "source": [
    "image_path = [\"../input/lyft-udacity-challenge/\"+\"data\"+i+\"/\"+\"data\"+i+\"/CameraRGB/\" for i in ['A', 'B', 'C', 'D', 'E']]\n",
    "mask_path = [\"../input/lyft-udacity-challenge/\"+\"data\"+i+\"/\"+\"data\"+i+\"/CameraSeg/\" for i in ['A', 'B', 'C', 'D', 'E']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create a function to iterate over all the direcory paths where our data are located (list in 2.1.1.) and return the list of the image paths in those directories**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-02T12:52:48.192573Z",
     "iopub.status.busy": "2022-07-02T12:52:48.192319Z",
     "iopub.status.idle": "2022-07-02T12:52:48.198691Z",
     "shell.execute_reply": "2022-07-02T12:52:48.197667Z",
     "shell.execute_reply.started": "2022-07-02T12:52:48.192546Z"
    }
   },
   "outputs": [],
   "source": [
    "def list_image_paths(directory_paths):\n",
    "    image_paths = []\n",
    "    for directory in range(len(directory_paths)):\n",
    "        image_filenames = os.listdir(directory_paths[directory])\n",
    "        for image_filename in image_filenames:\n",
    "            image_paths.append(directory_paths[directory] + image_filename)\n",
    "    return image_paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create lists of image and mask paths by initializing the function above**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:21.120171Z",
     "iopub.status.busy": "2021-10-20T19:59:21.119402Z",
     "iopub.status.idle": "2021-10-20T19:59:21.14813Z",
     "shell.execute_reply": "2021-10-20T19:59:21.147482Z",
     "shell.execute_reply.started": "2021-10-20T19:59:21.120077Z"
    }
   },
   "outputs": [],
   "source": [
    "image_paths = list_image_paths(image_path) \n",
    "mask_paths = list_image_paths(mask_path)\n",
    "number_of_images, number_of_masks = len(image_paths), len(mask_paths)\n",
    "print(f\"1. There are {number_of_images} images and {number_of_masks} masks in our dataset\")\n",
    "print(f\"2. An example of an image path is: \\n {image_paths[0]}\")\n",
    "print(f\"3. An example of a mask path is: \\n {mask_paths[0]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Preview random masked and unmasked images by reading them from their paths**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:21.152088Z",
     "iopub.status.busy": "2021-10-20T19:59:21.150589Z",
     "iopub.status.idle": "2021-10-20T19:59:29.423516Z",
     "shell.execute_reply": "2021-10-20T19:59:29.422834Z",
     "shell.execute_reply.started": "2021-10-20T19:59:21.15205Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "number_of_samples = len(image_paths)\n",
    "\n",
    "for i in range(3):\n",
    "    N = random.randint(0, number_of_samples - 1)\n",
    "\n",
    "    img = imageio.imread(image_paths[N])\n",
    "    mask = imageio.imread(mask_paths[N])\n",
    "    mask = np.array([max(mask[i, j]) for i in range(mask.shape[0]) for j in range(mask.shape[1])]).reshape(img.shape[0], img.shape[1])\n",
    "\n",
    "    fig, arr = plt.subplots(1, 3, figsize=(20, 8))\n",
    "    arr[0].imshow(img)\n",
    "    arr[0].set_title('Image')\n",
    "    arr[0].axis(\"off\")\n",
    "    arr[1].imshow(mask)\n",
    "    arr[1].set_title('Segmentation')\n",
    "    arr[1].axis(\"off\")    \n",
    "    arr[2].imshow(mask, cmap='Paired')\n",
    "    arr[2].set_title('Image Overlay')\n",
    "    arr[2].axis(\"off\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **2.1.2. Split the image and mask paths into training, validation, and test sets**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:29.425277Z",
     "iopub.status.busy": "2021-10-20T19:59:29.424834Z",
     "iopub.status.idle": "2021-10-20T19:59:29.438803Z",
     "shell.execute_reply": "2021-10-20T19:59:29.438033Z",
     "shell.execute_reply.started": "2021-10-20T19:59:29.425238Z"
    }
   },
   "outputs": [],
   "source": [
    "# First split the image paths into training and validation sets\n",
    "train_image_paths, val_image_paths, train_mask_paths, val_mask_paths = train_test_split(image_paths, mask_paths, train_size=0.8, random_state=0)\n",
    "\n",
    "# Keep part of the validation set as test set\n",
    "validation_image_paths, test_image_paths, validation_mask_paths, test_mask_paths = train_test_split(val_image_paths, val_mask_paths, train_size = 0.80, random_state=0)\n",
    "\n",
    "print(f'There are {len(train_image_paths)} images in the Training Set')\n",
    "print(f'There are {len(validation_image_paths)} images in the Validation Set')\n",
    "print(f'There are {len(test_image_paths)} images in the Test Set')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"2-2\" name=\"2-2\"></a>\n",
    "### **2.2. - Create a data pipeline to read and preprocess our data**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **2.2.1. Create a function to read image and mask paths and return equivalent arrays**\n",
    "\n",
    "The **read_image** function will\n",
    "1. Read an image and its mask from their paths\n",
    "2. Convert the digital image and its mask to image arrays \n",
    "3. Normalize the datasets\n",
    "4. Resize the image and its masks to a desired dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:29.440525Z",
     "iopub.status.busy": "2021-10-20T19:59:29.440242Z",
     "iopub.status.idle": "2021-10-20T19:59:29.450102Z",
     "shell.execute_reply": "2021-10-20T19:59:29.449337Z",
     "shell.execute_reply.started": "2021-10-20T19:59:29.440472Z"
    }
   },
   "outputs": [],
   "source": [
    "def read_image(image_path, mask_path):\n",
    "    \n",
    "    image = tf.io.read_file(image_path)\n",
    "    image = tf.image.decode_png(image, channels=3)\n",
    "    image = tf.image.convert_image_dtype(image, tf.float32)\n",
    "    image = tf.image.resize(image, (256, 256), method='nearest')\n",
    "\n",
    "    mask = tf.io.read_file(mask_path)\n",
    "    mask = tf.image.decode_png(mask, channels=3)\n",
    "    mask = tf.math.reduce_max(mask, axis=-1, keepdims=True)\n",
    "    mask = tf.image.resize(mask, (256, 256), method='nearest')\n",
    "    \n",
    "    return image, mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **2.2.2. Create a data generator function to read and load images and masks in batches**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:29.452006Z",
     "iopub.status.busy": "2021-10-20T19:59:29.451294Z",
     "iopub.status.idle": "2021-10-20T19:59:29.459206Z",
     "shell.execute_reply": "2021-10-20T19:59:29.458357Z",
     "shell.execute_reply.started": "2021-10-20T19:59:29.451949Z"
    }
   },
   "outputs": [],
   "source": [
    "def data_generator(image_paths, mask_paths, buffer_size, batch_size):\n",
    "    \n",
    "    image_list = tf.constant(image_paths) \n",
    "    mask_list = tf.constant(mask_paths)\n",
    "    dataset = tf.data.Dataset.from_tensor_slices((image_list, mask_list))\n",
    "    dataset = dataset.map(read_image, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "    dataset = dataset.cache().shuffle(buffer_size).batch(batch_size)\n",
    "    \n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **2.2.3. Create data pipelines for the training, validation and test sets using both functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:29.461252Z",
     "iopub.status.busy": "2021-10-20T19:59:29.460666Z",
     "iopub.status.idle": "2021-10-20T19:59:30.282201Z",
     "shell.execute_reply": "2021-10-20T19:59:30.281381Z",
     "shell.execute_reply.started": "2021-10-20T19:59:29.461214Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "buffer_size = 500\n",
    "\n",
    "train_dataset = data_generator(train_image_paths, train_mask_paths, buffer_size, batch_size)\n",
    "validation_dataset = data_generator(validation_image_paths, validation_mask_paths, buffer_size, batch_size)\n",
    "test_dataset = data_generator(test_image_paths, test_mask_paths, buffer_size, batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"3\" name=\"3\"></a>\n",
    "## **3. Model Architecture and Training**\n",
    "We will using a the **U-Net architecture** to train our semantic segmentation model. The U-Net model was named for its U-shape architecture, and it was originally created for biomedical image segmentation tasks in 2015. However, the model has become a very popular choice for other semantic segmentation tasks. \n",
    "\n",
    "U-Net builds on a previous architecture called the Fully Convolutional Network, or FCN, which replaces the dense layers found in a typical CNN with a transposed convolution layer that upsamples the feature map back to the size of the original input image, while preserving the spatial information. This is necessary because the dense layers destroy spatial information (the \"where\" of the image), which is an essential part of image segmentation tasks. An added bonus of using transpose convolutions is that the input size no longer needs to be fixed, as it does when dense layers are used. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"3-1\" name=\"3-1\"></a>\n",
    "\n",
    "### **3.1. U-Net Model Design**\n",
    "\n",
    "To design our model, we will carry out the following steps\n",
    "1. Define a function for an encoding block. The function will return the next layer output and the skip connection output for the corresponding block in the model\n",
    "2. Define a function for a decoding block. This function will merge the skip-connection input with the previous layer, process it, and return an output\n",
    "3. Develop a model using both the encoding and decoding blocks output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **3.1.1. Define a function for an encoding block (This function will return the next layer output and the skip connection output for the corresponding block in the model)** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:30.283578Z",
     "iopub.status.busy": "2021-10-20T19:59:30.28334Z",
     "iopub.status.idle": "2021-10-20T19:59:30.290358Z",
     "shell.execute_reply": "2021-10-20T19:59:30.289437Z",
     "shell.execute_reply.started": "2021-10-20T19:59:30.283549Z"
    }
   },
   "outputs": [],
   "source": [
    "def encoding_block(inputs, filters, dropout_probability=0, max_pooling=True):\n",
    "\n",
    "    \"\"\"\n",
    "    Convolutional encoding/downsampling block\n",
    "    \n",
    "    Arguments:\n",
    "        inputs -- Input tensor\n",
    "        filters -- Number of filters for the convolutional layers\n",
    "        max_pooling -- Use MaxPooling2D to reduce the spatial dimensions of the output volume\n",
    "    Returns: \n",
    "        next_layer, skip_connection --  Next layer and skip connection inputs \n",
    "    \"\"\"\n",
    "    \n",
    "    C = Conv2D(filters, 3, padding=\"same\", kernel_initializer=\"he_normal\")(inputs)\n",
    "    C = BatchNormalization()(C)\n",
    "    C = Activation(\"relu\")(C)\n",
    "\n",
    "    C = Conv2D(filters, 3, padding=\"same\", kernel_initializer=\"he_normal\")(C)\n",
    "    C = BatchNormalization()(C)\n",
    "    C = Activation(\"relu\")(C)\n",
    "\n",
    "    skip_connection = C  # Set aside residual\n",
    "    \n",
    "    # if max_pooling is True, add a MaxPooling2D with 2x2 pool_size\n",
    "    if max_pooling:\n",
    "        next_layer = MaxPooling2D(pool_size=(2, 2))(C)        \n",
    "    else:\n",
    "        next_layer = C\n",
    "            \n",
    "    return next_layer, skip_connection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **3.1.2. Define a function for a decoding block (This function will merge the skip-connection input with the previous layer, process it, and return an output)** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:30.29234Z",
     "iopub.status.busy": "2021-10-20T19:59:30.291593Z",
     "iopub.status.idle": "2021-10-20T19:59:30.301256Z",
     "shell.execute_reply": "2021-10-20T19:59:30.300511Z",
     "shell.execute_reply.started": "2021-10-20T19:59:30.292304Z"
    }
   },
   "outputs": [],
   "source": [
    "def decoding_block(inputs, skip_connection_input, filters):\n",
    "    \"\"\"\n",
    "    Convolutional decoding/upsampling block\n",
    "    \n",
    "    Arguments:\n",
    "        inputs -- Input tensor from previous layer\n",
    "        skip_connection_input -- Input tensor from previous skip layer\n",
    "        filters -- Number of filters for the convolutional layers\n",
    "    Returns: \n",
    "        C -- Tensor output\n",
    "    \"\"\"\n",
    "\n",
    "    CT = Conv2DTranspose(filters, 3, strides=(2,2), padding=\"same\", kernel_initializer=\"he_normal\")(inputs)\n",
    "    \n",
    "    residual_connection = concatenate([CT, skip_connection_input], axis=3)\n",
    "\n",
    "    C = Conv2D(filters, 3, padding=\"same\", kernel_initializer=\"he_normal\")(residual_connection)\n",
    "    C = BatchNormalization()(C)\n",
    "    C = Activation(\"relu\")(C)\n",
    "    \n",
    "    C = Conv2D(filters, 3, padding=\"same\", kernel_initializer=\"he_normal\")(C)\n",
    "    C = BatchNormalization()(C)\n",
    "    C = Activation(\"relu\")(C)\n",
    "    \n",
    "  \n",
    "    return C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **3.1.3. Develop a model using both the encoding and decoding blocks output** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:30.303409Z",
     "iopub.status.busy": "2021-10-20T19:59:30.302871Z",
     "iopub.status.idle": "2021-10-20T19:59:30.313511Z",
     "shell.execute_reply": "2021-10-20T19:59:30.312809Z",
     "shell.execute_reply.started": "2021-10-20T19:59:30.303374Z"
    }
   },
   "outputs": [],
   "source": [
    "def unet_model(input_size, filters, n_classes):\n",
    "    \"\"\"\n",
    "    Unet model\n",
    "    \n",
    "    Arguments:\n",
    "        input_size -- Input shape \n",
    "        filters -- Number of filters for the convolutional layers\n",
    "        n_classes -- Number of output classes\n",
    "    Returns: \n",
    "        model -- tf.keras.Model\n",
    "    \"\"\"\n",
    "    inputs = Input(input_size)\n",
    "        \n",
    "    # Contracting Path (encoding)\n",
    "    C1, S1 = encoding_block(inputs, filters, max_pooling=True)\n",
    "    C2, S2 = encoding_block(C1, filters * 2, max_pooling=True)\n",
    "    C3, S3 = encoding_block(C2, filters * 4, max_pooling=True)\n",
    "    C4, S4 = encoding_block(C3, filters * 8, max_pooling=True)\n",
    "    \n",
    "    C5, S5 = encoding_block(C4, filters * 16, max_pooling=False)\n",
    "    \n",
    "    # Expanding Path (decoding)\n",
    "    U6 = decoding_block(C5, S4, filters * 8)\n",
    "    U7 = decoding_block(U6, S3,  filters * 4)\n",
    "    U8 = decoding_block(U7, S2,  filters = filters * 2)\n",
    "    U9 = decoding_block(U8, S1,  filters = filters)\n",
    "\n",
    "    C10 = Conv2D(filters,\n",
    "                 3,\n",
    "                 activation='relu',\n",
    "                 padding='same',\n",
    "                 kernel_initializer='he_normal')(U9)\n",
    "\n",
    "    # Add a Conv2D layer with n_classes filter, kernel size of 1 and a 'same' padding\n",
    "    C11 = Conv2D(filters = n_classes, kernel_size = (1,1), activation='sigmoid', padding='same')(C10)\n",
    "    \n",
    "    model = Model(inputs=inputs, outputs=C11)\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:30.317792Z",
     "iopub.status.busy": "2021-10-20T19:59:30.317561Z",
     "iopub.status.idle": "2021-10-20T19:59:31.022704Z",
     "shell.execute_reply": "2021-10-20T19:59:31.022015Z",
     "shell.execute_reply.started": "2021-10-20T19:59:30.317769Z"
    }
   },
   "outputs": [],
   "source": [
    "img_height = 256\n",
    "img_width = 256\n",
    "num_channels = 3\n",
    "filters = 32\n",
    "n_classes = 13\n",
    "\n",
    "model = unet_model((img_height, img_width, num_channels), filters=32, n_classes=23)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"3-2\" name=\"3-2\"></a>\n",
    "### **3.2. Model Training**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:31.024194Z",
     "iopub.status.busy": "2021-10-20T19:59:31.023896Z",
     "iopub.status.idle": "2021-10-20T19:59:31.041129Z",
     "shell.execute_reply": "2021-10-20T19:59:31.040285Z",
     "shell.execute_reply.started": "2021-10-20T19:59:31.024153Z"
    }
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])\n",
    "callback = EarlyStopping(monitor='val_accuracy', patience=20, restore_best_weights=True)\n",
    "reduce_lr = ReduceLROnPlateau(monitor='val_accuracy',factor=1e-1, patience=5, verbose=1, min_lr = 2e-6)\n",
    "batch_size = 32\n",
    "epochs = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T19:59:31.04302Z",
     "iopub.status.busy": "2021-10-20T19:59:31.042526Z",
     "iopub.status.idle": "2021-10-20T20:27:21.093124Z",
     "shell.execute_reply": "2021-10-20T20:27:21.092368Z",
     "shell.execute_reply.started": "2021-10-20T19:59:31.042984Z"
    }
   },
   "outputs": [],
   "source": [
    "history = model.fit(train_dataset, \n",
    "                    validation_data = validation_dataset, \n",
    "                    epochs = epochs, \n",
    "                    verbose=1, \n",
    "                    callbacks = [callback, reduce_lr], \n",
    "                    batch_size = batch_size, \n",
    "                    shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:21.095097Z",
     "iopub.status.busy": "2021-10-20T20:27:21.094733Z",
     "iopub.status.idle": "2021-10-20T20:27:21.42544Z",
     "shell.execute_reply": "2021-10-20T20:27:21.42479Z",
     "shell.execute_reply.started": "2021-10-20T20:27:21.095058Z"
    }
   },
   "outputs": [],
   "source": [
    "acc = [0.] + history.history['accuracy']\n",
    "val_acc = [0.] + history.history['val_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(acc, label='Training Accuracy')\n",
    "plt.plot(val_acc, label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim([min(plt.ylim()),1])\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(loss, label='Training Loss')\n",
    "plt.plot(val_loss, label='Validation Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.ylabel('Cross Entropy')\n",
    "plt.ylim([0,1.0])\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:21.427031Z",
     "iopub.status.busy": "2021-10-20T20:27:21.426762Z",
     "iopub.status.idle": "2021-10-20T20:27:21.776788Z",
     "shell.execute_reply": "2021-10-20T20:27:21.775893Z",
     "shell.execute_reply.started": "2021-10-20T20:27:21.426997Z"
    }
   },
   "outputs": [],
   "source": [
    "model.save('carla-image-segmentation-model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"3-3\" name=\"3-3\"></a>\n",
    "### **3.3. Compute Model Accuracy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:21.77837Z",
     "iopub.status.busy": "2021-10-20T20:27:21.778109Z",
     "iopub.status.idle": "2021-10-20T20:27:49.349664Z",
     "shell.execute_reply": "2021-10-20T20:27:49.348984Z",
     "shell.execute_reply.started": "2021-10-20T20:27:21.778338Z"
    }
   },
   "outputs": [],
   "source": [
    "train_loss, train_accuracy = model.evaluate(train_dataset, batch_size = 32)\n",
    "validation_loss, validation_accuracy = model.evaluate(validation_dataset, batch_size = 32)\n",
    "test_loss, test_accuracy = model.evaluate(test_dataset, batch_size = 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:49.351344Z",
     "iopub.status.busy": "2021-10-20T20:27:49.35109Z",
     "iopub.status.idle": "2021-10-20T20:27:49.357145Z",
     "shell.execute_reply": "2021-10-20T20:27:49.356313Z",
     "shell.execute_reply.started": "2021-10-20T20:27:49.35131Z"
    }
   },
   "outputs": [],
   "source": [
    "print(f'Model Accuracy on the Training Dataset: {round(train_accuracy * 100, 2)}%')\n",
    "print(f'Model Accuracy on the Validation Dataset: {round(validation_accuracy * 100, 2)}%')\n",
    "print(f'Model Accuracy on the Test Dataset: {round(test_accuracy * 100, 2)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"4\" name=\"4\"></a>\n",
    "## **4. Model Evaluation**\n",
    "\n",
    "Model Evaluation is an integral part of the model development process. It helps to find the best model that represents our data and how well the chosen model will work in the future. For classification tasks, precision and recall are the popular choice metrics used in addition with model accuracy to evaluate model performance since model accuracy is not always sufficient to judge if a model is optimal or not (especially if our dataset is skewed). The same rule applies to most dense prediction tasks like image segmentation where the goal is to simplify and/or change the representation of an image into classes that is more meaningful and easier to analyze.\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"4-1\" name=\"4-1\"></a>\n",
    "### **4.1. Create Segmentations/Masks of Images in our Dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:49.35908Z",
     "iopub.status.busy": "2021-10-20T20:27:49.358544Z",
     "iopub.status.idle": "2021-10-20T20:27:49.368064Z",
     "shell.execute_reply": "2021-10-20T20:27:49.367336Z",
     "shell.execute_reply.started": "2021-10-20T20:27:49.359044Z"
    }
   },
   "outputs": [],
   "source": [
    "def create_mask(dataset, model):\n",
    "    true_masks, predicted_masks = [], []\n",
    "    for images, masks in dataset:\n",
    "        pred_masks = model.predict(images)\n",
    "        pred_masks = tf.expand_dims(tf.argmax(pred_masks, axis=-1), axis=-1)\n",
    "        true_masks.extend(masks)\n",
    "        predicted_masks.extend(pred_masks)\n",
    "        \n",
    "    true_masks = np.array(true_masks)\n",
    "    predicted_masks = np.array(predicted_masks)\n",
    "        \n",
    "    return true_masks, predicted_masks    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:27:49.37079Z",
     "iopub.status.busy": "2021-10-20T20:27:49.37049Z",
     "iopub.status.idle": "2021-10-20T20:29:17.022586Z",
     "shell.execute_reply": "2021-10-20T20:29:17.021664Z",
     "shell.execute_reply.started": "2021-10-20T20:27:49.370764Z"
    }
   },
   "outputs": [],
   "source": [
    "true_train_masks, predicted_train_masks = create_mask(train_dataset, model)\n",
    "true_validation_masks, predicted_validation_masks = create_mask(validation_dataset, model)\n",
    "true_test_masks, predicted_test_masks = create_mask(test_dataset, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"4-2\" name=\"4-2\"></a>\n",
    "### **4.2. Evaluate Predicted Segmentations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:17.024693Z",
     "iopub.status.busy": "2021-10-20T20:29:17.024408Z",
     "iopub.status.idle": "2021-10-20T20:29:17.046484Z",
     "shell.execute_reply": "2021-10-20T20:29:17.045576Z",
     "shell.execute_reply.started": "2021-10-20T20:29:17.024657Z"
    }
   },
   "outputs": [],
   "source": [
    "def evaluate_model(true_masks, predicted_masks, n_classes, smooth = 1e-6):\n",
    "    \n",
    "    # Create empty lists to store evaluation metric outputs\n",
    "    class_wise_true_positives, class_wise_true_negatives = [],[]\n",
    "    class_wise_false_positives, class_wise_false_negatives = [],[]\n",
    "    class_wise_precisions, class_wise_recalls = [],[] \n",
    "    class_wise_f1_scores, class_wise_ious = [],[] \n",
    "    classes = []\n",
    "            \n",
    "    for clas in range(n_classes):\n",
    "        true_positives, true_negatives, false_positives, false_negatives = 0,0,0,0\n",
    "        precisions, recalls, ious, f1_scores = 0,0,0,0        \n",
    "        \n",
    "        number_of_masks = true_masks.shape[0]\n",
    "        \n",
    "        for mask_id in range(number_of_masks):\n",
    "            true_positive = np.sum(np.logical_and(true_masks[mask_id]==clas, predicted_masks[mask_id]==clas))\n",
    "            true_negative = np.sum(np.logical_and(true_masks[mask_id]!=clas, predicted_masks[mask_id]!=clas))\n",
    "            false_positive = np.sum(np.logical_and(true_masks[mask_id]!=clas, predicted_masks[mask_id]==clas))\n",
    "            false_negative = np.sum(np.logical_and(true_masks[mask_id]==clas, predicted_masks[mask_id]!=clas))\n",
    "            \n",
    "            true_positives += true_positive\n",
    "            true_negatives += true_negative\n",
    "            false_positives += false_positive\n",
    "            false_negatives += false_negative\n",
    "\n",
    "        recall = round(true_positives/(true_positives + false_negatives + smooth), 2)\n",
    "        precision = round(true_positives/(true_positives + false_positives + smooth), 2)\n",
    "        iou = round(true_positives/(true_positives + false_negatives + false_positives + smooth), 2)\n",
    "        f1_score = round((2 * precision * recall)/(precision + recall + smooth), 2)\n",
    "        \n",
    "        class_wise_true_positives.append(true_positives)\n",
    "        class_wise_true_negatives.append(true_negatives)\n",
    "        class_wise_false_positives.append(false_positives)\n",
    "        class_wise_false_negatives.append(false_negatives)\n",
    "        class_wise_recalls.append(recall)\n",
    "        class_wise_precisions.append(precision)\n",
    "        class_wise_ious.append(iou)\n",
    "        class_wise_f1_scores.append(f1_score)\n",
    "        classes.append(\"Class \" + str(clas+1))\n",
    "        \n",
    "        \n",
    "    total_true_positives = np.sum(class_wise_true_positives)\n",
    "    total_true_negatives = np.sum(class_wise_true_negatives)\n",
    "    total_false_positives = np.sum(class_wise_false_positives)\n",
    "    total_false_negatives = np.sum(class_wise_false_negatives)\n",
    "    mean_recall = round(np.average(np.array(class_wise_recalls)), 2)\n",
    "    mean_precision = round(np.average(np.array(class_wise_precisions)), 2)\n",
    "    mean_iou = round(np.average(np.array(class_wise_ious)), 2)\n",
    "    mean_f1_score = round(np.average(np.array(class_wise_f1_scores)), 2)    \n",
    "         \n",
    "    class_wise_evaluations = {\"Class\": classes,\n",
    "                              \"True Positive Pixels\": class_wise_true_positives,\n",
    "                              \"True Negative Pixels\": class_wise_true_negatives,\n",
    "                              \"False Positive Pixels\": class_wise_false_positives,\n",
    "                              \"False Negative Pixels\": class_wise_false_negatives,\n",
    "                              \"IoU\": class_wise_ious,\n",
    "                              \"F1-Score\": class_wise_f1_scores\n",
    "                             }\n",
    "\n",
    "    overall_evaluations = {\"Class\": \"All Classes\",\n",
    "                        \"True Positive Pixels\": total_true_positives,\n",
    "                        \"True Negative Pixels\": total_true_negatives,\n",
    "                        \"False Positive Pixels\": total_false_positives,\n",
    "                        \"False Negative Pixels\": total_false_negatives,\n",
    "                        \"IoU\": mean_iou,\n",
    "                        \"F1-Score\": mean_f1_score}\n",
    "    \n",
    "    evaluations = {\"Overall Evaluations\": overall_evaluations, \n",
    "                   \"Class-wise Evaluations\": class_wise_evaluations}\n",
    "    \n",
    "    return evaluations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:17.048434Z",
     "iopub.status.busy": "2021-10-20T20:29:17.048098Z",
     "iopub.status.idle": "2021-10-20T20:29:17.063375Z",
     "shell.execute_reply": "2021-10-20T20:29:17.062645Z",
     "shell.execute_reply.started": "2021-10-20T20:29:17.048399Z"
    }
   },
   "outputs": [],
   "source": [
    "def show_evaluations(evaluations, \n",
    "                     metrics=[\n",
    "                     \"IoU\", \n",
    "                     \"F1-Score\"], \n",
    "                     class_list=None,\n",
    "                     display_evaluations=\"All\"):\n",
    "    \n",
    "    # Split evaluations into overall and class-wise evaluations\n",
    "    overall_evaluations = evaluations[\"Overall Evaluations\"]\n",
    "    class_wise_evaluations = evaluations[\"Class-wise Evaluations\"]\n",
    "    \n",
    "    # Validate list of metrics \n",
    "    for metric_id in range(len(metrics)):\n",
    "        metric = metrics[metric_id]\n",
    "        if metric not in overall_evaluations:\n",
    "            raise ValueError(\"'metrics argument' not properly defined. \"\n",
    "                            \"Kindly create a list containing one or more of the following metrics: \"\n",
    "                             \"'True Positive', 'True Negative', 'False Positive', 'False Negative', \"\n",
    "                             \"'Recall', 'Precision', 'F1 Score', 'IoU'\") \n",
    "    \n",
    "    # Check if class_list is none\n",
    "    if class_list != None and all(isinstance(class_, str) for class_ in class_list):\n",
    "        if len(class_list) == len(class_wise_evaluations[\"Class\"]):\n",
    "            class_list = [class_list]\n",
    "        else:\n",
    "            raise ValueError(\"class_list argument' not properly defined. \" \n",
    "                             \"List is either shorter or longer than segmentation classes\") \n",
    "    else:\n",
    "        class_list = [class_wise_evaluations[\"Class\"]]                             \n",
    "    \n",
    "    # Extract data from the evaluations\n",
    "    overall_data = [overall_evaluations[\"Class\"]] + [overall_evaluations[metrics[metric_id]] for metric_id in range(len(metrics))]\n",
    "    classwise_data = class_list + [class_wise_evaluations[metrics[metric_id]] for metric_id in range(len(metrics))]\n",
    "    overall_data = np.array(overall_data).reshape(1,-1)\n",
    "    classwise_data = np.array(classwise_data).transpose()\n",
    "    \n",
    "    # Determine the type of evaluation report to display\n",
    "    if display_evaluations.lower() == \"all\":\n",
    "        data = np.concatenate((overall_data, classwise_data), axis=0)\n",
    "    elif display_evaluations.lower() == \"overall\":\n",
    "        data = overall_data\n",
    "    elif display_evaluations.lower() == \"class-wise\" or \"classwise\":\n",
    "        data = classwise_data\n",
    "    else:\n",
    "        raise ValueError(\"Display argument are not properly defined.\"\n",
    "                        \"Kindly use 'All' to display both overall and class-wise evaluations.\"\n",
    "                        \"Use 'Overall' to display only the overall evaluations.\"\n",
    "                        \"Or use 'Class-wise' to display only the class-wise evaluations\")\n",
    "\n",
    "    \n",
    "    # Create evaluation report as a pandas dataframe\n",
    "    dataframe = pd.DataFrame(data)\n",
    "    dataframe_titles = [\"Class\"] + metrics\n",
    "    dataframe.columns = dataframe_titles\n",
    "    # dataframe = dataframe.set_index(dataframe_titles[0], col_level=1)\n",
    "    \n",
    "    return dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **4.2.1. Evaluate predicted segmentations of the training images**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:17.065022Z",
     "iopub.status.busy": "2021-10-20T20:29:17.064734Z",
     "iopub.status.idle": "2021-10-20T20:29:40.562564Z",
     "shell.execute_reply": "2021-10-20T20:29:40.561853Z",
     "shell.execute_reply.started": "2021-10-20T20:29:17.064987Z"
    }
   },
   "outputs": [],
   "source": [
    "model_evaluation_on_train_dataset = evaluate_model(true_train_masks, predicted_train_masks, n_classes=13)\n",
    "\n",
    "show_evaluations(model_evaluation_on_train_dataset, \n",
    "                 metrics=[\n",
    "                     \"IoU\", \n",
    "                     \"F1-Score\"], \n",
    "                 class_list=None, \n",
    "                 display_evaluations=\"All\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **4.2.2. Evaluate predicted segmentations of the validation images**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:40.564223Z",
     "iopub.status.busy": "2021-10-20T20:29:40.56373Z",
     "iopub.status.idle": "2021-10-20T20:29:45.414676Z",
     "shell.execute_reply": "2021-10-20T20:29:45.413963Z",
     "shell.execute_reply.started": "2021-10-20T20:29:40.564185Z"
    }
   },
   "outputs": [],
   "source": [
    "model_evaluation_on_validation_dataset = evaluate_model(true_validation_masks, predicted_validation_masks, n_classes=13)\n",
    "\n",
    "show_evaluations(model_evaluation_on_validation_dataset, \n",
    "                 metrics=[\n",
    "                     \"IoU\", \n",
    "                     \"F1-Score\"], \n",
    "                 class_list=None, \n",
    "                 display_evaluations=\"All\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **4.2.3. Evaluate predicted segmentations of the test images**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:45.41642Z",
     "iopub.status.busy": "2021-10-20T20:29:45.415827Z",
     "iopub.status.idle": "2021-10-20T20:29:46.573639Z",
     "shell.execute_reply": "2021-10-20T20:29:46.572855Z",
     "shell.execute_reply.started": "2021-10-20T20:29:45.416381Z"
    }
   },
   "outputs": [],
   "source": [
    "model_evaluation_on_test_dataset = evaluate_model(true_test_masks, predicted_test_masks, n_classes=13)\n",
    "\n",
    "show_evaluations(model_evaluation_on_test_dataset, \n",
    "                 metrics=[\n",
    "                     \"IoU\", \n",
    "                     \"F1-Score\"], \n",
    "                 class_list=None, \n",
    "                 display_evaluations=\"All\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"5\" name=\"5\"></a>\n",
    "## **5. Predict image segmentations using the trained Model**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"5-1\" name=\"5-1\"></a>\n",
    "### **5.1. Create functions to preprocess selected images and display their true state, true mask and predicted mask**\n",
    "\n",
    "In this step, we will:\n",
    "1. Load our model\n",
    "2. Define a function to create new masks using our model\n",
    "3. Define a function to display outputs of this process: an input image, its true mask, and its predicted mask.\n",
    "4. Define a function to select images from a specified dataset and return the images, their true masks and their predicted masks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.1. Load our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:46.57526Z",
     "iopub.status.busy": "2021-10-20T20:29:46.575002Z",
     "iopub.status.idle": "2021-10-20T20:29:47.384399Z",
     "shell.execute_reply": "2021-10-20T20:29:47.383605Z",
     "shell.execute_reply.started": "2021-10-20T20:29:46.575232Z"
    }
   },
   "outputs": [],
   "source": [
    "model = load_model('carla-image-segmentation-model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **5.1.2. Define a function to create new masks using our model** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:47.38603Z",
     "iopub.status.busy": "2021-10-20T20:29:47.385749Z",
     "iopub.status.idle": "2021-10-20T20:29:47.391664Z",
     "shell.execute_reply": "2021-10-20T20:29:47.390827Z",
     "shell.execute_reply.started": "2021-10-20T20:29:47.385994Z"
    }
   },
   "outputs": [],
   "source": [
    "def create_mask(pred_mask):\n",
    "    pred_mask = tf.argmax(pred_mask, axis=-1)\n",
    "    pred_mask = tf.expand_dims(pred_mask, axis=-1)\n",
    "    \n",
    "    return pred_mask[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **5.1.3. Define a function to display outputs of this process: an input image, its true mask, and its predicted mask** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:47.393681Z",
     "iopub.status.busy": "2021-10-20T20:29:47.393128Z",
     "iopub.status.idle": "2021-10-20T20:29:47.401156Z",
     "shell.execute_reply": "2021-10-20T20:29:47.400499Z",
     "shell.execute_reply.started": "2021-10-20T20:29:47.393645Z"
    }
   },
   "outputs": [],
   "source": [
    "def display(display_list):\n",
    "    plt.figure(figsize=(18, 18))\n",
    "\n",
    "    title = ['Input Image', 'True Mask', 'Predicted Mask']\n",
    "\n",
    "    for i in range(len(display_list)):\n",
    "        plt.subplot(1, len(display_list), i+1)\n",
    "        plt.title(title[i])\n",
    "        plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n",
    "        plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **5.1.4. Define a function to select images from a specified dataset and return the images, their true masks and their predicted masks** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:47.403535Z",
     "iopub.status.busy": "2021-10-20T20:29:47.403059Z",
     "iopub.status.idle": "2021-10-20T20:29:47.411025Z",
     "shell.execute_reply": "2021-10-20T20:29:47.410251Z",
     "shell.execute_reply.started": "2021-10-20T20:29:47.403501Z"
    }
   },
   "outputs": [],
   "source": [
    "def show_predictions(dataset, num):\n",
    "    \"\"\"\n",
    "    Displays the first image of each of the num batches\n",
    "    \"\"\"\n",
    "    if dataset:\n",
    "        for image, mask in dataset.take(num):\n",
    "            pred_mask = model.predict(image)\n",
    "            display([image[0], mask[0], create_mask(pred_mask)])\n",
    "    else:\n",
    "        display([sample_image, sample_mask,\n",
    "             create_mask(model.predict(sample_image[tf.newaxis, ...]))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"5-2\" name=\"5-2\"></a>\n",
    "### **5.2. Predict and compare masks of images in the training set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:47.414024Z",
     "iopub.status.busy": "2021-10-20T20:29:47.413794Z",
     "iopub.status.idle": "2021-10-20T20:29:50.998793Z",
     "shell.execute_reply": "2021-10-20T20:29:50.998056Z",
     "shell.execute_reply.started": "2021-10-20T20:29:47.414001Z"
    }
   },
   "outputs": [],
   "source": [
    "show_predictions(train_dataset, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"5-3\" name=\"5-3\"></a>\n",
    "### **5.3. Predict and compare masks of images in the validation set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:51.000357Z",
     "iopub.status.busy": "2021-10-20T20:29:51.000101Z",
     "iopub.status.idle": "2021-10-20T20:29:54.774758Z",
     "shell.execute_reply": "2021-10-20T20:29:54.77405Z",
     "shell.execute_reply.started": "2021-10-20T20:29:51.000328Z"
    }
   },
   "outputs": [],
   "source": [
    "show_predictions(validation_dataset, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"5-4\" name=\"5-4\"></a>\n",
    "### **5.4. Predict and compare masks of images in the test set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-10-20T20:29:54.776677Z",
     "iopub.status.busy": "2021-10-20T20:29:54.776401Z",
     "iopub.status.idle": "2021-10-20T20:29:58.526765Z",
     "shell.execute_reply": "2021-10-20T20:29:58.526062Z",
     "shell.execute_reply.started": "2021-10-20T20:29:54.776642Z"
    }
   },
   "outputs": [],
   "source": [
    "show_predictions(test_dataset, 6)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}