Ex6.SampleSolution-DomainAdaptionAutoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c8d5a65",
   "metadata": {},
   "source": [
    "<img src=\"https://www.th-koeln.de/img/logo.svg\" style=\"float:right;\" width=\"200\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aa99fd9",
   "metadata": {},
   "source": [
    "# Musterlösung / Sample solution \n",
    "## 6th exercise: <font color=\"#C70039\">Domain Adaption with Autoencoders</font>\n",
    "* Course: AML\n",
    "* Lecturer: <a href=\"https://www.gernotheisenberg.de/\">Gernot Heisenberg</a>\n",
    "* Author of notebook: <a href=\"https://www.gernotheisenberg.de/\">Gernot Heisenberg</a>\n",
    "* Date:   04.09.2024\n",
    "\n",
    "---------------------------------\n",
    "\n",
    "### Description \n",
    "This is one implementation example to demo the image reconstruction using autoencoders for domain adaption. \n",
    "Please do not miss to try different optimizers and losses.\n",
    "\n",
    "---------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a50f3435",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import cv2\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, UpSampling2D\n",
    "from tensorflow.keras.models import Sequential\n",
    "import os\n",
    "from   tqdm import tqdm\n",
    "import time\n",
    "\n",
    "SIZE=256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df24b693",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# import input img\n",
    "input_img_data=[]\n",
    "input_path = './data/heisenberg_heisenberg/gernot/'\n",
    "files=os.listdir(input_path)\n",
    "# read all images in the folder (different rotations and flips of the original)\n",
    "for i in tqdm(files):\n",
    "    img=cv2.imread(input_path+'/'+i,1)   #Change 0 to 1 for color images\n",
    "    img=cv2.resize(img,(SIZE, SIZE))\n",
    "    input_img_data.append(img_to_array(img))\n",
    "# -----------------------------------------  \n",
    "# import output_img\n",
    "output_img_data=[]\n",
    "output_path = './data/heisenberg_heisenberg/walter/'\n",
    "files=os.listdir(output_path)\n",
    "# read all images in the folder (same rotations and flips as img)\n",
    "for i in tqdm(files):\n",
    "    img=cv2.imread(output_path+'/'+i,1)  #Change 0 to 1 for color images\n",
    "    img=cv2.resize(img,(SIZE, SIZE))\n",
    "    output_img_data.append(img_to_array(img))\n",
    "\n",
    "input_img_array = np.reshape(input_img_data, (len(input_img_data), SIZE, SIZE, 3))\n",
    "input_img_array = input_img_array.astype('float32') / 255. # normalize\n",
    "output_img_array= np.reshape(output_img_data, (len(output_img_data), SIZE, SIZE, 3))\n",
    "output_img_array = output_img_array.astype('float32') / 255. # normalize\n",
    "\n",
    "# Original image for prediction of output_img \n",
    "# this one does not belong to the training set\n",
    "test_img_data=[]\n",
    "\n",
    "test_img=cv2.imread('./data/heisenberg_heisenberg/gernot-heisenberg-original.jpg', 1)   #Change 0 to 1 for color images\n",
    "test_img = cv2.cvtColor(test_img, cv2.COLOR_BGR2RGB)#Changing BGR to RGB to show images in true colors\n",
    "test_img=cv2.resize(test_img,(SIZE, SIZE))\n",
    "test_img_data.append(img_to_array(test_img))\n",
    "\n",
    "test_img_array = np.reshape(test_img_data, (len(test_img_data), SIZE, SIZE, 3))\n",
    "test_img_array = test_img_array.astype('float32') / 255. # normalize\n",
    "\n",
    "# set the start time\n",
    "# later needed for calculating the computation time\n",
    "start=time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20dd69aa",
   "metadata": {},
   "source": [
    "## Build the autoencoder-decoder model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51eb5824-ee07-40f8-b29c-d273e124acfd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(SIZE, SIZE, 3)))\n",
    "model.add(MaxPooling2D((2, 2), padding='same'))\n",
    "model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))\n",
    "model.add(MaxPooling2D((2, 2), padding='same'))\n",
    "model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))\n",
    "model.add(MaxPooling2D((2, 2), padding='same'))\n",
    "     \n",
    "model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))\n",
    "model.add(UpSampling2D((2, 2)))\n",
    "model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))\n",
    "model.add(UpSampling2D((2, 2)))\n",
    "model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))\n",
    "model.add(UpSampling2D((2, 2)))\n",
    "model.add(Conv2D(3, (3, 3), activation='relu', padding='same'))\n",
    "\n",
    "model.compile(optimizer='adam', loss='mean_squared_error', metrics=['accuracy'])\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ae50643",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#callbacks = [tf.keras.callbacks.TensorBoard(log_dir='einstein_logs')]\n",
    "\n",
    "# fit the model of input_img to output_img \n",
    "epochs = 50\n",
    "model.fit(input_img_array, output_img_array, epochs=epochs, shuffle=True)#, callbacks=callbacks)\n",
    "\n",
    "# print out the computation time\n",
    "finish=time.time()\n",
    "print('total computation time = ', finish-start)\n",
    "\n",
    "# save the model\n",
    "model.save(\"domain_adapt_autoenc_epochs.\" + str(epochs) + \".keras\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df2d2f78",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# predict the original image as test image, \n",
    "# since it did not belong to the training data.\n",
    "# if the domain was really adapted, then the result would look like output_img\n",
    "print(\"output of test image\")\n",
    "\n",
    "model = tf.keras.models.load_model(\"domain_adapt_autoenc_epochs.50.keras\")\n",
    "pred = model.predict(test_img_array)\n",
    "plt.imshow(pred[0].reshape(SIZE,SIZE,3))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "826bb252",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}