18. Modified Image Segmentation-tf.ipynb

{"metadata":{"colab":{"provenance":[],"gpuType":"T4"},"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"accelerator":"GPU","kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":2319455,"sourceType":"datasetVersion","datasetId":1392101}],"dockerImageVersionId":30615,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"### **Import Libraries**","metadata":{}},{"cell_type":"code","source":"import tensorflow as tf\nimport tensorflow_datasets as tfds\nfrom IPython.display import clear_output\nimport matplotlib.pyplot as plt\nimport os\nimport numpy as np\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import confusion_matrix","metadata":{"id":"cartKTidb2aH","execution":{"iopub.status.busy":"2023-12-31T06:38:18.468087Z","iopub.execute_input":"2023-12-31T06:38:18.468676Z","iopub.status.idle":"2023-12-31T06:38:35.391707Z","shell.execute_reply.started":"2023-12-31T06:38:18.468643Z","shell.execute_reply":"2023-12-31T06:38:35.390540Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"markdown","source":"### **Set Constant Values**","metadata":{}},{"cell_type":"code","source":"BATCH = 64\nAT = tf.data.AUTOTUNE\nBUFFER = 1000\n\nSTEPS_PER_EPOCH = 800//BATCH\nVALIDATION_STEPS = 200//BATCH\nINITIAL_EPOCHS = 50\nFINE_TUNE_EPOCHS = 150\n\nTRAIN_DATASET_PATH = \"/kaggle/input/people-clothing-segmentation/png_images/IMAGES/\"\nVALIDATION_DATASET_PATH = \"/kaggle/input/people-clothing-segmentation/png_masks/MASKS/\"","metadata":{"id":"EA2-9KEFlFRT","execution":{"iopub.status.busy":"2023-12-31T06:38:35.394103Z","iopub.execute_input":"2023-12-31T06:38:35.394817Z","iopub.status.idle":"2023-12-31T06:38:35.403491Z","shell.execute_reply.started":"2023-12-31T06:38:35.394779Z","shell.execute_reply":"2023-12-31T06:38:35.401241Z"},"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"markdown","source":"### **A Dataset Loader class for converting the dataset into a training dataset and validation dataset**","metadata":{}},{"cell_type":"code","source":"class DatasetLoader():\n    def __init__(self):\n      pass\n\n    '''\n      Load images and masks from the dataset\n\n      @param images_path - path to the images\n      @param masks_path - path to the masks\n      @return train_dataset - train dataset\n      @return validation_dataset - validation dataset\n    '''\n    def load_images_and_masks(self, images_path, masks_path):\n      image_paths = []\n      mask_paths = []\n\n      # Put the images paths into a list\n      for root, dir, files in os.walk(images_path):\n        for file in files:\n          path = os.path.join(root, file)\n          image_paths.append(path)\n\n      # Put the masks paths into a list\n      for root, dir, files in os.walk(masks_path):\n        for file in files:\n          path = os.path.join(root, file)\n          mask_paths.append(path)\n\n      # Sort the lists into their correct orders\n      image_paths.sort()\n      mask_paths.sort()\n\n      # Convert images and masks to tensors\n      images, masks = self._convert_images_masks_to_tensors(image_paths, mask_paths)\n\n      # Normalize images\n      images = self._normalize_images(images)\n\n      # Resize images and masks\n      images, masks = self._resize_images_and_masks(images, masks)\n\n      # Split dataset into train and validation\n      train_dataset, validation_dataset = self._train_test_split_dataset(images, masks)\n\n      return train_dataset, validation_dataset\n\n    '''\n      Convert images and masks to tensors\n\n      @param image_paths - list of image paths\n      @param mask_paths - list of mask paths\n      @return images - list of images\n      @return masks - list of masks\n    '''\n    def _convert_images_masks_to_tensors(self, image_paths, mask_paths):\n      images = []\n      masks = []\n\n      # Convert images to tensors\n      for image in image_paths:\n        image = tf.io.read_file(image)\n        image = tf.image.decode_png(image, channels=3, dtype=tf.uint8)\n        images.append(image)\n\n      # Convert masks to tensors\n      for mask in mask_paths:\n        mask = tf.io.read_file(mask)\n        mask = tf.image.decode_png(mask, channels=1, dtype=tf.uint8)\n        masks.append(mask)\n\n      return images, masks\n\n    '''\n      Split dataset into train and validation\n\n      @param images - list of images\n      @param masks - list of masks\n      @return train_dataset - train dataset\n      @return validation_dataset - validation dataset\n    '''\n    def _train_test_split_dataset(self, images, masks):\n      train_X, validation_X, train_y, validation_y = train_test_split(images, masks, test_size=0.2, random_state=42)\n\n      # Convert train and validation datasets to tensors\n      train_X = tf.data.Dataset.from_tensor_slices(train_X)\n      train_y = tf.data.Dataset.from_tensor_slices(train_y)\n\n      # Convert the validation datasets to tensors\n      validation_X = tf.data.Dataset.from_tensor_slices(validation_X)\n      validation_y = tf.data.Dataset.from_tensor_slices(validation_y)\n\n      # create a 1-1 mapping from X -> y\n      train_dataset = tf.data.Dataset.zip(train_X, train_y)\n      validation_dataset = tf.data.Dataset.zip(validation_X, validation_y)\n\n      return train_dataset, validation_dataset\n\n    '''\n      Normalize input images\n\n      @param images - list of images\n      @return image_list - list of normalized images\n    '''\n    def _normalize_images(self, images):\n      image_list = []\n      for image in images:\n        image = tf.cast(image, tf.float32)\n        image = image / 255.0\n        image_list.append(image)\n\n      return image_list\n\n    '''\n      Resize images and masks\n\n      @param images - list of images\n      @param masks - list of masks\n      @return image_list - list of resized images\n      @return mask_list - list of resized masks\n    '''\n    def _resize_images_and_masks(self, images, masks):\n      image_list = []\n      mask_list = []\n\n      for image in images:\n        image = tf.image.resize(image, (128, 128))\n        image_list.append(image)\n\n      for mask in masks:\n        mask = tf.cast(mask, tf.uint8)\n        mask = tf.image.resize(mask, (128, 128),\n                                      method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n        mask_list.append(mask)\n\n      return image_list, mask_list","metadata":{"id":"YBOcsPLhcJi4","execution":{"iopub.status.busy":"2023-12-31T06:38:35.405052Z","iopub.execute_input":"2023-12-31T06:38:35.405404Z","iopub.status.idle":"2023-12-31T06:38:35.428012Z","shell.execute_reply.started":"2023-12-31T06:38:35.405373Z","shell.execute_reply":"2023-12-31T06:38:35.426471Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"markdown","source":"### An Augment Dataset for augmented datasets","metadata":{}},{"cell_type":"code","source":"class AugmentDataset():\n    def __init__(self):\n      pass\n\n    '''\n      Augment dataset\n\n      @param image_dataset - image dataset\n      @return image_dataset - augmented image dataset\n    '''\n    def augment_dataset(self, image_dataset):\n      a = image_dataset.map(self._brightness)\n      b = image_dataset.map(self._contrast)\n      c = image_dataset.map(self._saturation)\n      d = image_dataset.map(self._hue)\n      e = image_dataset.map(self._crop)\n      f = image_dataset.map(self._flip)\n      g = image_dataset.map(self._rotate)\n\n      # Concatenate all augmented datasets to return a dataset 7X larger\n      image_dataset = image_dataset.concatenate(a)\n      image_dataset = image_dataset.concatenate(b)\n      image_dataset = image_dataset.concatenate(c)\n      image_dataset = image_dataset.concatenate(d)\n      image_dataset = image_dataset.concatenate(e)\n      image_dataset = image_dataset.concatenate(f)\n      image_dataset = image_dataset.concatenate(g)\n\n      return image_dataset\n\n    '''\n      Adjust an image's brightness\n\n      @param image - image\n      @return bright adjusted image\n    '''\n    def _brightness(self, image, mask):\n        image = tf.image.adjust_brightness(image, 0.1)\n        return image, mask\n\n    '''\n      Adjust an image and mask's contrast\n\n      @param image - image\n      @param mask - mask\n      @return contrast adjusted image\n      @return contrast adjusted mask\n    '''\n    def _contrast(self, image, mask):\n        image = tf.image.adjust_contrast(image, 0.1)\n        return image, mask\n\n    '''\n      Adjust an image and mask's saturation\n\n      @param image - image\n      @param mask - mask\n      @return saturation adjusted image\n      @return saturation adjusted mask\n    '''\n    def _saturation(self, image, mask):\n        image = tf.image.adjust_saturation(image, 0.1)\n        return image, mask\n\n    '''\n      Adjust an image and mask's hue\n\n      @param image - image\n      @param mask - mask\n      @return hue adjusted image\n      @return hue adjusted mask\n    '''\n    def _hue(self, image, mask):\n        image = tf.image.adjust_hue(image, 0.1)\n        return image, mask\n\n    '''\n      Crop an image and mask\n\n      @param image - image\n      @param mask - mask\n      @return cropped image\n      @return cropped mask\n    '''\n    def _crop(self, image, mask):\n      tf.image.central_crop(image, 0.7)\n      tf.image.resize(image, (128, 128))\n\n      mask = tf.image.central_crop(mask, 0.7)\n      mask = tf.image.resize(mask, (128,128))\n      mask = tf.cast(mask, tf.uint8)\n\n      return image, mask\n\n    '''\n      Flip an image and mask\n\n      @param image - image\n      @param mask - mask\n      @return flipped image\n      @return flipped mask\n    '''\n    def _flip(self, image, mask):\n      image = tf.image.flip_left_right(image)\n      mask = tf.image.flip_left_right(mask)\n      return image, mask\n\n    '''\n      Rotate an image and mask\n\n      @param image - image\n      @param mask - mask\n      @return rotated image\n      @return rotated mask\n    '''\n    def _rotate(self, image, mask):\n      image = tf.image.rot90(image)\n      mask = tf.image.rot90(mask)\n      return image, mask","metadata":{"id":"Y-qsG3cw-kzu","execution":{"iopub.status.busy":"2023-12-31T06:38:35.430645Z","iopub.execute_input":"2023-12-31T06:38:35.431036Z","iopub.status.idle":"2023-12-31T06:38:35.447630Z","shell.execute_reply.started":"2023-12-31T06:38:35.430999Z","shell.execute_reply":"2023-12-31T06:38:35.446489Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":"### The Model Builder creates a modified UNet Model using a concatenation of a downsampler (MobileNetV2) and an upsampler","metadata":{}},{"cell_type":"code","source":"class ModelBuilder():\n    def __init__(self):\n      self.down_sampling_model = None\n      self.unet_model = None\n\n    '''\n      Create a unet model\n\n      @return unet model\n    '''\n    def build_unet_model(self):\n      # create the upsampling model using a combination of upsampling models\n      upsampling_model = [\n          self.build_upsampling_model(512, 4),\n          self.build_upsampling_model(256, 4),\n          self.build_upsampling_model(128, 4),\n          self.build_upsampling_model(64, 4)\n      ]\n\n      # create the input layer using the shape of the images\n      inputs = tf.keras.layers.Input(shape=[128, 128, 3])\n\n      self.down_sampling_model = self.build_down_sampling_model()\n\n      # store the results of the inputs going through the downsampling model\n      down_sample = self.down_sampling_model(inputs)\n\n      # store the last layer result as an output\n      output = down_sample[-1]\n\n      # store every output from the downsampling layer except the last one\n      skips = reversed(down_sample[:-1])\n\n      # loop through the upsampling model and the skips and concatenate them\n      for upsample, skip in zip(upsampling_model, skips):\n        output = upsample(output)\n        output = tf.keras.layers.Concatenate()([output, skip])\n\n      # downsample the output to get 59 mask potential values\n      output = tf.keras.layers.Conv2DTranspose(\n          filters=59,\n          kernel_size=3,\n          strides=2,\n          padding='same')(output)\n\n      # create and compile the UNET model\n      self.unet_model = tf.keras.Model(inputs=inputs, outputs=output)\n      self.compile_unet_model()\n\n      return self.unet_model\n\n    '''\n      Compile a unet model\n    '''\n    def compile_unet_model(self):\n      self.unet_model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n        optimizer=tf.keras.optimizers.RMSprop(lr=0.001),\n        metrics=['accuracy'])\n\n    '''\n      Create a fine-tuned unet model\n\n      @return fine-tuned unet model\n    '''\n    def build_fine_tuned_unet_model(self):\n      # enable training for the down_sampling_model (MobileNetV2)\n      self.down_sampling_model.trainable = True\n\n      # recompile the model\n      self.compile_unet_model()\n\n      return self.unet_model\n\n    '''\n      Create a down-sampling model\n\n      @return down-sampling model\n    '''\n    def build_down_sampling_model(self):\n      # using MobileNetV2 but any other choice could probably work here\n      base_model = tf.keras.applications.MobileNetV2(input_shape=(128, 128, 3), include_top=False, weights=\"imagenet\")\n\n      # Looking through the MobileNetV2 plot_model I found these blocks that\n      # fit the needs of the down_sampling_model.\n      skip_layer_names = [\n          \"block_1_expand_relu\", # 128 -> 64\n          \"block_2_expand_relu\", # 64 -> 32\n          \"block_5_expand_relu\", # 32 -> 16\n          \"block_8_expand_relu\", # 16 -> 8\n          \"block_14_expand_relu\", # 8 -> 4\n      ]\n\n      # get the skip layers from the base model using the layer names\n      skip_layers = [base_model.get_layer(name).output for name in skip_layer_names]\n\n      # create the down_sampling model with the base model having training disabled\n      down_stack = tf.keras.Model(inputs=base_model.input, outputs=skip_layers)\n      down_stack.trainable = False\n\n      return down_stack\n\n    '''\n      Create an up-sampling model\n\n      @param filters - number of filters\n      @param size - size of the kernel\n      @return up-sampling model\n    '''\n    def build_upsampling_model(self, filters, size):\n      initializer = tf.random_normal_initializer(0., 0.02)\n\n      upsampling_model = tf.keras.Sequential()\n      upsampling_model.add(tf.keras.layers.Conv2DTranspose(\n          filters, size, strides=2,\n          padding='same',\n          kernel_initializer=initializer,\n          use_bias=False))\n\n      upsampling_model.add(tf.keras.layers.BatchNormalization())\n      upsampling_model.add(tf.keras.layers.ReLU())\n\n      return upsampling_model","metadata":{"id":"bqmQg9LIUXbs","execution":{"iopub.status.busy":"2023-12-31T06:38:35.449373Z","iopub.execute_input":"2023-12-31T06:38:35.449745Z","iopub.status.idle":"2023-12-31T06:38:35.466617Z","shell.execute_reply.started":"2023-12-31T06:38:35.449713Z","shell.execute_reply":"2023-12-31T06:38:35.465196Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"markdown","source":"### An Image Viewer class for plotting images","metadata":{}},{"cell_type":"code","source":"class ImageViewer():\n    def __init__(self):\n      pass\n\n    '''\n      Show images and masks from a dataset\n\n      @param dataset - dataset to containg images and masks to display\n      @param num_to_show - an even number of images to show (default is 2)\n    '''\n    def show_from_dataset(self, dataset, num_to_show=2):\n      plt.figure(figsize=(15,15))\n\n      for image, mask in dataset.take(1):\n        for i in range(num_to_show):\n          if (i % 2) == 0:\n            plt.subplot(1,2,i+1)\n            plt.imshow(image)\n            plt.axis('off')\n          else:\n            plt.subplot(1,2,i+1)\n            plt.imshow(mask)\n            plt.axis(\"off\")\n            plt.show()\n\n    '''\n      Plot two images side-by-side\n      @param image1 -image 1\n      @param image2 - image 2\n    '''\n    def plot_two_images(self, image1, image2):\n      plt.figure(figsize=(15,15))\n      plt.subplot(1,2, 1)\n      plt.imshow(image1)\n      plt.axis('off')\n\n      plt.subplot(1,2, 2)\n      plt.imshow(image2)\n      plt.axis(\"off\")\n      plt.show()\n\n    '''\n      Show prediction\n\n      @param image - image\n      @param mask - mask\n      @param pred - prediction\n    '''\n    def show_pred(self, image, mask, pred):\n        plt.figure(figsize=(20,28))\n\n        k = 0\n        for i in pred:\n            # show the predicted mask\n            plt.subplot(4,3,1+k*3)\n            i = tf.argmax(i, axis=-1)\n            plt.imshow(i)\n            plt.axis('off')\n            plt.title('Prediction')\n\n            # show the groundtruth mask\n            plt.subplot(4,3,2+k*3)\n            plt.imshow(mask[k])\n            plt.axis('off')\n            plt.title('Ground Truth')\n\n            # show the real image\n            plt.subplot(4,3,3+k*3)\n            plt.imshow(image[k])\n            plt.axis('off')\n            plt.title('Actual')\n            k += 1\n            if k == 4: break\n\n        plt.suptitle('Preditions', color='blue', size=24)\n        plt.show()","metadata":{"id":"P3HtQkKKGver","execution":{"iopub.status.busy":"2023-12-31T06:38:35.468509Z","iopub.execute_input":"2023-12-31T06:38:35.468920Z","iopub.status.idle":"2023-12-31T06:38:35.483908Z","shell.execute_reply.started":"2023-12-31T06:38:35.468887Z","shell.execute_reply":"2023-12-31T06:38:35.482683Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":"### A Performance Report class for plotting the performance of the model","metadata":{}},{"cell_type":"code","source":"class PerformanceReport():\n    def __init__(self):\n      self.conf_matrix = None\n\n    '''\n      Plot the UNET model's loss performance\n\n      @param model_history - the unet model history\n    '''\n    def plot_loss_performance_charts(self, model_history):\n      loss = model_history.history['loss']\n      val_loss = model_history.history['val_loss']\n\n      plt.figure()\n      plt.plot(model_history.epoch, loss, 'r', label='Training loss')\n      plt.plot(model_history.epoch, val_loss, 'bo', label='Validation loss')\n      plt.title('Training and Validation Loss')\n      plt.xlabel('Epoch')\n      plt.ylabel('Loss Value')\n      plt.ylim([0.5, 1])\n      plt.legend()\n      plt.show()\n\n    '''\n      Plot the UNET model's accuracy performance\n\n      @param model_history - the unet model history\n    '''\n    def plot_accuracy_performance_charts(self, model_history):\n      loss = model_history.history['accuracy']\n      val_loss = model_history.history['val_accuracy']\n\n      plt.figure()\n      plt.plot(model_history.epoch, loss, 'r', label='Training Accuracy')\n      plt.plot(model_history.epoch, val_loss, 'bo', label='Validation Accuracy')\n      plt.title('Training and Validation Accuracy')\n      plt.xlabel('Epoch')\n      plt.ylabel('Accuracy Value')\n      plt.ylim([0.5, 1])\n      plt.legend()\n      plt.show()\n\n    '''\n      Display a confusion matrix\n\n      @param y_true - true labels\n      @param y_pred - predicted labels\n    '''\n    def display_confusion_matrix(self, y_true, y_pred):\n      self.conf_matrix = confusion_matrix(y_true=y_true, y_pred=y_pred)\n\n      # plot the confusion matrix\n      fig, ax = plt.subplots(figsize=(7.5, 7.5))\n      ax.matshow(self.conf_matrix, cmap=plt.cm.Blues, alpha=0.3)\n      for i in range(self.conf_matrix.shape[0]):\n          for j in range(self.conf_matrix.shape[1]):\n              ax.text(x=j, y=i,s=self.conf_matrix[i, j], va='center', ha='center', size='xx-large')\n\n      plt.xlabel('Predictions', fontsize=14)\n      plt.ylabel('Actuals', fontsize=14)\n      plt.title('Confusion Matrix', fontsize=18)\n      plt.show()\n\n      # Show the confusion matrix results in a text report\n      self._show_confusion_matrix_report()\n\n      '''\n        Display the results of the confusion matrix as a text report\n      '''\n      def _show_confusion_matrix_report(self):\n        tn, fp, fn, tp = self.conf_matrix.ravel()\n\n        print(\"True Positive (TP): \", tp)\n        print(\"True Negative (TN): \", tn)\n        print(\"False Positive (FP): \", fp)\n        print(\"False Negative (FN): \", fn)\n\n        accuracy = (tp + tn) / (tp + tn + fp + fn)\n\n        precision = tp / (tp + fp)\n\n        recall = tp / (tp + fn)\n\n        f1_score = 2 * (precision * recall) / (precision + recall)\n\n        print(\"\\n\\nMetrics:\")\n        print(\"Accuracy: \", round(accuracy, 2))\n        print(\"Precision: \", round(precision, 2))\n        print(\"Recall: \", round(recall, 2))\n        print(\"F1-score: \", round(f1_score, 2))","metadata":{"id":"SP5tdCxC4aCe","execution":{"iopub.status.busy":"2023-12-31T06:38:35.485583Z","iopub.execute_input":"2023-12-31T06:38:35.485981Z","iopub.status.idle":"2023-12-31T06:38:35.503072Z","shell.execute_reply.started":"2023-12-31T06:38:35.485949Z","shell.execute_reply":"2023-12-31T06:38:35.501675Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"markdown","source":"#### Start by loading the images and masks into a training_dataset and validation_dataset","metadata":{}},{"cell_type":"code","source":"dataset_loader = DatasetLoader()\ntrain_dataset, validation_dataset = dataset_loader.load_images_and_masks(TRAIN_DATASET_PATH, VALIDATION_DATASET_PATH)","metadata":{"id":"S8X24zdBkq-8","execution":{"iopub.status.busy":"2023-12-31T06:38:35.505118Z","iopub.execute_input":"2023-12-31T06:38:35.505942Z","iopub.status.idle":"2023-12-31T06:39:08.131135Z","shell.execute_reply.started":"2023-12-31T06:38:35.505896Z","shell.execute_reply":"2023-12-31T06:39:08.129977Z"},"trusted":true},"execution_count":8,"outputs":[]},{"cell_type":"markdown","source":"#### Verify an image and corresponding mask from the training set","metadata":{}},{"cell_type":"code","source":"image_viewer = ImageViewer()\nimage_viewer.show_from_dataset(train_dataset)","metadata":{"id":"BA4v0axsHI_Y","outputId":"a71df322-893a-43b7-c050-3cf65fc72816","execution":{"iopub.status.busy":"2023-12-31T06:39:08.132959Z","iopub.execute_input":"2023-12-31T06:39:08.133399Z","iopub.status.idle":"2023-12-31T06:39:08.541164Z","shell.execute_reply.started":"2023-12-31T06:39:08.133360Z","shell.execute_reply":"2023-12-31T06:39:08.539888Z"},"trusted":true},"execution_count":9,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1500x1500 with 2 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"markdown","source":"#### Augment the training dataset to create 7X more training data","metadata":{}},{"cell_type":"code","source":"augment_dataset = AugmentDataset()\ntrain_dataset = augment_dataset.augment_dataset(train_dataset)\n\nprint(\"Training Dataset: \", len(train_dataset))\nprint(\"Training Dataset #:\", train_dataset.element_spec)","metadata":{"id":"1HiRvaoqApqO","outputId":"fc870d68-46d9-495f-ee67-14694c0d6b5e","execution":{"iopub.status.busy":"2023-12-31T06:39:08.544731Z","iopub.execute_input":"2023-12-31T06:39:08.545178Z","iopub.status.idle":"2023-12-31T06:39:09.072544Z","shell.execute_reply.started":"2023-12-31T06:39:08.545144Z","shell.execute_reply":"2023-12-31T06:39:09.071312Z"},"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"Training Dataset:  6400\nTraining Dataset #: (TensorSpec(shape=(128, 128, 3), dtype=tf.float32, name=None), TensorSpec(shape=(128, 128, 1), dtype=tf.uint8, name=None))\n","output_type":"stream"}]},{"cell_type":"markdown","source":"#### Build the modified UNet model","metadata":{}}]}