train_segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copyright (C) 2024  Jose Ángel Pérez Garrido\n",
    "# \n",
    "# This program is free software: you can redistribute it and/or modify\n",
    "# it under the terms of the GNU General Public License as published by\n",
    "# the Free Software Foundation, either version 3 of the License, or\n",
    "# (at your option) any later version.\n",
    "\n",
    "# This program is distributed in the hope that it will be useful,\n",
    "# but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
    "# GNU General Public License for more details.\n",
    "\n",
    "# You should have received a copy of the GNU General Public License\n",
    "# along with this program.  If not, see <https://www.gnu.org/licenses/>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare a segmentation model for evaluation\n",
    "\n",
    "### Prepare the environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables\n",
    "DATASET_PATH = \"./datasets/TU-Graz\"\n",
    "SEED = 42 # Fixing the seed for PRNGs, to help reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import keras\n",
    "from keras.models import Model\n",
    "from keras.layers import *\n",
    "from keras.applications.vgg16 import *\n",
    "from keras.applications import InceptionV3\n",
    "\n",
    "# Fixing the seed for PRNGs, to help reproducibility\n",
    "np.random.seed(SEED)\n",
    "tf.random.set_seed(SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cityscapes Classes\n",
    "\n",
    "Let us first explore what TU-Graz contains. As stated by the Institute of Computer Graphics and Vision in the [Dataset Overview](https://www.tugraz.at/index.php?id=22387), the complexity of the dataset is limited to 23 classes as listed below.\n",
    "\n",
    "Therefore, we will use these methods to list all the classes appearing in this dataset, along with their related information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>r</th>\n",
       "      <th>g</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>unlabeled</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>paved-area</td>\n",
       "      <td>128</td>\n",
       "      <td>64</td>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dirt</td>\n",
       "      <td>130</td>\n",
       "      <td>76</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>grass</td>\n",
       "      <td>0</td>\n",
       "      <td>102</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>gravel</td>\n",
       "      <td>112</td>\n",
       "      <td>103</td>\n",
       "      <td>87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>water</td>\n",
       "      <td>28</td>\n",
       "      <td>42</td>\n",
       "      <td>168</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>rocks</td>\n",
       "      <td>48</td>\n",
       "      <td>41</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>pool</td>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>89</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>vegetation</td>\n",
       "      <td>107</td>\n",
       "      <td>142</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>roof</td>\n",
       "      <td>70</td>\n",
       "      <td>70</td>\n",
       "      <td>70</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>wall</td>\n",
       "      <td>102</td>\n",
       "      <td>102</td>\n",
       "      <td>156</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>window</td>\n",
       "      <td>254</td>\n",
       "      <td>228</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>door</td>\n",
       "      <td>254</td>\n",
       "      <td>148</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>fence</td>\n",
       "      <td>190</td>\n",
       "      <td>153</td>\n",
       "      <td>153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>fence-pole</td>\n",
       "      <td>153</td>\n",
       "      <td>153</td>\n",
       "      <td>153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>person</td>\n",
       "      <td>255</td>\n",
       "      <td>22</td>\n",
       "      <td>96</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>dog</td>\n",
       "      <td>102</td>\n",
       "      <td>51</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>car</td>\n",
       "      <td>9</td>\n",
       "      <td>143</td>\n",
       "      <td>150</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>bicycle</td>\n",
       "      <td>119</td>\n",
       "      <td>11</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>tree</td>\n",
       "      <td>51</td>\n",
       "      <td>51</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>bald-tree</td>\n",
       "      <td>190</td>\n",
       "      <td>250</td>\n",
       "      <td>190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>ar-marker</td>\n",
       "      <td>112</td>\n",
       "      <td>150</td>\n",
       "      <td>146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>obstacle</td>\n",
       "      <td>2</td>\n",
       "      <td>135</td>\n",
       "      <td>115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>conflicting</td>\n",
       "      <td>255</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           name    r    g    b\n",
       "0     unlabeled    0    0    0\n",
       "1    paved-area  128   64  128\n",
       "2          dirt  130   76    0\n",
       "3         grass    0  102    0\n",
       "4        gravel  112  103   87\n",
       "5         water   28   42  168\n",
       "6         rocks   48   41   30\n",
       "7          pool    0   50   89\n",
       "8    vegetation  107  142   35\n",
       "9          roof   70   70   70\n",
       "10         wall  102  102  156\n",
       "11       window  254  228   12\n",
       "12         door  254  148   12\n",
       "13        fence  190  153  153\n",
       "14   fence-pole  153  153  153\n",
       "15       person  255   22   96\n",
       "16          dog  102   51    0\n",
       "17          car    9  143  150\n",
       "18      bicycle  119   11   32\n",
       "19         tree   51   51    0\n",
       "20    bald-tree  190  250  190\n",
       "21    ar-marker  112  150  146\n",
       "22     obstacle    2  135  115\n",
       "23  conflicting  255    0    0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_file = pd.read_csv(str(DATASET_PATH + '/class_dict.csv'))\n",
    "\n",
    "class_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CLASSES=['unlabeled', 'paved-area', 'dirt', 'grass', 'gravel', 'water', 'rocks', 'pool', 'vegetation', 'roof', 'wall', 'window', 'door', 'fence', 'fence-pole', 'person', 'dog', 'car', 'bicycle', 'tree', 'bald-tree', 'ar-marker', 'obstacle', 'conflicting']\n",
      "COLORS=[(0, 0, 0), (128, 64, 128), (130, 76, 0), (0, 102, 0), (112, 103, 87), (28, 42, 168), (48, 41, 30), (0, 50, 89), (107, 142, 35), (70, 70, 70), (102, 102, 156), (254, 228, 12), (254, 148, 12), (190, 153, 153), (153, 153, 153), (255, 22, 96), (102, 51, 0), (9, 143, 150), (119, 11, 32), (51, 51, 0), (190, 250, 190), (112, 150, 146), (2, 135, 115), (255, 0, 0)]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-10 12:17:44.314535: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.341429: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.341658: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.343699: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.343926: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.344131: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.695285: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.695499: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.695527: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2022] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2024-05-10 12:17:44.695733: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:07:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-05-10 12:17:44.695757: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 9470 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3060, pci bus id: 0000:07:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "CLASSES = list(class_file[\"name\"])\n",
    "NUM_CLASSES = len(CLASSES)\n",
    "COLORS = list(zip(class_file[\" r\"],class_file[\" g\"],class_file[\" b\"]))\n",
    "COLORS_TF = tf.constant(COLORS, dtype=tf.int32) # TF constant corresponding to our color list\n",
    "\n",
    "print(f\"{CLASSES=}\")\n",
    "print(f\"{COLORS=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data preprocessing\n",
    "\n",
    "The procedure is defined below:\n",
    "\n",
    "1. Resize each `400 x 600` image to a—`286 x 286`, or directly to `256 x 256` if data augmentation is not applied.\n",
    "2. (With data augmentation) Randomly crop it to `256 x 256`.\n",
    "3. (With data augmentation) Randomly flip the image horizontally i.e., left to right (random mirroring).\n",
    "4. Convert label images to one-hot encoding.\n",
    "5. Normalize the images to the `[-1, 1]` range (as indicated in [How to Train a GAN? Tips and tricks to make GANs work](https://github.com/soumith/ganhacks?tab=readme-ov-file#1-normalize-the-inputs)).\n",
    "\n",
    "We employ an 80/10/10 split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Each image is 256x256 in size\n",
    "IMG_WIDTH = 256\n",
    "IMG_HEIGHT = 256\n",
    "\n",
    "# The training set consist of 400 images\n",
    "BUFFER_SIZE = 320\n",
    "\n",
    "def load(image_file, type=tf.float32):\n",
    "  # Read and decode an image file to a uint8 tensor\n",
    "  image = tf.io.read_file(image_file)\n",
    "  image = tf.io.decode_jpeg(image)\n",
    "\n",
    "  # Split each image tensor into two tensors:\n",
    "  # - one with a real building facade image\n",
    "  # - one with an architecture label image \n",
    "  w = tf.shape(image)[1]\n",
    "  w = w // 2\n",
    "  input_image = image[:, w:, :]\n",
    "  real_image = image[:, :w, :]\n",
    "\n",
    "  # Convert both images to float32 tensors\n",
    "  input_image = tf.cast(input_image, type)\n",
    "  real_image = tf.cast(real_image, type)\n",
    "\n",
    "  return input_image, real_image\n",
    "\n",
    "def resize(image, height, width, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR):\n",
    "  image = tf.image.resize(image, [height, width],\n",
    "                                method=method)\n",
    "\n",
    "  return image\n",
    "\n",
    "# Normalizing the images to [-1, 1]\n",
    "def normalize(image):\n",
    "  image = (image / 127.5) - 1\n",
    "\n",
    "  return image\n",
    "\n",
    "def random_crop(input_image, real_image):\n",
    "  stacked_image = tf.stack([input_image, real_image], axis=0)\n",
    "  cropped_image = tf.image.random_crop(\n",
    "      stacked_image, size=[2, IMG_WIDTH, IMG_HEIGHT, 3])\n",
    "\n",
    "  return cropped_image[0], cropped_image[1]\n",
    "\n",
    "@tf.function()\n",
    "def random_jitter(input_image, real_image):\n",
    "  # Resizing to 286x286\n",
    "  input_image = resize(input_image, 286, 286)\n",
    "  real_image = resize(real_image, 286, 286)\n",
    "\n",
    "  # Random cropping back to 256x256\n",
    "  input_image, real_image = random_crop(input_image, real_image)\n",
    "\n",
    "  if tf.random.uniform(()) > 0.5:\n",
    "    # Random mirroring\n",
    "    input_image = tf.image.flip_left_right(input_image)\n",
    "    real_image = tf.image.flip_left_right(real_image)\n",
    "\n",
    "  return input_image, real_image\n",
    "\n",
    "def convert_to_one_hot(image):\n",
    "    # Create a \"color reference\" tensor from image_colors\n",
    "    color_reference = tf.cast(tf.constant(COLORS), dtype=tf.float32)\n",
    "    comp = tf.equal(image[..., None, :], color_reference)\n",
    "    one_hot = tf.cast(tf.reduce_all(comp, axis=-1), dtype=tf.float32)\n",
    "\n",
    "    return one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load images without data augmentation\n",
    "def load_image_seg(image_file):\n",
    "  input_image, real_image = load(image_file)\n",
    "  input_image = resize(input_image, IMG_WIDTH, IMG_HEIGHT)\n",
    "  real_image = resize(real_image, IMG_WIDTH, IMG_HEIGHT)\n",
    "  input_image = convert_to_one_hot(input_image)\n",
    "  real_image = normalize(real_image)\n",
    "\n",
    "  return real_image, input_image\n",
    "\n",
    "# Load images without data augmentation\n",
    "def load_image_seg_da(image_file):\n",
    "  input_image, real_image = load(image_file)\n",
    "  input_image, real_image = random_jitter(input_image, real_image)\n",
    "  input_image = convert_to_one_hot(input_image)\n",
    "  real_image = normalize(real_image)\n",
    "\n",
    "  return real_image, input_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network hyper-parameters:\n",
    "batch_size     = 16\n",
    "num_epochs     = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset size: 20\n",
      "Validation dataset size: 3\n",
      "Test dataset size: 3\n"
     ]
    }
   ],
   "source": [
    "# 80% training, 10% validation, and 10% test\n",
    "train_percentage = 0.8\n",
    "val_percentage = 0.1\n",
    "test_percentage = 0.1\n",
    "\n",
    "dataset = tf.data.Dataset.list_files(str(DATASET_PATH + '/*.png'), shuffle=False)\n",
    "\n",
    "# Calculate the sizes for each set\n",
    "dataset_size = len(list(dataset))\n",
    "train_size = int(train_percentage * dataset_size)\n",
    "val_size = int(val_percentage * dataset_size)\n",
    "test_size = dataset_size - train_size - val_size\n",
    "\n",
    "# Split the dataset\n",
    "train_dataset = dataset.take(train_size)\n",
    "val_dataset = dataset.skip(train_size).take(val_size)\n",
    "test_dataset = dataset.skip(train_size + val_size).take(test_size)\n",
    "\n",
    "train_dataset = train_dataset.map(load_image_seg,\n",
    "                                  num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_dataset = train_dataset.shuffle(BUFFER_SIZE)\n",
    "train_dataset = train_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Training dataset size:\",train_dataset.cardinality().numpy())\n",
    "\n",
    "val_dataset = val_dataset.map(load_image_seg)\n",
    "val_dataset = val_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Validation dataset size:\",val_dataset.cardinality().numpy())\n",
    "\n",
    "test_dataset = test_dataset.map(load_image_seg)\n",
    "test_dataset = test_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Test dataset size:\",test_dataset.cardinality().numpy())"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FCN-8s architecture\n",
    "\n",
    "FCN models have been developed for semantic segmentation. Based on VGG-16, they use this network as feature extractor, adding on top some layers to concatenate and upsample the feature maps into pixel-level predictions.\n",
    "\n",
    "The FCN architecture is as follow:\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "To purely focus on the architecture, we will once again use the Keras high-level API to create our model. Using the pre-trained VGG-16 network provided by Keras, we extend at according to the previous figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fcn_8s(image_size, ch_in=3, ch_out=3):\n",
    "    \"\"\"\n",
    "    Build a FCN-8s Keras model, with the VGG-16 layers pretrained on ImageNet.\n",
    "    :param image_size:  Image size (H x W)\n",
    "    :param ch_in:       Number of input channels\n",
    "    :param ch_out:      Number of output channels\n",
    "    :return:            Keras model\n",
    "    \"\"\"\n",
    "    \n",
    "    inputs = Input(shape=(*image_size, ch_in), name='input')\n",
    "\n",
    "    # Building a pre-trained VGG-16 feature extractor (i.e., without the final FC layers)\n",
    "    vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=inputs)\n",
    "\n",
    "    for layer in vgg16.layers:\n",
    "        layer.trainable = False\n",
    "\n",
    "    # Recovering the feature maps generated by each of the 3 final blocks:\n",
    "    f3 = vgg16.get_layer('block3_pool').output  # shape: (28, 28, 256)\n",
    "    f4 = vgg16.get_layer('block4_pool').output  # shape: (14, 14, 512)\n",
    "    f5 = vgg16.get_layer('block5_pool').output  # shape: ( 7,  7, 512)\n",
    "    f5.trainable = True\n",
    "\n",
    "    # Replacing VGG dense layers by convolutions:\n",
    "    f5_conv1 = Conv2D(filters=4086, kernel_size=7, padding='same',\n",
    "                      activation='relu')(f5)\n",
    "    f5_drop1 = Dropout(0.5)(f5_conv1)\n",
    "    f5_conv2 = Conv2D(filters=4086, kernel_size=1, padding='same',\n",
    "                      activation='relu')(f5_drop1)\n",
    "    f5_drop2 = Dropout(0.5)(f5_conv2)\n",
    "    f5_conv3 = Conv2D(filters=ch_out, kernel_size=1, padding='same',\n",
    "                      activation=None)(f5_drop2)\n",
    "\n",
    "\n",
    "    # Using a transposed conv (w/ s=2) to upscale `f5` into a 14 x 14 map\n",
    "    # so it can be merged with features from `f4_conv1` obtained from `f4`:\n",
    "    f5_conv3_x2 = Conv2DTranspose(filters=ch_out, kernel_size=4, strides=2,\n",
    "                                use_bias=False, padding='same', activation='relu')(f5_conv3)\n",
    "    f4_conv1 = Conv2D(filters=ch_out, kernel_size=1, padding='same',\n",
    "                      activation=None)(f4)\n",
    "\n",
    "    # Merging the 2 feature maps (addition):\n",
    "    merge1 = add([f4_conv1, f5_conv3_x2])\n",
    "\n",
    "    # We repeat the operation to merge `merge1` and `f3` into a 28 x 28 map:\n",
    "    merge1_x2 = Conv2DTranspose(filters=ch_out, kernel_size=4, strides=2,\n",
    "                                use_bias=False, padding='same', activation='relu')(merge1)\n",
    "    f3_conv1 = Conv2D(filters=ch_out, kernel_size=1, padding='same',\n",
    "                      activation=None)(f3)\n",
    "    merge2 = add([f3_conv1, merge1_x2])\n",
    "\n",
    "    # Finally, we use another transposed conv to decode and up-scale the feature map\n",
    "    # to the original shape, i.e., using a stride 8 to go from 28 x 28 to 224 x 224 here:\n",
    "    outputs = Conv2DTranspose(filters=ch_out, kernel_size=16, strides=8,\n",
    "                              padding='same', activation=\"softmax\")(merge2)\n",
    "    \n",
    "    fcn8s_model = Model(inputs, outputs)\n",
    "    return fcn8s_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input (InputLayer)          [(None, 256, 256, 3)]        0         []                            \n",
      "                                                                                                  \n",
      " block1_conv1 (Conv2D)       (None, 256, 256, 64)         1792      ['input[0][0]']               \n",
      "                                                                                                  \n",
      " block1_conv2 (Conv2D)       (None, 256, 256, 64)         36928     ['block1_conv1[0][0]']        \n",
      "                                                                                                  \n",
      " block1_pool (MaxPooling2D)  (None, 128, 128, 64)         0         ['block1_conv2[0][0]']        \n",
      "                                                                                                  \n",
      " block2_conv1 (Conv2D)       (None, 128, 128, 128)        73856     ['block1_pool[0][0]']         \n",
      "                                                                                                  \n",
      " block2_conv2 (Conv2D)       (None, 128, 128, 128)        147584    ['block2_conv1[0][0]']        \n",
      "                                                                                                  \n",
      " block2_pool (MaxPooling2D)  (None, 64, 64, 128)          0         ['block2_conv2[0][0]']        \n",
      "                                                                                                  \n",
      " block3_conv1 (Conv2D)       (None, 64, 64, 256)          295168    ['block2_pool[0][0]']         \n",
      "                                                                                                  \n",
      " block3_conv2 (Conv2D)       (None, 64, 64, 256)          590080    ['block3_conv1[0][0]']        \n",
      "                                                                                                  \n",
      " block3_conv3 (Conv2D)       (None, 64, 64, 256)          590080    ['block3_conv2[0][0]']        \n",
      "                                                                                                  \n",
      " block3_pool (MaxPooling2D)  (None, 32, 32, 256)          0         ['block3_conv3[0][0]']        \n",
      "                                                                                                  \n",
      " block4_conv1 (Conv2D)       (None, 32, 32, 512)          1180160   ['block3_pool[0][0]']         \n",
      "                                                                                                  \n",
      " block4_conv2 (Conv2D)       (None, 32, 32, 512)          2359808   ['block4_conv1[0][0]']        \n",
      "                                                                                                  \n",
      " block4_conv3 (Conv2D)       (None, 32, 32, 512)          2359808   ['block4_conv2[0][0]']        \n",
      "                                                                                                  \n",
      " block4_pool (MaxPooling2D)  (None, 16, 16, 512)          0         ['block4_conv3[0][0]']        \n",
      "                                                                                                  \n",
      " block5_conv1 (Conv2D)       (None, 16, 16, 512)          2359808   ['block4_pool[0][0]']         \n",
      "                                                                                                  \n",
      " block5_conv2 (Conv2D)       (None, 16, 16, 512)          2359808   ['block5_conv1[0][0]']        \n",
      "                                                                                                  \n",
      " block5_conv3 (Conv2D)       (None, 16, 16, 512)          2359808   ['block5_conv2[0][0]']        \n",
      "                                                                                                  \n",
      " block5_pool (MaxPooling2D)  (None, 8, 8, 512)            0         ['block5_conv3[0][0]']        \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)             (None, 8, 8, 4086)           1025136   ['block5_pool[0][0]']         \n",
      "                                                          54                                      \n",
      "                                                                                                  \n",
      " dropout (Dropout)           (None, 8, 8, 4086)           0         ['conv2d[0][0]']              \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)           (None, 8, 8, 4086)           1669948   ['dropout[0][0]']             \n",
      "                                                          2                                       \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)         (None, 8, 8, 4086)           0         ['conv2d_1[0][0]']            \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)           (None, 8, 8, 24)             98088     ['dropout_1[0][0]']           \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)           (None, 16, 16, 24)           12312     ['block4_pool[0][0]']         \n",
      "                                                                                                  \n",
      " conv2d_transpose (Conv2DTr  (None, 16, 16, 24)           9216      ['conv2d_2[0][0]']            \n",
      " anspose)                                                                                         \n",
      "                                                                                                  \n",
      " add (Add)                   (None, 16, 16, 24)           0         ['conv2d_3[0][0]',            \n",
      "                                                                     'conv2d_transpose[0][0]']    \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)           (None, 32, 32, 24)           6168      ['block3_pool[0][0]']         \n",
      "                                                                                                  \n",
      " conv2d_transpose_1 (Conv2D  (None, 32, 32, 24)           9216      ['add[0][0]']                 \n",
      " Transpose)                                                                                       \n",
      "                                                                                                  \n",
      " add_1 (Add)                 (None, 32, 32, 24)           0         ['conv2d_4[0][0]',            \n",
      "                                                                     'conv2d_transpose_1[0][0]']  \n",
      "                                                                                                  \n",
      " conv2d_transpose_2 (Conv2D  (None, 256, 256, 24)         147480    ['add_1[0][0]']               \n",
      " Transpose)                                                                                       \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 134210304 (511.97 MB)\n",
      "Trainable params: 119495616 (455.84 MB)\n",
      "Non-trainable params: 14714688 (56.13 MB)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "seg_model = fcn_8s((IMG_WIDTH,IMG_HEIGHT), 3, NUM_CLASSES)\n",
    "seg_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VGG is a rather heavy architecture (c.f. number of parameters). Nevertheless, most of the layers composing our model have been pre-trained on ImageNet already, which will simplify the training for our new task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'TU-Graz_fcn8s'\n",
    "model_dir = os.path.join('models', model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This training loop saves logs that you can view in TensorBoard to monitor the training progress.\n",
    "\n",
    "If you work on a local machine, you would launch a separate TensorBoard process. When working in a notebook, launch the viewer before starting the training to monitor with TensorBoard.\n",
    "\n",
    "Prepare and launch the TensorBoard viewer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_dir=\"logs_seg/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tensorboard extension is already loaded. To reload it, use:\n",
      "  %reload_ext tensorboard\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Reusing TensorBoard on port 6006 (pid 4981), started 0:00:02 ago. (Use '!kill 4981' to kill it.)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-2131d2d46d2873b9\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-2131d2d46d2873b9\");\n",
       "          const url = new URL(\"http://localhost\");\n",
       "          const port = 6006;\n",
       "          if (port) {\n",
       "            url.port = port;\n",
       "          }\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext tensorboard\n",
    "%tensorboard --logdir {log_dir}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/150\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-10 12:18:32.402239: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:961] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inmodel/dropout/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n",
      "2024-05-10 12:18:35.102222: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8902\n",
      "2024-05-10 12:18:43.280281: I external/local_xla/xla/service/service.cc:168] XLA service 0x7f4b38b4e1b0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-05-10 12:18:43.280337: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 3060, Compute Capability 8.6\n",
      "2024-05-10 12:18:43.286645: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1715336323.397936  278914 device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 41s 1s/step - loss: 2.5074 - accuracy: 0.3548 - one_hot_mean_io_u: 0.0544 - val_loss: 1.9194 - val_accuracy: 0.4605 - val_one_hot_mean_io_u: 0.0927\n",
      "Epoch 2/150\n",
      "20/20 [==============================] - 18s 814ms/step - loss: 1.6691 - accuracy: 0.5242 - one_hot_mean_io_u: 0.1125 - val_loss: 1.4729 - val_accuracy: 0.5806 - val_one_hot_mean_io_u: 0.1167\n",
      "Epoch 3/150\n",
      "20/20 [==============================] - 18s 816ms/step - loss: 1.4135 - accuracy: 0.5878 - one_hot_mean_io_u: 0.1407 - val_loss: 1.2529 - val_accuracy: 0.6452 - val_one_hot_mean_io_u: 0.1602\n",
      "Epoch 4/150\n",
      "20/20 [==============================] - 18s 814ms/step - loss: 1.2365 - accuracy: 0.6353 - one_hot_mean_io_u: 0.1661 - val_loss: 1.0936 - val_accuracy: 0.6764 - val_one_hot_mean_io_u: 0.1846\n",
      "Epoch 5/150\n",
      "20/20 [==============================] - 17s 800ms/step - loss: 1.1019 - accuracy: 0.6710 - one_hot_mean_io_u: 0.1916 - val_loss: 0.9934 - val_accuracy: 0.6963 - val_one_hot_mean_io_u: 0.2119\n",
      "Epoch 6/150\n",
      "20/20 [==============================] - 17s 802ms/step - loss: 1.0345 - accuracy: 0.6896 - one_hot_mean_io_u: 0.2174 - val_loss: 0.9228 - val_accuracy: 0.7294 - val_one_hot_mean_io_u: 0.2305\n",
      "Epoch 7/150\n",
      "20/20 [==============================] - 17s 789ms/step - loss: 0.9706 - accuracy: 0.7060 - one_hot_mean_io_u: 0.2306 - val_loss: 0.9015 - val_accuracy: 0.7298 - val_one_hot_mean_io_u: 0.2378\n",
      "Epoch 8/150\n",
      "20/20 [==============================] - 18s 838ms/step - loss: 0.9038 - accuracy: 0.7273 - one_hot_mean_io_u: 0.2535 - val_loss: 0.8882 - val_accuracy: 0.7288 - val_one_hot_mean_io_u: 0.2734\n",
      "Epoch 9/150\n",
      "20/20 [==============================] - 18s 814ms/step - loss: 0.8501 - accuracy: 0.7417 - one_hot_mean_io_u: 0.2767 - val_loss: 0.7911 - val_accuracy: 0.7586 - val_one_hot_mean_io_u: 0.2813\n",
      "Epoch 10/150\n",
      "20/20 [==============================] - 19s 842ms/step - loss: 0.8215 - accuracy: 0.7475 - one_hot_mean_io_u: 0.2968 - val_loss: 0.7244 - val_accuracy: 0.7769 - val_one_hot_mean_io_u: 0.3074\n",
      "Epoch 11/150\n",
      "20/20 [==============================] - 17s 777ms/step - loss: 0.7732 - accuracy: 0.7619 - one_hot_mean_io_u: 0.3135 - val_loss: 0.7878 - val_accuracy: 0.7511 - val_one_hot_mean_io_u: 0.3334\n",
      "Epoch 12/150\n",
      "20/20 [==============================] - 18s 812ms/step - loss: 0.7374 - accuracy: 0.7724 - one_hot_mean_io_u: 0.3293 - val_loss: 0.6790 - val_accuracy: 0.7937 - val_one_hot_mean_io_u: 0.3328\n",
      "Epoch 13/150\n",
      "20/20 [==============================] - 17s 794ms/step - loss: 0.7159 - accuracy: 0.7783 - one_hot_mean_io_u: 0.3380 - val_loss: 0.6785 - val_accuracy: 0.7916 - val_one_hot_mean_io_u: 0.3500\n",
      "Epoch 14/150\n",
      "20/20 [==============================] - 17s 778ms/step - loss: 0.6942 - accuracy: 0.7848 - one_hot_mean_io_u: 0.3556 - val_loss: 0.6922 - val_accuracy: 0.7838 - val_one_hot_mean_io_u: 0.3620\n",
      "Epoch 15/150\n",
      "20/20 [==============================] - 18s 817ms/step - loss: 0.6603 - accuracy: 0.7942 - one_hot_mean_io_u: 0.3676 - val_loss: 0.6086 - val_accuracy: 0.8074 - val_one_hot_mean_io_u: 0.3723\n",
      "Epoch 16/150\n",
      "20/20 [==============================] - 18s 819ms/step - loss: 0.6496 - accuracy: 0.7960 - one_hot_mean_io_u: 0.3698 - val_loss: 0.6531 - val_accuracy: 0.7984 - val_one_hot_mean_io_u: 0.3601\n",
      "Epoch 17/150\n",
      "20/20 [==============================] - 18s 835ms/step - loss: 0.6340 - accuracy: 0.8026 - one_hot_mean_io_u: 0.3791 - val_loss: 0.6242 - val_accuracy: 0.8038 - val_one_hot_mean_io_u: 0.4080\n",
      "Epoch 18/150\n",
      "20/20 [==============================] - 18s 853ms/step - loss: 0.6092 - accuracy: 0.8101 - one_hot_mean_io_u: 0.3910 - val_loss: 0.6007 - val_accuracy: 0.8106 - val_one_hot_mean_io_u: 0.3881\n",
      "Epoch 19/150\n",
      "20/20 [==============================] - 18s 844ms/step - loss: 0.6159 - accuracy: 0.8066 - one_hot_mean_io_u: 0.3902 - val_loss: 0.5889 - val_accuracy: 0.8133 - val_one_hot_mean_io_u: 0.4130\n",
      "Epoch 20/150\n",
      "20/20 [==============================] - 18s 849ms/step - loss: 0.6034 - accuracy: 0.8099 - one_hot_mean_io_u: 0.3962 - val_loss: 0.5728 - val_accuracy: 0.8189 - val_one_hot_mean_io_u: 0.3837\n",
      "Epoch 21/150\n",
      "20/20 [==============================] - 18s 820ms/step - loss: 0.5885 - accuracy: 0.8149 - one_hot_mean_io_u: 0.4061 - val_loss: 0.6162 - val_accuracy: 0.8049 - val_one_hot_mean_io_u: 0.3950\n",
      "Epoch 22/150\n",
      "20/20 [==============================] - 18s 822ms/step - loss: 0.5708 - accuracy: 0.8206 - one_hot_mean_io_u: 0.4167 - val_loss: 0.5128 - val_accuracy: 0.8355 - val_one_hot_mean_io_u: 0.4400\n",
      "Epoch 23/150\n",
      "20/20 [==============================] - 17s 785ms/step - loss: 0.5547 - accuracy: 0.8253 - one_hot_mean_io_u: 0.4223 - val_loss: 0.5280 - val_accuracy: 0.8320 - val_one_hot_mean_io_u: 0.4270\n",
      "Epoch 24/150\n",
      "20/20 [==============================] - 17s 781ms/step - loss: 0.5540 - accuracy: 0.8253 - one_hot_mean_io_u: 0.4215 - val_loss: 0.5005 - val_accuracy: 0.8405 - val_one_hot_mean_io_u: 0.4585\n",
      "Epoch 25/150\n",
      "20/20 [==============================] - 18s 812ms/step - loss: 0.5424 - accuracy: 0.8280 - one_hot_mean_io_u: 0.4467 - val_loss: 0.4486 - val_accuracy: 0.8560 - val_one_hot_mean_io_u: 0.4399\n",
      "Epoch 26/150\n",
      "20/20 [==============================] - 17s 774ms/step - loss: 0.5259 - accuracy: 0.8337 - one_hot_mean_io_u: 0.4343 - val_loss: 0.4813 - val_accuracy: 0.8470 - val_one_hot_mean_io_u: 0.4673\n",
      "Epoch 27/150\n",
      "20/20 [==============================] - 17s 803ms/step - loss: 0.5347 - accuracy: 0.8297 - one_hot_mean_io_u: 0.4341 - val_loss: 0.4640 - val_accuracy: 0.8529 - val_one_hot_mean_io_u: 0.4915\n",
      "Epoch 28/150\n",
      "20/20 [==============================] - 17s 775ms/step - loss: 0.5165 - accuracy: 0.8360 - one_hot_mean_io_u: 0.4420 - val_loss: 0.4996 - val_accuracy: 0.8388 - val_one_hot_mean_io_u: 0.4684\n",
      "Epoch 29/150\n",
      "20/20 [==============================] - 17s 774ms/step - loss: 0.4964 - accuracy: 0.8423 - one_hot_mean_io_u: 0.4535 - val_loss: 0.4488 - val_accuracy: 0.8567 - val_one_hot_mean_io_u: 0.4607\n",
      "Epoch 30/150\n",
      "20/20 [==============================] - 17s 788ms/step - loss: 0.5027 - accuracy: 0.8400 - one_hot_mean_io_u: 0.4553 - val_loss: 0.4821 - val_accuracy: 0.8437 - val_one_hot_mean_io_u: 0.4892\n",
      "Epoch 31/150\n",
      "20/20 [==============================] - 17s 789ms/step - loss: 0.4991 - accuracy: 0.8407 - one_hot_mean_io_u: 0.4695 - val_loss: 0.4366 - val_accuracy: 0.8629 - val_one_hot_mean_io_u: 0.4418\n",
      "Epoch 32/150\n",
      "20/20 [==============================] - 18s 804ms/step - loss: 0.4959 - accuracy: 0.8414 - one_hot_mean_io_u: 0.4791 - val_loss: 0.4510 - val_accuracy: 0.8593 - val_one_hot_mean_io_u: 0.4766\n",
      "Epoch 33/150\n",
      "20/20 [==============================] - 17s 789ms/step - loss: 0.4920 - accuracy: 0.8427 - one_hot_mean_io_u: 0.4592 - val_loss: 0.4434 - val_accuracy: 0.8570 - val_one_hot_mean_io_u: 0.5236\n",
      "Epoch 34/150\n",
      "20/20 [==============================] - 18s 808ms/step - loss: 0.4755 - accuracy: 0.8478 - one_hot_mean_io_u: 0.4905 - val_loss: 0.4702 - val_accuracy: 0.8502 - val_one_hot_mean_io_u: 0.4829\n",
      "Epoch 35/150\n",
      "20/20 [==============================] - 17s 785ms/step - loss: 0.4814 - accuracy: 0.8449 - one_hot_mean_io_u: 0.4882 - val_loss: 0.4568 - val_accuracy: 0.8544 - val_one_hot_mean_io_u: 0.4958\n",
      "Epoch 36/150\n",
      "20/20 [==============================] - 18s 791ms/step - loss: 0.4616 - accuracy: 0.8523 - one_hot_mean_io_u: 0.5012 - val_loss: 0.4168 - val_accuracy: 0.8659 - val_one_hot_mean_io_u: 0.4900\n",
      "Epoch 37/150\n",
      "20/20 [==============================] - 18s 836ms/step - loss: 0.4627 - accuracy: 0.8515 - one_hot_mean_io_u: 0.4906 - val_loss: 0.4470 - val_accuracy: 0.8546 - val_one_hot_mean_io_u: 0.4709\n",
      "Epoch 38/150\n",
      "20/20 [==============================] - 18s 808ms/step - loss: 0.4657 - accuracy: 0.8503 - one_hot_mean_io_u: 0.4948 - val_loss: 0.4075 - val_accuracy: 0.8679 - val_one_hot_mean_io_u: 0.4937\n",
      "Epoch 39/150\n",
      "20/20 [==============================] - 18s 811ms/step - loss: 0.4572 - accuracy: 0.8533 - one_hot_mean_io_u: 0.5012 - val_loss: 0.4170 - val_accuracy: 0.8650 - val_one_hot_mean_io_u: 0.4808\n",
      "Epoch 40/150\n",
      "20/20 [==============================] - 18s 816ms/step - loss: 0.4563 - accuracy: 0.8529 - one_hot_mean_io_u: 0.4986 - val_loss: 0.3960 - val_accuracy: 0.8735 - val_one_hot_mean_io_u: 0.5355\n",
      "Epoch 41/150\n",
      "20/20 [==============================] - 17s 778ms/step - loss: 0.4457 - accuracy: 0.8556 - one_hot_mean_io_u: 0.5116 - val_loss: 0.4030 - val_accuracy: 0.8694 - val_one_hot_mean_io_u: 0.5294\n",
      "Epoch 42/150\n",
      "20/20 [==============================] - 18s 814ms/step - loss: 0.4435 - accuracy: 0.8563 - one_hot_mean_io_u: 0.5138 - val_loss: 0.3596 - val_accuracy: 0.8845 - val_one_hot_mean_io_u: 0.5072\n",
      "Epoch 43/150\n",
      "20/20 [==============================] - 17s 801ms/step - loss: 0.4365 - accuracy: 0.8590 - one_hot_mean_io_u: 0.5148 - val_loss: 0.3983 - val_accuracy: 0.8728 - val_one_hot_mean_io_u: 0.5184\n",
      "Epoch 44/150\n",
      "20/20 [==============================] - 18s 803ms/step - loss: 0.4369 - accuracy: 0.8592 - one_hot_mean_io_u: 0.5142 - val_loss: 0.3644 - val_accuracy: 0.8802 - val_one_hot_mean_io_u: 0.5318\n",
      "Epoch 45/150\n",
      "20/20 [==============================] - 17s 794ms/step - loss: 0.4272 - accuracy: 0.8611 - one_hot_mean_io_u: 0.5168 - val_loss: 0.3838 - val_accuracy: 0.8738 - val_one_hot_mean_io_u: 0.5107\n",
      "Epoch 46/150\n",
      "20/20 [==============================] - 18s 809ms/step - loss: 0.4274 - accuracy: 0.8615 - one_hot_mean_io_u: 0.5236 - val_loss: 0.4050 - val_accuracy: 0.8705 - val_one_hot_mean_io_u: 0.5120\n",
      "Epoch 47/150\n",
      "20/20 [==============================] - 17s 796ms/step - loss: 0.4299 - accuracy: 0.8612 - one_hot_mean_io_u: 0.5218 - val_loss: 0.3743 - val_accuracy: 0.8784 - val_one_hot_mean_io_u: 0.5229\n",
      "Epoch 48/150\n",
      "20/20 [==============================] - 19s 859ms/step - loss: 0.4283 - accuracy: 0.8608 - one_hot_mean_io_u: 0.5205 - val_loss: 0.4043 - val_accuracy: 0.8680 - val_one_hot_mean_io_u: 0.5054\n",
      "Epoch 49/150\n",
      "20/20 [==============================] - 19s 859ms/step - loss: 0.4135 - accuracy: 0.8658 - one_hot_mean_io_u: 0.5287 - val_loss: 0.4304 - val_accuracy: 0.8604 - val_one_hot_mean_io_u: 0.5286\n",
      "Epoch 50/150\n",
      "20/20 [==============================] - 35s 2s/step - loss: 0.4177 - accuracy: 0.8638 - one_hot_mean_io_u: 0.5274 - val_loss: 0.3948 - val_accuracy: 0.8734 - val_one_hot_mean_io_u: 0.5491\n"
     ]
    }
   ],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "\n",
    "callbacks = [\n",
    "    # Callback to interrupt the training if the validation loss stops improving:\n",
    "    tf.keras.callbacks.EarlyStopping(patience=8, monitor='val_loss',\n",
    "                                     restore_best_weights=True),\n",
    "    # Callback to log the graph, losses and metrics into TensorBoard:\n",
    "    tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True),\n",
    "    # Callback to save the model  specifying the epoch and val-loss in the filename:\n",
    "    tf.keras.callbacks.ModelCheckpoint(\n",
    "        os.path.join(model_dir, f\"{model_name}.keras\")),\n",
    "]\n",
    "\n",
    "seg_model.compile(optimizer=optimizer, loss=tf.losses.CategoricalCrossentropy(), \n",
    "                    metrics=[\"accuracy\", tf.metrics.OneHotMeanIoU(num_classes=NUM_CLASSES)])\n",
    "\n",
    "history = seg_model.fit(\n",
    "    train_dataset,  epochs=num_epochs,validation_data=test_dataset,\n",
    "    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/3 [==============================] - 4s 1s/step - loss: 0.4122 - accuracy: 0.8684 - one_hot_mean_io_u: 0.5260\n",
      "test_acc=0.8683521151542664\n",
      "test_iou=0.5260190367698669\n"
     ]
    }
   ],
   "source": [
    "seg_model = keras.models.load_model(os.path.join(model_dir, f\"{model_name}.keras\"), safe_mode=False)\n",
    "_, test_acc, test_iou = seg_model.evaluate(test_dataset)\n",
    "\n",
    "print(f\"{test_acc=}\")\n",
    "print(f\"{test_iou=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With data augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network hyper-parameters:\n",
    "batch_size     = 16\n",
    "num_epochs     = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset size: 20\n",
      "Validation dataset size: 3\n",
      "Test dataset size: 3\n"
     ]
    }
   ],
   "source": [
    "# 80% training, 10% validation, and 10% test\n",
    "train_percentage = 0.8\n",
    "val_percentage = 0.1\n",
    "test_percentage = 0.1\n",
    "\n",
    "dataset = tf.data.Dataset.list_files(str(DATASET_PATH + '/*.png'), shuffle=False)\n",
    "\n",
    "# Calculate the sizes for each set\n",
    "dataset_size = len(list(dataset))\n",
    "train_size = int(train_percentage * dataset_size)\n",
    "val_size = int(val_percentage * dataset_size)\n",
    "test_size = dataset_size - train_size - val_size\n",
    "\n",
    "# Split the dataset\n",
    "train_dataset = dataset.take(train_size)\n",
    "val_dataset = dataset.skip(train_size).take(val_size)\n",
    "test_dataset = dataset.skip(train_size + val_size).take(test_size)\n",
    "\n",
    "train_dataset = train_dataset.map(load_image_seg_da,\n",
    "                                  num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_dataset = train_dataset.shuffle(BUFFER_SIZE)\n",
    "train_dataset = train_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Training dataset size:\",train_dataset.cardinality().numpy())\n",
    "\n",
    "val_dataset = val_dataset.map(load_image_seg_da)\n",
    "val_dataset = val_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Validation dataset size:\",val_dataset.cardinality().numpy())\n",
    "\n",
    "test_dataset = test_dataset.map(load_image_seg_da)\n",
    "test_dataset = test_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Test dataset size:\",test_dataset.cardinality().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seg_model = fcn_8s((IMG_WIDTH,IMG_HEIGHT), 3, NUM_CLASSES)\n",
    "\n",
    "log_dir=\"logs_seg/\"\n",
    "\n",
    "model_name = 'TU-Graz_fcn8s_da'\n",
    "model_dir = os.path.join('models', model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/150\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-15 09:35:27.853421: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:961] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inmodel_1/dropout_2/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 23s 980ms/step - loss: 2.4677 - accuracy: 0.3485 - one_hot_mean_io_u_1: 0.0444 - val_loss: 1.7771 - val_accuracy: 0.5133 - val_one_hot_mean_io_u_1: 0.0663\n",
      "Epoch 2/150\n",
      "20/20 [==============================] - 17s 799ms/step - loss: 1.6523 - accuracy: 0.5207 - one_hot_mean_io_u_1: 0.0851 - val_loss: 1.6194 - val_accuracy: 0.5273 - val_one_hot_mean_io_u_1: 0.0986\n",
      "Epoch 3/150\n",
      "20/20 [==============================] - 21s 958ms/step - loss: 1.4189 - accuracy: 0.5905 - one_hot_mean_io_u_1: 0.1125 - val_loss: 1.3983 - val_accuracy: 0.5962 - val_one_hot_mean_io_u_1: 0.1180\n",
      "Epoch 4/150\n",
      "20/20 [==============================] - 21s 963ms/step - loss: 1.3165 - accuracy: 0.6165 - one_hot_mean_io_u_1: 0.1276 - val_loss: 1.2872 - val_accuracy: 0.6203 - val_one_hot_mean_io_u_1: 0.1414\n",
      "Epoch 5/150\n",
      "20/20 [==============================] - 20s 944ms/step - loss: 1.2038 - accuracy: 0.6515 - one_hot_mean_io_u_1: 0.1473 - val_loss: 1.0919 - val_accuracy: 0.6839 - val_one_hot_mean_io_u_1: 0.1548\n",
      "Epoch 6/150\n",
      "20/20 [==============================] - 20s 944ms/step - loss: 1.1038 - accuracy: 0.6747 - one_hot_mean_io_u_1: 0.1594 - val_loss: 1.1211 - val_accuracy: 0.6531 - val_one_hot_mean_io_u_1: 0.1611\n",
      "Epoch 7/150\n",
      "20/20 [==============================] - 20s 947ms/step - loss: 1.0699 - accuracy: 0.6771 - one_hot_mean_io_u_1: 0.1756 - val_loss: 1.0089 - val_accuracy: 0.6969 - val_one_hot_mean_io_u_1: 0.1860\n",
      "Epoch 8/150\n",
      "20/20 [==============================] - 20s 926ms/step - loss: 1.0213 - accuracy: 0.6935 - one_hot_mean_io_u_1: 0.1884 - val_loss: 1.0077 - val_accuracy: 0.7012 - val_one_hot_mean_io_u_1: 0.1987\n",
      "Epoch 9/150\n",
      "20/20 [==============================] - 20s 927ms/step - loss: 1.0005 - accuracy: 0.6971 - one_hot_mean_io_u_1: 0.1945 - val_loss: 0.9861 - val_accuracy: 0.7022 - val_one_hot_mean_io_u_1: 0.1867\n",
      "Epoch 10/150\n",
      "20/20 [==============================] - 20s 941ms/step - loss: 0.9580 - accuracy: 0.7098 - one_hot_mean_io_u_1: 0.2067 - val_loss: 0.9332 - val_accuracy: 0.7226 - val_one_hot_mean_io_u_1: 0.2144\n",
      "Epoch 11/150\n",
      "20/20 [==============================] - 20s 946ms/step - loss: 0.9328 - accuracy: 0.7153 - one_hot_mean_io_u_1: 0.2192 - val_loss: 0.9722 - val_accuracy: 0.7035 - val_one_hot_mean_io_u_1: 0.2285\n",
      "Epoch 12/150\n",
      "20/20 [==============================] - 20s 933ms/step - loss: 0.9391 - accuracy: 0.7141 - one_hot_mean_io_u_1: 0.2239 - val_loss: 1.0035 - val_accuracy: 0.6998 - val_one_hot_mean_io_u_1: 0.2161\n",
      "Epoch 13/150\n",
      "20/20 [==============================] - 16s 725ms/step - loss: 0.9087 - accuracy: 0.7227 - one_hot_mean_io_u_1: 0.2318 - val_loss: 0.9410 - val_accuracy: 0.7120 - val_one_hot_mean_io_u_1: 0.2569\n",
      "Epoch 14/150\n",
      "20/20 [==============================] - 20s 943ms/step - loss: 0.8673 - accuracy: 0.7366 - one_hot_mean_io_u_1: 0.2496 - val_loss: 0.7929 - val_accuracy: 0.7536 - val_one_hot_mean_io_u_1: 0.2689\n",
      "Epoch 15/150\n",
      "20/20 [==============================] - 20s 934ms/step - loss: 0.8456 - accuracy: 0.7432 - one_hot_mean_io_u_1: 0.2539 - val_loss: 0.9066 - val_accuracy: 0.7204 - val_one_hot_mean_io_u_1: 0.2402\n",
      "Epoch 16/150\n",
      "20/20 [==============================] - 20s 944ms/step - loss: 0.8109 - accuracy: 0.7509 - one_hot_mean_io_u_1: 0.2714 - val_loss: 0.7311 - val_accuracy: 0.7796 - val_one_hot_mean_io_u_1: 0.3058\n",
      "Epoch 17/150\n",
      "20/20 [==============================] - 20s 939ms/step - loss: 0.8031 - accuracy: 0.7533 - one_hot_mean_io_u_1: 0.2725 - val_loss: 0.8302 - val_accuracy: 0.7441 - val_one_hot_mean_io_u_1: 0.2688\n",
      "Epoch 18/150\n",
      "20/20 [==============================] - 16s 742ms/step - loss: 0.7826 - accuracy: 0.7576 - one_hot_mean_io_u_1: 0.2854 - val_loss: 0.7258 - val_accuracy: 0.7747 - val_one_hot_mean_io_u_1: 0.2989\n",
      "Epoch 19/150\n",
      "20/20 [==============================] - 18s 839ms/step - loss: 0.7597 - accuracy: 0.7669 - one_hot_mean_io_u_1: 0.2926 - val_loss: 0.7758 - val_accuracy: 0.7570 - val_one_hot_mean_io_u_1: 0.3199\n",
      "Epoch 20/150\n",
      "20/20 [==============================] - 16s 734ms/step - loss: 0.7462 - accuracy: 0.7693 - one_hot_mean_io_u_1: 0.2995 - val_loss: 0.8262 - val_accuracy: 0.7425 - val_one_hot_mean_io_u_1: 0.3014\n",
      "Epoch 21/150\n",
      "20/20 [==============================] - 16s 742ms/step - loss: 0.7341 - accuracy: 0.7734 - one_hot_mean_io_u_1: 0.3047 - val_loss: 0.7099 - val_accuracy: 0.7817 - val_one_hot_mean_io_u_1: 0.3376\n",
      "Epoch 22/150\n",
      "20/20 [==============================] - 16s 724ms/step - loss: 0.7343 - accuracy: 0.7722 - one_hot_mean_io_u_1: 0.3096 - val_loss: 0.6756 - val_accuracy: 0.7859 - val_one_hot_mean_io_u_1: 0.3164\n",
      "Epoch 23/150\n",
      "20/20 [==============================] - 16s 709ms/step - loss: 0.7230 - accuracy: 0.7762 - one_hot_mean_io_u_1: 0.3137 - val_loss: 0.7411 - val_accuracy: 0.7692 - val_one_hot_mean_io_u_1: 0.3126\n",
      "Epoch 24/150\n",
      "20/20 [==============================] - 16s 711ms/step - loss: 0.7041 - accuracy: 0.7830 - one_hot_mean_io_u_1: 0.3138 - val_loss: 0.6935 - val_accuracy: 0.7814 - val_one_hot_mean_io_u_1: 0.3302\n",
      "Epoch 25/150\n",
      "20/20 [==============================] - 15s 701ms/step - loss: 0.6865 - accuracy: 0.7869 - one_hot_mean_io_u_1: 0.3372 - val_loss: 0.7433 - val_accuracy: 0.7705 - val_one_hot_mean_io_u_1: 0.3420\n",
      "Epoch 26/150\n",
      "20/20 [==============================] - 15s 701ms/step - loss: 0.6871 - accuracy: 0.7860 - one_hot_mean_io_u_1: 0.3347 - val_loss: 0.7046 - val_accuracy: 0.7853 - val_one_hot_mean_io_u_1: 0.3446\n",
      "Epoch 27/150\n",
      "20/20 [==============================] - 16s 715ms/step - loss: 0.6748 - accuracy: 0.7901 - one_hot_mean_io_u_1: 0.3327 - val_loss: 0.6301 - val_accuracy: 0.8000 - val_one_hot_mean_io_u_1: 0.3479\n",
      "Epoch 28/150\n",
      "20/20 [==============================] - 16s 713ms/step - loss: 0.6799 - accuracy: 0.7860 - one_hot_mean_io_u_1: 0.3448 - val_loss: 0.6405 - val_accuracy: 0.8006 - val_one_hot_mean_io_u_1: 0.3443\n",
      "Epoch 29/150\n",
      "20/20 [==============================] - 15s 688ms/step - loss: 0.6644 - accuracy: 0.7921 - one_hot_mean_io_u_1: 0.3392 - val_loss: 0.6768 - val_accuracy: 0.7867 - val_one_hot_mean_io_u_1: 0.3560\n",
      "Epoch 30/150\n",
      "20/20 [==============================] - 16s 721ms/step - loss: 0.6498 - accuracy: 0.7975 - one_hot_mean_io_u_1: 0.3484 - val_loss: 0.6045 - val_accuracy: 0.8135 - val_one_hot_mean_io_u_1: 0.3596\n",
      "Epoch 31/150\n",
      "20/20 [==============================] - 16s 725ms/step - loss: 0.6522 - accuracy: 0.7962 - one_hot_mean_io_u_1: 0.3511 - val_loss: 0.6349 - val_accuracy: 0.8021 - val_one_hot_mean_io_u_1: 0.3697\n",
      "Epoch 32/150\n",
      "20/20 [==============================] - 16s 739ms/step - loss: 0.6387 - accuracy: 0.8001 - one_hot_mean_io_u_1: 0.3557 - val_loss: 0.5743 - val_accuracy: 0.8186 - val_one_hot_mean_io_u_1: 0.3839\n",
      "Epoch 33/150\n",
      "20/20 [==============================] - 16s 721ms/step - loss: 0.6388 - accuracy: 0.7999 - one_hot_mean_io_u_1: 0.3633 - val_loss: 0.6757 - val_accuracy: 0.7869 - val_one_hot_mean_io_u_1: 0.3460\n",
      "Epoch 34/150\n",
      "20/20 [==============================] - 15s 688ms/step - loss: 0.6428 - accuracy: 0.7983 - one_hot_mean_io_u_1: 0.3489 - val_loss: 0.6066 - val_accuracy: 0.8114 - val_one_hot_mean_io_u_1: 0.3621\n",
      "Epoch 35/150\n",
      "20/20 [==============================] - 16s 722ms/step - loss: 0.6354 - accuracy: 0.8013 - one_hot_mean_io_u_1: 0.3567 - val_loss: 0.6049 - val_accuracy: 0.8163 - val_one_hot_mean_io_u_1: 0.3941\n",
      "Epoch 36/150\n",
      "20/20 [==============================] - 16s 745ms/step - loss: 0.6281 - accuracy: 0.8038 - one_hot_mean_io_u_1: 0.3629 - val_loss: 0.5233 - val_accuracy: 0.8393 - val_one_hot_mean_io_u_1: 0.3778\n",
      "Epoch 37/150\n",
      "20/20 [==============================] - 16s 730ms/step - loss: 0.6221 - accuracy: 0.8053 - one_hot_mean_io_u_1: 0.3589 - val_loss: 0.6349 - val_accuracy: 0.8037 - val_one_hot_mean_io_u_1: 0.3828\n",
      "Epoch 38/150\n",
      "20/20 [==============================] - 16s 713ms/step - loss: 0.6250 - accuracy: 0.8033 - one_hot_mean_io_u_1: 0.3641 - val_loss: 0.5892 - val_accuracy: 0.8154 - val_one_hot_mean_io_u_1: 0.3932\n",
      "Epoch 39/150\n",
      "20/20 [==============================] - 16s 720ms/step - loss: 0.5971 - accuracy: 0.8133 - one_hot_mean_io_u_1: 0.3715 - val_loss: 0.5491 - val_accuracy: 0.8312 - val_one_hot_mean_io_u_1: 0.4081\n",
      "Epoch 40/150\n",
      "20/20 [==============================] - 16s 718ms/step - loss: 0.6003 - accuracy: 0.8116 - one_hot_mean_io_u_1: 0.3757 - val_loss: 0.5779 - val_accuracy: 0.8151 - val_one_hot_mean_io_u_1: 0.3864\n",
      "Epoch 41/150\n",
      "20/20 [==============================] - 16s 705ms/step - loss: 0.5880 - accuracy: 0.8147 - one_hot_mean_io_u_1: 0.3980 - val_loss: 0.5799 - val_accuracy: 0.8191 - val_one_hot_mean_io_u_1: 0.3948\n",
      "Epoch 42/150\n",
      "20/20 [==============================] - 15s 695ms/step - loss: 0.5826 - accuracy: 0.8158 - one_hot_mean_io_u_1: 0.4035 - val_loss: 0.6132 - val_accuracy: 0.8060 - val_one_hot_mean_io_u_1: 0.4042\n",
      "Epoch 43/150\n",
      "20/20 [==============================] - 15s 701ms/step - loss: 0.5732 - accuracy: 0.8200 - one_hot_mean_io_u_1: 0.3874 - val_loss: 0.6120 - val_accuracy: 0.8099 - val_one_hot_mean_io_u_1: 0.4299\n",
      "Epoch 44/150\n",
      "20/20 [==============================] - 17s 784ms/step - loss: 0.5803 - accuracy: 0.8169 - one_hot_mean_io_u_1: 0.3993 - val_loss: 0.5888 - val_accuracy: 0.8150 - val_one_hot_mean_io_u_1: 0.4090\n"
     ]
    }
   ],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "\n",
    "callbacks = [\n",
    "    # Callback to interrupt the training if the validation loss stops improving:\n",
    "    tf.keras.callbacks.EarlyStopping(patience=8, monitor='val_loss',\n",
    "                                     restore_best_weights=True),\n",
    "    # Callback to log the graph, losses and metrics into TensorBoard:\n",
    "    tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True),\n",
    "    # Callback to save the model  specifying the epoch and val-loss in the filename:\n",
    "    tf.keras.callbacks.ModelCheckpoint(\n",
    "        os.path.join(model_dir, f\"{model_name}.keras\")),\n",
    "]\n",
    "\n",
    "seg_model.compile(optimizer=optimizer, loss=tf.losses.CategoricalCrossentropy(), \n",
    "                    metrics=[\"accuracy\", tf.metrics.OneHotMeanIoU(num_classes=NUM_CLASSES)])\n",
    "\n",
    "history = seg_model.fit(\n",
    "    train_dataset,  epochs=num_epochs,validation_data=val_dataset,\n",
    "    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/3 [==============================] - 2s 212ms/step - loss: 0.7177 - accuracy: 0.7736 - one_hot_mean_io_u_1: 0.3506\n",
      "test_acc=0.7735759615898132\n",
      "test_iou=0.35057541728019714\n"
     ]
    }
   ],
   "source": [
    "seg_model = keras.models.load_model(os.path.join(model_dir, f\"{model_name}.keras\"), safe_mode=False)\n",
    "_, test_acc, test_iou = seg_model.evaluate(test_dataset)\n",
    "\n",
    "print(f\"{test_acc=}\")\n",
    "print(f\"{test_iou=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## U-Net\n",
    "\n",
    "Let's see if we can improve the segmentation performance using a U-net instead of a FCN-8s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network hyper-parameters:\n",
    "batch_size     = 16\n",
    "num_epochs     = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset size: 20\n",
      "Validation dataset size: 3\n",
      "Test dataset size: 3\n"
     ]
    }
   ],
   "source": [
    "# 80% training, 10% validation, and 10% test\n",
    "train_percentage = 0.8\n",
    "val_percentage = 0.1\n",
    "test_percentage = 0.1\n",
    "\n",
    "dataset = tf.data.Dataset.list_files(str(DATASET_PATH + '/*.png'), shuffle=False)\n",
    "\n",
    "# Calculate the sizes for each set\n",
    "dataset_size = len(list(dataset))\n",
    "train_size = int(train_percentage * dataset_size)\n",
    "val_size = int(val_percentage * dataset_size)\n",
    "test_size = dataset_size - train_size - val_size\n",
    "\n",
    "# Split the dataset\n",
    "train_dataset = dataset.take(train_size)\n",
    "val_dataset = dataset.skip(train_size).take(val_size)\n",
    "test_dataset = dataset.skip(train_size + val_size).take(test_size)\n",
    "\n",
    "train_dataset = train_dataset.map(load_image_seg,\n",
    "                                  num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_dataset = train_dataset.shuffle(BUFFER_SIZE)\n",
    "train_dataset = train_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Training dataset size:\",train_dataset.cardinality().numpy())\n",
    "\n",
    "val_dataset = val_dataset.map(load_image_seg)\n",
    "val_dataset = val_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Validation dataset size:\",val_dataset.cardinality().numpy())\n",
    "\n",
    "test_dataset = test_dataset.map(load_image_seg)\n",
    "test_dataset = test_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Test dataset size:\",test_dataset.cardinality().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unet_conv_block(x, filters, kernel_size=3, batch_norm=True, dropout=False,\n",
    "                    name_prefix=\"enc_\", name_suffix=0):\n",
    "    \"\"\"\n",
    "    Pass the input tensor through 2 Conv layers with LeakyReLU activation + opt. through\n",
    "    BatchNorm and Dropout layers.\n",
    "    :param x:                       Input tensor.\n",
    "    :param filters:                 Number of filters.\n",
    "    :param kernel_size:             Kernel size.\n",
    "    :param batch_norm:              Flag to apply batch normalization.\n",
    "    :param dropout:                 Flag to apply dropout.\n",
    "    :param name_prefix:             Prefix for the layers' names.\n",
    "    :param name_suffix:             Suffix for the layers' names.\n",
    "    :return:                        Transformed tensor.\n",
    "    \"\"\"\n",
    "    name_fn = lambda layer, num: '{}{}{}-{}'.format(name_prefix, layer, name_suffix, num)\n",
    "\n",
    "    # First convolution:\n",
    "    x = Conv2D(filters, kernel_size=kernel_size, activation=None,\n",
    "               kernel_initializer='he_normal', padding='same',\n",
    "               name=name_fn('conv', 1))(x)\n",
    "    if batch_norm:\n",
    "        x = BatchNormalization(name=name_fn('bn', 1))(x)\n",
    "    x = LeakyReLU(alpha=0.3, name=name_fn('act', 1))(x)\n",
    "    if dropout:\n",
    "        x = Dropout(0.2, name=name_fn('drop', 1))(x)\n",
    "\n",
    "    # Second convolution:\n",
    "    x = Conv2D(filters, kernel_size=kernel_size, activation=None,\n",
    "               kernel_initializer='he_normal', padding='same',\n",
    "               name=name_fn('conv', 2))(x)\n",
    "    if batch_norm:\n",
    "        x = BatchNormalization(name=name_fn('bn', 2))(x)\n",
    "    x = LeakyReLU(alpha=0.3, name=name_fn('act', 2))(x)\n",
    "\n",
    "    return x\n",
    "\n",
    "\n",
    "def unet_deconv_block(x, filters, kernel_size=2, strides=2, batch_norm=True, dropout=False,\n",
    "                      name_prefix=\"dec_\", name_suffix=0):\n",
    "    \"\"\"\n",
    "    Pass the input tensor through 1 Conv layer and 1 transposed (de)Conv layer with LeakyReLU\n",
    "    activation + opt. through BatchNorm and Dropout layers.\n",
    "    :param x:                       Input tensor.\n",
    "    :param filters:                 Number of filters.\n",
    "    :param kernel_size:             Kernel size.\n",
    "    :param strides:                 Strides for transposed convolution.\n",
    "    :param batch_norm:              Flag to apply batch normalization.\n",
    "    :param dropout:                 Flag to apply dropout.\n",
    "    :param name_prefix:             Prefix for the layers' names.\n",
    "    :param name_suffix:             Suffix for the layers' names.\n",
    "    :return:                        Transformed tensor.\n",
    "    \"\"\"\n",
    "    name_fn = lambda layer, num: '{}{}{}-{}'.format(name_prefix, layer, name_suffix, num)\n",
    "\n",
    "    # First convolution:\n",
    "    x = Conv2D(filters, kernel_size=kernel_size, activation=None,\n",
    "               kernel_initializer='he_normal', padding='same',\n",
    "               name=name_fn('conv', 1))(x)\n",
    "    if batch_norm:\n",
    "        x = BatchNormalization(name=name_fn('bn', 1))(x)\n",
    "    x = LeakyReLU(alpha=0.3, name=name_fn('act', 1))(x)\n",
    "    if dropout:\n",
    "        x = Dropout(0.2, name=name_fn('drop', 1))(x)\n",
    "\n",
    "    # Second (de)convolution:\n",
    "    x = Conv2DTranspose(filters, kernel_size=kernel_size, strides=strides,\n",
    "                        activation=None, kernel_initializer='he_normal',\n",
    "                        padding='same', name=name_fn('conv', 2))(x)\n",
    "    if batch_norm:\n",
    "        x = BatchNormalization(name=name_fn('bn', 2))(x)\n",
    "    x = LeakyReLU(alpha=0.3, name=name_fn('act', 2))(x)\n",
    "\n",
    "    return x\n",
    "\n",
    "\n",
    "# As the dimensions of our images may not be normalized/even, it is possible that after \n",
    "# downsampling and upsampling, we do not reobtain the original size (with a difference \n",
    "# of +/- 1px).\n",
    "# To avoid the problems this may cause, we define a layer to slightly resize the generated\n",
    "# image to the dimensions of the target one:\n",
    "ResizeToSame = lambda name: Lambda(\n",
    "    lambda images: tf.image.resize(images[0], tf.shape(images[1])[1:3]),\n",
    "    # `images` is a tuple of 2 tensors.\n",
    "    # We resize the first image tensor to the shape of the 2nd\n",
    "    name=name)\n",
    "\n",
    "\n",
    "def unet(x, out_channels=3, layer_depth=4, filters_orig=32, kernel_size=4,\n",
    "         batch_norm=True, final_activation='sigmoid'):\n",
    "    \"\"\"\n",
    "    Pass the tensor through a trainable UNet.\n",
    "    :param x:                       Input tensor.\n",
    "    :param out_channels:            Number of output channels.\n",
    "    :param layer_depth:             Number of convolutional blocks vertically stacked.\n",
    "    :param filters_orig:            Number of filters for the 1st block (then multiplied by 2 \n",
    "                                    every block).\n",
    "    :param kernel_size:             Kernel size for layers.\n",
    "    :param batch_norm:              Flag to apply batch normalization.\n",
    "    :param final_activation:        Name/function for the last activation.\n",
    "    :return:                        Output tensor.\n",
    "    \"\"\"\n",
    "    # Encoding layers:\n",
    "    filters = filters_orig\n",
    "    outputs_for_skip = []\n",
    "    for i in range(layer_depth):\n",
    "        conv_block = unet_conv_block(x, filters, kernel_size,\n",
    "                                     batch_norm=batch_norm, name_suffix=i)\n",
    "        outputs_for_skip.append(conv_block)\n",
    "\n",
    "        x = MaxPooling2D(2)(conv_block)\n",
    "\n",
    "        filters = min(filters * 2, 512)\n",
    "\n",
    "    # Bottleneck layers:\n",
    "    x = unet_conv_block(x, filters, kernel_size, name_suffix='btleneck')\n",
    "\n",
    "    # Decoding layers:\n",
    "    for i in range(layer_depth):\n",
    "        filters = max(filters // 2, filters_orig)\n",
    "\n",
    "        use_dropout = i < (layer_depth - 2)\n",
    "        deconv_block = unet_deconv_block(x, filters, kernel_size,\n",
    "                                         batch_norm=batch_norm,\n",
    "                                         dropout=use_dropout, name_suffix=i)\n",
    "\n",
    "        shortcut = outputs_for_skip[-(i + 1)]\n",
    "        deconv_block = ResizeToSame(\n",
    "            name='resize_to_same{}'.format(i))([deconv_block, shortcut])\n",
    "\n",
    "        x = concatenate([deconv_block, shortcut], axis=-1,\n",
    "                        name='dec_conc{}'.format(i))\n",
    "\n",
    "    x = Conv2D(filters=filters, kernel_size=kernel_size, activation='relu',\n",
    "               padding='same', name='dec_out1')(x)\n",
    "    x = Dropout(0.3, name='drop_out1')(x)\n",
    "    x = Conv2D(filters=filters, kernel_size=kernel_size, activation='relu',\n",
    "               padding='same', name='dec_out2')(x)\n",
    "    x = Dropout(0.3, name='drop_out2')(x)\n",
    "    x = Conv2D(filters=out_channels, kernel_size=1, activation=final_activation,\n",
    "               padding='same', name='dec_output')(x)\n",
    "\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_4\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input (InputLayer)          [(None, 256, 256, 3)]        0         []                            \n",
      "                                                                                                  \n",
      " enc_conv0-1 (Conv2D)        (None, 256, 256, 32)         1568      ['input[0][0]']               \n",
      "                                                                                                  \n",
      " enc_bn0-1 (BatchNormalizat  (None, 256, 256, 32)         128       ['enc_conv0-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act0-1 (LeakyReLU)      (None, 256, 256, 32)         0         ['enc_bn0-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv0-2 (Conv2D)        (None, 256, 256, 32)         16416     ['enc_act0-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn0-2 (BatchNormalizat  (None, 256, 256, 32)         128       ['enc_conv0-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act0-2 (LeakyReLU)      (None, 256, 256, 32)         0         ['enc_bn0-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_7 (MaxPoolin  (None, 128, 128, 32)         0         ['enc_act0-2[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " enc_conv1-1 (Conv2D)        (None, 128, 128, 64)         32832     ['max_pooling2d_7[0][0]']     \n",
      "                                                                                                  \n",
      " enc_bn1-1 (BatchNormalizat  (None, 128, 128, 64)         256       ['enc_conv1-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act1-1 (LeakyReLU)      (None, 128, 128, 64)         0         ['enc_bn1-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv1-2 (Conv2D)        (None, 128, 128, 64)         65600     ['enc_act1-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn1-2 (BatchNormalizat  (None, 128, 128, 64)         256       ['enc_conv1-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act1-2 (LeakyReLU)      (None, 128, 128, 64)         0         ['enc_bn1-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_8 (MaxPoolin  (None, 64, 64, 64)           0         ['enc_act1-2[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " enc_conv2-1 (Conv2D)        (None, 64, 64, 128)          131200    ['max_pooling2d_8[0][0]']     \n",
      "                                                                                                  \n",
      " enc_bn2-1 (BatchNormalizat  (None, 64, 64, 128)          512       ['enc_conv2-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act2-1 (LeakyReLU)      (None, 64, 64, 128)          0         ['enc_bn2-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv2-2 (Conv2D)        (None, 64, 64, 128)          262272    ['enc_act2-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn2-2 (BatchNormalizat  (None, 64, 64, 128)          512       ['enc_conv2-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act2-2 (LeakyReLU)      (None, 64, 64, 128)          0         ['enc_bn2-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_9 (MaxPoolin  (None, 32, 32, 128)          0         ['enc_act2-2[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " enc_convbtleneck-1 (Conv2D  (None, 32, 32, 256)          524544    ['max_pooling2d_9[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " enc_bnbtleneck-1 (BatchNor  (None, 32, 32, 256)          1024      ['enc_convbtleneck-1[0][0]']  \n",
      " malization)                                                                                      \n",
      "                                                                                                  \n",
      " enc_actbtleneck-1 (LeakyRe  (None, 32, 32, 256)          0         ['enc_bnbtleneck-1[0][0]']    \n",
      " LU)                                                                                              \n",
      "                                                                                                  \n",
      " enc_convbtleneck-2 (Conv2D  (None, 32, 32, 256)          1048832   ['enc_actbtleneck-1[0][0]']   \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " enc_bnbtleneck-2 (BatchNor  (None, 32, 32, 256)          1024      ['enc_convbtleneck-2[0][0]']  \n",
      " malization)                                                                                      \n",
      "                                                                                                  \n",
      " enc_actbtleneck-2 (LeakyRe  (None, 32, 32, 256)          0         ['enc_bnbtleneck-2[0][0]']    \n",
      " LU)                                                                                              \n",
      "                                                                                                  \n",
      " dec_conv0-1 (Conv2D)        (None, 32, 32, 128)          524416    ['enc_actbtleneck-2[0][0]']   \n",
      "                                                                                                  \n",
      " dec_bn0-1 (BatchNormalizat  (None, 32, 32, 128)          512       ['dec_conv0-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act0-1 (LeakyReLU)      (None, 32, 32, 128)          0         ['dec_bn0-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_drop0-1 (Dropout)       (None, 32, 32, 128)          0         ['dec_act0-1[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv0-2 (Conv2DTranspo  (None, 64, 64, 128)          262272    ['dec_drop0-1[0][0]']         \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn0-2 (BatchNormalizat  (None, 64, 64, 128)          512       ['dec_conv0-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act0-2 (LeakyReLU)      (None, 64, 64, 128)          0         ['dec_bn0-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same0 (Lambda)    (None, 64, 64, 128)          0         ['dec_act0-2[0][0]',          \n",
      "                                                                     'enc_act2-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc0 (Concatenate)     (None, 64, 64, 256)          0         ['resize_to_same0[0][0]',     \n",
      "                                                                     'enc_act2-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv1-1 (Conv2D)        (None, 64, 64, 64)           262208    ['dec_conc0[0][0]']           \n",
      "                                                                                                  \n",
      " dec_bn1-1 (BatchNormalizat  (None, 64, 64, 64)           256       ['dec_conv1-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act1-1 (LeakyReLU)      (None, 64, 64, 64)           0         ['dec_bn1-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_conv1-2 (Conv2DTranspo  (None, 128, 128, 64)         65600     ['dec_act1-1[0][0]']          \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn1-2 (BatchNormalizat  (None, 128, 128, 64)         256       ['dec_conv1-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act1-2 (LeakyReLU)      (None, 128, 128, 64)         0         ['dec_bn1-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same1 (Lambda)    (None, 128, 128, 64)         0         ['dec_act1-2[0][0]',          \n",
      "                                                                     'enc_act1-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc1 (Concatenate)     (None, 128, 128, 128)        0         ['resize_to_same1[0][0]',     \n",
      "                                                                     'enc_act1-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv2-1 (Conv2D)        (None, 128, 128, 32)         65568     ['dec_conc1[0][0]']           \n",
      "                                                                                                  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " dec_bn2-1 (BatchNormalizat  (None, 128, 128, 32)         128       ['dec_conv2-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act2-1 (LeakyReLU)      (None, 128, 128, 32)         0         ['dec_bn2-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_conv2-2 (Conv2DTranspo  (None, 256, 256, 32)         16416     ['dec_act2-1[0][0]']          \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn2-2 (BatchNormalizat  (None, 256, 256, 32)         128       ['dec_conv2-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act2-2 (LeakyReLU)      (None, 256, 256, 32)         0         ['dec_bn2-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same2 (Lambda)    (None, 256, 256, 32)         0         ['dec_act2-2[0][0]',          \n",
      "                                                                     'enc_act0-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc2 (Concatenate)     (None, 256, 256, 64)         0         ['resize_to_same2[0][0]',     \n",
      "                                                                     'enc_act0-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_out1 (Conv2D)           (None, 256, 256, 32)         32800     ['dec_conc2[0][0]']           \n",
      "                                                                                                  \n",
      " drop_out1 (Dropout)         (None, 256, 256, 32)         0         ['dec_out1[0][0]']            \n",
      "                                                                                                  \n",
      " dec_out2 (Conv2D)           (None, 256, 256, 32)         16416     ['drop_out1[0][0]']           \n",
      "                                                                                                  \n",
      " drop_out2 (Dropout)         (None, 256, 256, 32)         0         ['dec_out2[0][0]']            \n",
      "                                                                                                  \n",
      " dec_output (Conv2D)         (None, 256, 256, 24)         792       ['drop_out2[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 3335384 (12.72 MB)\n",
      "Trainable params: 3332568 (12.71 MB)\n",
      "Non-trainable params: 2816 (11.00 KB)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Network hyper-parameters:\n",
    "kernel_size    = 4\n",
    "filters_orig   = 32\n",
    "layer_depth    = 3\n",
    "use_batch_norm = batch_size > 1\n",
    "\n",
    "inputs = Input(shape=(256, 256, 3), name='input')\n",
    "outputs = unet(inputs, out_channels=NUM_CLASSES, \n",
    "               layer_depth=layer_depth, filters_orig=filters_orig, \n",
    "               kernel_size=kernel_size, batch_norm=use_batch_norm,\n",
    "               final_activation=\"softmax\" # we define our U-Net to output logits.\n",
    "              )\n",
    "\n",
    "seg_model = Model(inputs, outputs)\n",
    "\n",
    "seg_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),\n",
    "                  loss=\"categorical_crossentropy\",\n",
    "                  metrics=[\"accuracy\", tf.metrics.OneHotMeanIoU(num_classes=NUM_CLASSES)])\n",
    "\n",
    "seg_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'TU-Graz_unet'\n",
    "model_dir = os.path.join('models', model_name)\n",
    "\n",
    "log_dir=\"logs_seg/\"\n",
    "\n",
    "callbacks = [\n",
    "    # Callback to interrupt the training if the validation loss stops improving:\n",
    "    tf.keras.callbacks.EarlyStopping(patience=8, monitor='val_loss',\n",
    "                                     restore_best_weights=True),\n",
    "    # Callback to log the graph, losses and metrics into TensorBoard:\n",
    "    tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True),\n",
    "    # Callback to save the model  specifying the epoch and val-loss in the filename:\n",
    "    tf.keras.callbacks.ModelCheckpoint(\n",
    "        os.path.join(model_dir, f\"{model_name}.keras\")),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/150\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-14 14:37:00.732436: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:961] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inmodel_4/dec_drop0-1/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "320/320 [==============================] - 22s 45ms/step - loss: 2.1673 - accuracy: 0.4130 - one_hot_mean_io_u_2: 0.0459 - val_loss: 1.5053 - val_accuracy: 0.5532 - val_one_hot_mean_io_u_2: 0.0582\n",
      "Epoch 2/150\n",
      "320/320 [==============================] - 16s 43ms/step - loss: 1.7602 - accuracy: 0.5061 - one_hot_mean_io_u_2: 0.0697 - val_loss: 1.4061 - val_accuracy: 0.5960 - val_one_hot_mean_io_u_2: 0.0863\n",
      "Epoch 3/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.5976 - accuracy: 0.5539 - one_hot_mean_io_u_2: 0.0853 - val_loss: 1.4923 - val_accuracy: 0.5376 - val_one_hot_mean_io_u_2: 0.0808\n",
      "Epoch 4/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.4420 - accuracy: 0.6002 - one_hot_mean_io_u_2: 0.0985 - val_loss: 1.4617 - val_accuracy: 0.5880 - val_one_hot_mean_io_u_2: 0.1021\n",
      "Epoch 5/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.3722 - accuracy: 0.6195 - one_hot_mean_io_u_2: 0.1088 - val_loss: 1.6932 - val_accuracy: 0.4895 - val_one_hot_mean_io_u_2: 0.0870\n",
      "Epoch 6/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.3066 - accuracy: 0.6380 - one_hot_mean_io_u_2: 0.1194 - val_loss: 1.4500 - val_accuracy: 0.5788 - val_one_hot_mean_io_u_2: 0.0982\n",
      "Epoch 7/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.2223 - accuracy: 0.6603 - one_hot_mean_io_u_2: 0.1289 - val_loss: 1.2759 - val_accuracy: 0.5943 - val_one_hot_mean_io_u_2: 0.0924\n",
      "Epoch 8/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.1727 - accuracy: 0.6713 - one_hot_mean_io_u_2: 0.1414 - val_loss: 1.3664 - val_accuracy: 0.6104 - val_one_hot_mean_io_u_2: 0.1212\n",
      "Epoch 9/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.1138 - accuracy: 0.6904 - one_hot_mean_io_u_2: 0.1600 - val_loss: 1.4890 - val_accuracy: 0.5707 - val_one_hot_mean_io_u_2: 0.1157\n",
      "Epoch 10/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.0842 - accuracy: 0.6940 - one_hot_mean_io_u_2: 0.1669 - val_loss: 1.5973 - val_accuracy: 0.5111 - val_one_hot_mean_io_u_2: 0.1050\n",
      "Epoch 11/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.0629 - accuracy: 0.6978 - one_hot_mean_io_u_2: 0.1754 - val_loss: 1.9135 - val_accuracy: 0.5147 - val_one_hot_mean_io_u_2: 0.1099\n",
      "Epoch 12/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 1.0424 - accuracy: 0.7063 - one_hot_mean_io_u_2: 0.1801 - val_loss: 1.4317 - val_accuracy: 0.5544 - val_one_hot_mean_io_u_2: 0.1151\n",
      "Epoch 13/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 0.9631 - accuracy: 0.7270 - one_hot_mean_io_u_2: 0.1934 - val_loss: 1.3236 - val_accuracy: 0.6002 - val_one_hot_mean_io_u_2: 0.1326\n",
      "Epoch 14/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 0.9304 - accuracy: 0.7374 - one_hot_mean_io_u_2: 0.1973 - val_loss: 1.3589 - val_accuracy: 0.5985 - val_one_hot_mean_io_u_2: 0.1320\n",
      "Epoch 15/150\n",
      "320/320 [==============================] - 15s 43ms/step - loss: 0.9453 - accuracy: 0.7319 - one_hot_mean_io_u_2: 0.1994 - val_loss: 1.2983 - val_accuracy: 0.5995 - val_one_hot_mean_io_u_2: 0.1381\n"
     ]
    }
   ],
   "source": [
    "history = seg_model.fit(\n",
    "    train_dataset,  epochs=num_epochs,validation_data=val_dataset,\n",
    "    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40/40 [==============================] - 2s 20ms/step - loss: 1.5587 - accuracy: 0.5486 - one_hot_mean_io_u: 0.1002\n",
      "test_acc=0.5486301183700562\n",
      "test_iou=0.10022569447755814\n"
     ]
    }
   ],
   "source": [
    "seg_model = keras.models.load_model(os.path.join(model_dir, f\"{model_name}.keras\"), safe_mode=False)\n",
    "_, test_acc, test_iou = seg_model.evaluate(test_dataset)\n",
    "\n",
    "print(f\"{test_acc=}\")\n",
    "print(f\"{test_iou=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network hyper-parameters:\n",
    "batch_size     = 16\n",
    "num_epochs     = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset size: 20\n",
      "Validation dataset size: 3\n",
      "Test dataset size: 3\n"
     ]
    }
   ],
   "source": [
    "# Split the dataset\n",
    "train_dataset = dataset.take(train_size)\n",
    "val_dataset = dataset.skip(train_size).take(val_size)\n",
    "test_dataset = dataset.skip(train_size + val_size).take(test_size)\n",
    "\n",
    "train_dataset = train_dataset.map(load_image_seg_da,\n",
    "                                  num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_dataset = train_dataset.shuffle(BUFFER_SIZE)\n",
    "train_dataset = train_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Training dataset size:\",train_dataset.cardinality().numpy())\n",
    "\n",
    "val_dataset = val_dataset.map(load_image_seg_da)\n",
    "val_dataset = val_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Validation dataset size:\",val_dataset.cardinality().numpy())\n",
    "\n",
    "test_dataset = test_dataset.map(load_image_seg_da)\n",
    "test_dataset = test_dataset.batch(batch_size)\n",
    "\n",
    "print(\"Test dataset size:\",test_dataset.cardinality().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_7\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input (InputLayer)          [(None, 256, 256, 3)]        0         []                            \n",
      "                                                                                                  \n",
      " enc_conv0-1 (Conv2D)        (None, 256, 256, 32)         1568      ['input[0][0]']               \n",
      "                                                                                                  \n",
      " enc_bn0-1 (BatchNormalizat  (None, 256, 256, 32)         128       ['enc_conv0-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act0-1 (LeakyReLU)      (None, 256, 256, 32)         0         ['enc_bn0-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv0-2 (Conv2D)        (None, 256, 256, 32)         16416     ['enc_act0-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn0-2 (BatchNormalizat  (None, 256, 256, 32)         128       ['enc_conv0-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act0-2 (LeakyReLU)      (None, 256, 256, 32)         0         ['enc_bn0-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_16 (MaxPooli  (None, 128, 128, 32)         0         ['enc_act0-2[0][0]']          \n",
      " ng2D)                                                                                            \n",
      "                                                                                                  \n",
      " enc_conv1-1 (Conv2D)        (None, 128, 128, 64)         32832     ['max_pooling2d_16[0][0]']    \n",
      "                                                                                                  \n",
      " enc_bn1-1 (BatchNormalizat  (None, 128, 128, 64)         256       ['enc_conv1-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act1-1 (LeakyReLU)      (None, 128, 128, 64)         0         ['enc_bn1-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv1-2 (Conv2D)        (None, 128, 128, 64)         65600     ['enc_act1-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn1-2 (BatchNormalizat  (None, 128, 128, 64)         256       ['enc_conv1-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act1-2 (LeakyReLU)      (None, 128, 128, 64)         0         ['enc_bn1-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_17 (MaxPooli  (None, 64, 64, 64)           0         ['enc_act1-2[0][0]']          \n",
      " ng2D)                                                                                            \n",
      "                                                                                                  \n",
      " enc_conv2-1 (Conv2D)        (None, 64, 64, 128)          131200    ['max_pooling2d_17[0][0]']    \n",
      "                                                                                                  \n",
      " enc_bn2-1 (BatchNormalizat  (None, 64, 64, 128)          512       ['enc_conv2-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act2-1 (LeakyReLU)      (None, 64, 64, 128)          0         ['enc_bn2-1[0][0]']           \n",
      "                                                                                                  \n",
      " enc_conv2-2 (Conv2D)        (None, 64, 64, 128)          262272    ['enc_act2-1[0][0]']          \n",
      "                                                                                                  \n",
      " enc_bn2-2 (BatchNormalizat  (None, 64, 64, 128)          512       ['enc_conv2-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " enc_act2-2 (LeakyReLU)      (None, 64, 64, 128)          0         ['enc_bn2-2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_18 (MaxPooli  (None, 32, 32, 128)          0         ['enc_act2-2[0][0]']          \n",
      " ng2D)                                                                                            \n",
      "                                                                                                  \n",
      " enc_convbtleneck-1 (Conv2D  (None, 32, 32, 256)          524544    ['max_pooling2d_18[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " enc_bnbtleneck-1 (BatchNor  (None, 32, 32, 256)          1024      ['enc_convbtleneck-1[0][0]']  \n",
      " malization)                                                                                      \n",
      "                                                                                                  \n",
      " enc_actbtleneck-1 (LeakyRe  (None, 32, 32, 256)          0         ['enc_bnbtleneck-1[0][0]']    \n",
      " LU)                                                                                              \n",
      "                                                                                                  \n",
      " enc_convbtleneck-2 (Conv2D  (None, 32, 32, 256)          1048832   ['enc_actbtleneck-1[0][0]']   \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " enc_bnbtleneck-2 (BatchNor  (None, 32, 32, 256)          1024      ['enc_convbtleneck-2[0][0]']  \n",
      " malization)                                                                                      \n",
      "                                                                                                  \n",
      " enc_actbtleneck-2 (LeakyRe  (None, 32, 32, 256)          0         ['enc_bnbtleneck-2[0][0]']    \n",
      " LU)                                                                                              \n",
      "                                                                                                  \n",
      " dec_conv0-1 (Conv2D)        (None, 32, 32, 128)          524416    ['enc_actbtleneck-2[0][0]']   \n",
      "                                                                                                  \n",
      " dec_bn0-1 (BatchNormalizat  (None, 32, 32, 128)          512       ['dec_conv0-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act0-1 (LeakyReLU)      (None, 32, 32, 128)          0         ['dec_bn0-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_drop0-1 (Dropout)       (None, 32, 32, 128)          0         ['dec_act0-1[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv0-2 (Conv2DTranspo  (None, 64, 64, 128)          262272    ['dec_drop0-1[0][0]']         \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn0-2 (BatchNormalizat  (None, 64, 64, 128)          512       ['dec_conv0-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act0-2 (LeakyReLU)      (None, 64, 64, 128)          0         ['dec_bn0-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same0 (Lambda)    (None, 64, 64, 128)          0         ['dec_act0-2[0][0]',          \n",
      "                                                                     'enc_act2-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc0 (Concatenate)     (None, 64, 64, 256)          0         ['resize_to_same0[0][0]',     \n",
      "                                                                     'enc_act2-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv1-1 (Conv2D)        (None, 64, 64, 64)           262208    ['dec_conc0[0][0]']           \n",
      "                                                                                                  \n",
      " dec_bn1-1 (BatchNormalizat  (None, 64, 64, 64)           256       ['dec_conv1-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act1-1 (LeakyReLU)      (None, 64, 64, 64)           0         ['dec_bn1-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_conv1-2 (Conv2DTranspo  (None, 128, 128, 64)         65600     ['dec_act1-1[0][0]']          \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn1-2 (BatchNormalizat  (None, 128, 128, 64)         256       ['dec_conv1-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act1-2 (LeakyReLU)      (None, 128, 128, 64)         0         ['dec_bn1-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same1 (Lambda)    (None, 128, 128, 64)         0         ['dec_act1-2[0][0]',          \n",
      "                                                                     'enc_act1-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc1 (Concatenate)     (None, 128, 128, 128)        0         ['resize_to_same1[0][0]',     \n",
      "                                                                     'enc_act1-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conv2-1 (Conv2D)        (None, 128, 128, 32)         65568     ['dec_conc1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_bn2-1 (BatchNormalizat  (None, 128, 128, 32)         128       ['dec_conv2-1[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act2-1 (LeakyReLU)      (None, 128, 128, 32)         0         ['dec_bn2-1[0][0]']           \n",
      "                                                                                                  \n",
      " dec_conv2-2 (Conv2DTranspo  (None, 256, 256, 32)         16416     ['dec_act2-1[0][0]']          \n",
      " se)                                                                                              \n",
      "                                                                                                  \n",
      " dec_bn2-2 (BatchNormalizat  (None, 256, 256, 32)         128       ['dec_conv2-2[0][0]']         \n",
      " ion)                                                                                             \n",
      "                                                                                                  \n",
      " dec_act2-2 (LeakyReLU)      (None, 256, 256, 32)         0         ['dec_bn2-2[0][0]']           \n",
      "                                                                                                  \n",
      " resize_to_same2 (Lambda)    (None, 256, 256, 32)         0         ['dec_act2-2[0][0]',          \n",
      "                                                                     'enc_act0-2[0][0]']          \n",
      "                                                                                                  \n",
      " dec_conc2 (Concatenate)     (None, 256, 256, 64)         0         ['resize_to_same2[0][0]',     \n",
      "                                                                     'enc_act0-2[0][0]']          \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                                                  \n",
      " dec_out1 (Conv2D)           (None, 256, 256, 32)         32800     ['dec_conc2[0][0]']           \n",
      "                                                                                                  \n",
      " drop_out1 (Dropout)         (None, 256, 256, 32)         0         ['dec_out1[0][0]']            \n",
      "                                                                                                  \n",
      " dec_out2 (Conv2D)           (None, 256, 256, 32)         16416     ['drop_out1[0][0]']           \n",
      "                                                                                                  \n",
      " drop_out2 (Dropout)         (None, 256, 256, 32)         0         ['dec_out2[0][0]']            \n",
      "                                                                                                  \n",
      " dec_output (Conv2D)         (None, 256, 256, 24)         792       ['drop_out2[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 3335384 (12.72 MB)\n",
      "Trainable params: 3332568 (12.71 MB)\n",
      "Non-trainable params: 2816 (11.00 KB)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Network hyper-parameters:\n",
    "kernel_size    = 4\n",
    "filters_orig   = 32\n",
    "layer_depth    = 3\n",
    "use_batch_norm = batch_size > 1\n",
    "\n",
    "inputs = Input(shape=(256, 256, 3), name='input')\n",
    "outputs = unet(inputs, out_channels=NUM_CLASSES, \n",
    "               layer_depth=layer_depth, filters_orig=filters_orig, \n",
    "               kernel_size=kernel_size, batch_norm=use_batch_norm,\n",
    "               final_activation=\"softmax\" # we define our U-Net to output logits.\n",
    "              )\n",
    "\n",
    "seg_model = Model(inputs, outputs)\n",
    "\n",
    "seg_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),\n",
    "                  loss=\"categorical_crossentropy\",\n",
    "                  metrics=[\"accuracy\", tf.metrics.OneHotMeanIoU(num_classes=NUM_CLASSES)])\n",
    "\n",
    "seg_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'TU-Graz_unet_da'\n",
    "model_dir = os.path.join('models', model_name)\n",
    "\n",
    "log_dir=\"logs_seg/\"\n",
    "\n",
    "callbacks = [\n",
    "    # Callback to interrupt the training if the validation loss stops improving:\n",
    "    tf.keras.callbacks.EarlyStopping(patience=8, monitor='val_loss',\n",
    "                                     restore_best_weights=True),\n",
    "    # Callback to log the graph, losses and metrics into TensorBoard:\n",
    "    tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True),\n",
    "    # Callback to save the model  specifying the epoch and val-loss in the filename:\n",
    "    tf.keras.callbacks.ModelCheckpoint(\n",
    "        os.path.join(model_dir, f\"{model_name}.keras\")),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/150\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-14 15:09:04.774660: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:961] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inmodel_7/dec_drop0-1/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "320/320 [==============================] - 22s 46ms/step - loss: 2.1209 - accuracy: 0.4173 - one_hot_mean_io_u_5: 0.0443 - val_loss: 1.5705 - val_accuracy: 0.5926 - val_one_hot_mean_io_u_5: 0.0578\n",
      "Epoch 2/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.7568 - accuracy: 0.5122 - one_hot_mean_io_u_5: 0.0631 - val_loss: 1.5219 - val_accuracy: 0.5665 - val_one_hot_mean_io_u_5: 0.0754\n",
      "Epoch 3/150\n",
      "320/320 [==============================] - 16s 44ms/step - loss: 1.5992 - accuracy: 0.5541 - one_hot_mean_io_u_5: 0.0758 - val_loss: 1.5331 - val_accuracy: 0.5508 - val_one_hot_mean_io_u_5: 0.0779\n",
      "Epoch 4/150\n",
      "320/320 [==============================] - 16s 44ms/step - loss: 1.4696 - accuracy: 0.5859 - one_hot_mean_io_u_5: 0.0848 - val_loss: 1.6385 - val_accuracy: 0.5442 - val_one_hot_mean_io_u_5: 0.0856\n",
      "Epoch 5/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.3781 - accuracy: 0.6117 - one_hot_mean_io_u_5: 0.0939 - val_loss: 1.5418 - val_accuracy: 0.5587 - val_one_hot_mean_io_u_5: 0.0784\n",
      "Epoch 6/150\n",
      "320/320 [==============================] - 16s 44ms/step - loss: 1.3336 - accuracy: 0.6268 - one_hot_mean_io_u_5: 0.1025 - val_loss: 1.5524 - val_accuracy: 0.5391 - val_one_hot_mean_io_u_5: 0.0860\n",
      "Epoch 7/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.2359 - accuracy: 0.6544 - one_hot_mean_io_u_5: 0.1159 - val_loss: 1.3406 - val_accuracy: 0.6059 - val_one_hot_mean_io_u_5: 0.1095\n",
      "Epoch 8/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.2034 - accuracy: 0.6605 - one_hot_mean_io_u_5: 0.1284 - val_loss: 1.5527 - val_accuracy: 0.5480 - val_one_hot_mean_io_u_5: 0.0804\n",
      "Epoch 9/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.1980 - accuracy: 0.6620 - one_hot_mean_io_u_5: 0.1364 - val_loss: 1.5001 - val_accuracy: 0.5423 - val_one_hot_mean_io_u_5: 0.0916\n",
      "Epoch 10/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.1607 - accuracy: 0.6761 - one_hot_mean_io_u_5: 0.1449 - val_loss: 1.6299 - val_accuracy: 0.5450 - val_one_hot_mean_io_u_5: 0.0870\n",
      "Epoch 11/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.1074 - accuracy: 0.6900 - one_hot_mean_io_u_5: 0.1530 - val_loss: 1.6850 - val_accuracy: 0.5203 - val_one_hot_mean_io_u_5: 0.0996\n",
      "Epoch 12/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.0465 - accuracy: 0.7062 - one_hot_mean_io_u_5: 0.1658 - val_loss: 1.6201 - val_accuracy: 0.5650 - val_one_hot_mean_io_u_5: 0.1175\n",
      "Epoch 13/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.0499 - accuracy: 0.7054 - one_hot_mean_io_u_5: 0.1709 - val_loss: 1.4081 - val_accuracy: 0.5951 - val_one_hot_mean_io_u_5: 0.1245\n",
      "Epoch 14/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 1.0044 - accuracy: 0.7174 - one_hot_mean_io_u_5: 0.1766 - val_loss: 1.4236 - val_accuracy: 0.5998 - val_one_hot_mean_io_u_5: 0.1114\n",
      "Epoch 15/150\n",
      "320/320 [==============================] - 16s 45ms/step - loss: 0.9990 - accuracy: 0.7178 - one_hot_mean_io_u_5: 0.1816 - val_loss: 1.5239 - val_accuracy: 0.5767 - val_one_hot_mean_io_u_5: 0.1064\n"
     ]
    }
   ],
   "source": [
    "history = seg_model.fit(\n",
    "    train_dataset,  epochs=num_epochs,validation_data=val_dataset,\n",
    "    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-15 12:58:06.274846: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8902\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/3 [==============================] - 16s 2s/step - loss: 1.4274 - accuracy: 0.5847 - one_hot_mean_io_u_5: 0.1058\n",
      "test_acc=0.5847129821777344\n",
      "test_iou=0.10575371980667114\n"
     ]
    }
   ],
   "source": [
    "seg_model = keras.models.load_model(os.path.join(model_dir, f\"{model_name}.keras\"), safe_mode=False)\n",
    "_, test_acc, test_iou = seg_model.evaluate(test_dataset)\n",
    "\n",
    "print(f\"{test_acc=}\")\n",
    "print(f\"{test_iou=}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dl",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}