Final_Project/Final_Project_Loedige.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intelligent World Informatics LectureV: Assignment Week 12\n",
    "- Author: Paul Lödige (ploedige@g.ecc.u-tokyo.ac.jp)\n",
    "- Student ID: 37-229753"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment\n",
    "- Define your own project\n",
    "  - Describe the task and the goal you would like to achieve\n",
    "  - Experiment on any public dataset provided by Tensorflow:\n",
    "    - Full list: https://www.tensorflow.org/datasets/catalog/overview\n",
    "    - Simple datasets: https://www.tensorflow.org/api_docs/python/tf/keras/datasets\n",
    "  - Do one of the followings:\n",
    "    1. Apply two different deep learning techniques you learned from this class\n",
    "       - e.g.: Comparing Dense DNN vs RNN method on the same dataset (what pros and cons?)\n",
    "       - e.g.: Combining CNN and RNN on a dataset (why the combination is preferable?)\n",
    "    2. Apply transfer learning with two different base models\n",
    "       - Explain the reasons why the base models are reasonable choices.\n",
    "       - Survey on the internet with keywords such as “best model for imagenet/cifar10/mnist”, “tensorflow pre-trained models”, etc, to find the name of the model\n",
    "       - Download the base model through tensorflow\n",
    "         - Just like in the code, simply change the name of the base model. List of available base models in Tensorflow:\n",
    "           - https://www.tensorflow.org/api_docs/python/tf/keras/applications\n",
    "         - Add layers, dropouts, use different learning rate, epoch, batch_size, etc.\n",
    "\n",
    "### Additional Details\n",
    "- Write 1 ~ 2 page(s) (excluding the code) describing your project:\n",
    "  - Imagine the project as a kind of “mini research paper”\n",
    "  - What is the problem? What is your motivation?\n",
    "  - How are you solving them? What deep learning algorithms?\n",
    "  - Outline the experiment and test on the dataset.\n",
    "  - What are the results?\n",
    "    - Add at least 1 figure and insert your analysis\n",
    "  - Attach the code at the end.\n",
    "  - Include your name, affiliation, student number, as well as your university e-mail address in case if we need to contact you for clarification\n",
    "  - Put all the above in a single PDF and upload to ITC-LMS\n",
    "\n",
    "### How the project is graded\n",
    "- The purpose of the project is to make you familiar with machine learning experiments.\n",
    "  - Not intended to be a stressful project.\n",
    "    - So do not worry too much on achieving high accuracy, good parameter settings, etc\n",
    "    - Make sure to keep it simple\n",
    "- What we would like to see:\n",
    "  - Clarity of the project description\n",
    "  - Relevance between the problem and the chosen approaches\n",
    "  - Appropriate input/output design and execution of the experiments\n",
    "  - Proper evaluation methods, figures and tables\n",
    "  - Easy to understand writings, informative comments on the code\n",
    "- Overall grade for this course : 70% homeworks, 30% final project\n",
    "  - Bonus points for helping each other on slack\n",
    "    - Feel free to discuss your final project on slack if you have troubles"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code\n",
    "### Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-03 13:55:00.456857: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-02-03 13:55:00.602905: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2023-02-03 13:55:00.602949: I tensorflow/compiler/xla/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n",
      "2023-02-03 13:55:01.295401: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
      "2023-02-03 13:55:01.295490: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
      "2023-02-03 13:55:01.295499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n",
      "/home/paul/.local/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers, models, applications, optimizers\n",
    "import tensorflow_datasets as tfds\n",
    "import tkinter.messagebox # for notifications"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load Dataset\n",
    "https://www.tensorflow.org/datasets/keras_example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-03 13:55:02.605437: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
      "2023-02-03 13:55:02.605483: W tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:265] failed call to cuInit: UNKNOWN ERROR (303)\n",
      "2023-02-03 13:55:02.605508: I tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (paul-laptop): /proc/driver/nvidia/version does not exist\n",
      "2023-02-03 13:55:02.605775: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# split into training and test data\n",
    "ds_train, ds_test = tfds.load(\n",
    "    'svhn_cropped', \n",
    "    split=['train', 'test'],\n",
    "    shuffle_files=True, \n",
    "    as_supervised=True\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confirm Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for image, label in ds_train.take(1):\n",
    "    plt.imshow(image)\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define normalization function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_img(image, label):\n",
    "    return tf.cast(image, tf.float32) / 255.0, label"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build a training pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_train = ds_train.map(normalize_img, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "ds_train = ds_train.cache()\n",
    "ds_train = ds_train.batch(128)\n",
    "ds_train = ds_train.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build an evaluation pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_test = ds_test.map(normalize_img, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "ds_test = ds_test.cache()\n",
    "ds_test = ds_test.batch(128)\n",
    "ds_test = ds_test.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configurations\n",
    "The following is a list of the neural network configurations that will be compared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs['regular Neural Network (3 hidden layers)'] = {\n",
    "        'model': models.Sequential([\n",
    "            layers.Flatten(input_shape=(32, 32, 3)),\n",
    "            layers.Dense(256, activation='relu'),\n",
    "            layers.Dense(128, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax')\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 10,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs['regular Neural Network (5 hidden layers)'] = {\n",
    "        'model': models.Sequential([\n",
    "            layers.Flatten(input_shape=(32, 32, 3)),\n",
    "            layers.Dense(1024, activation='relu'),\n",
    "            layers.Dense(512, activation='relu'),\n",
    "            layers.Dense(256, activation='relu'),\n",
    "            layers.Dense(128, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax')\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 10,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs['regular Neural Network (10 hidden layers)'] = {\n",
    "        'model': models.Sequential([\n",
    "            layers.Flatten(input_shape=(32, 32, 3)),\n",
    "            layers.Dense(1024, activation='relu'),\n",
    "            layers.Dense(1024, activation='relu'),\n",
    "            layers.Dense(512, activation='relu'),\n",
    "            layers.Dense(512, activation='relu'),\n",
    "            layers.Dense(256, activation='relu'),\n",
    "            layers.Dense(256, activation='relu'),\n",
    "            layers.Dense(128, activation='relu'),\n",
    "            layers.Dense(128, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax')\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 30,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs['convolutional neural network (1 convolution)'] = {\n",
    "        'model': models.Sequential([\n",
    "            layers.Conv2D(32, (3,3), activation='relu', input_shape=(32,32,3)),\n",
    "            layers.MaxPooling2D((2,2)),\n",
    "            layers.Flatten(),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax')\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 10,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs['convolutional neural network (3 convolutions)'] = {\n",
    "        'model': models.Sequential([\n",
    "            layers.Conv2D(32, (3,3), activation='relu', input_shape=(32,32,3)),\n",
    "            layers.MaxPooling2D((2,2)),\n",
    "            layers.Conv2D(64, (3,3), activation='relu'),\n",
    "            layers.MaxPooling2D((2,2)),\n",
    "            layers.Conv2D(128, (3,3), activation='relu'),\n",
    "            layers.MaxPooling2D((2,2)),\n",
    "            layers.Flatten(),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax')\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 10,\n",
    "        'batch_size': 128\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "vgg16_base_model = applications.VGG16(input_shape=(32,32,3), include_top= False)\n",
    "# freeze the VGG16 model\n",
    "vgg16_base_model.trainable = False\n",
    "\n",
    "configs['frozen VGG16 base model'] = {\n",
    "        'model': models.Sequential([\n",
    "            vgg16_base_model,\n",
    "            layers.Flatten(),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(32, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax'),\n",
    "        ]),\n",
    "        'optimizer': 'adam',\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 5,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "vgg16_base_model = applications.VGG16(input_shape=(32,32,3), include_top= False)\n",
    "\n",
    "configs['fully trainable VGG16 base model'] = {\n",
    "        'model': models.Sequential([\n",
    "            vgg16_base_model,\n",
    "            layers.Flatten(),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(32, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax'),\n",
    "        ]),\n",
    "        'optimizer': optimizers.Adam(learning_rate=0.001),\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 5,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "vgg16_base_model = applications.VGG16(input_shape=(32,32,3), include_top= False)\n",
    "# freeze the VGG16 model\n",
    "vgg16_base_model.trainable = False\n",
    "for layer in vgg16_base_model.layers[-6:]:\n",
    "    layer.trainable=True\n",
    "\n",
    "configs['partly trainable VGG16 base model'] = {\n",
    "        'model': models.Sequential([\n",
    "            vgg16_base_model,\n",
    "            layers.Flatten(),\n",
    "            layers.Dense(64, activation='relu'),\n",
    "            layers.Dense(32, activation='relu'),\n",
    "            layers.Dense(10, activation='softmax'),\n",
    "        ]),\n",
    "        'optimizer': optimizers.Adam(learning_rate=0.001),\n",
    "        'loss': 'sparse_categorical_crossentropy',\n",
    "        'metrics': ['accuracy'],\n",
    "        'epochs': 5,\n",
    "        'batch_size': 64\n",
    "    }"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compile the Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "for config in configs.values():\n",
    "    if 'history' not in config.keys():\n",
    "        config['model'].compile(\n",
    "            optimizer=config['optimizer'],\n",
    "            loss=config['loss'],\n",
    "            metrics=config['metrics']\n",
    "        )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and Evaluate the Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Already trained model \"regular Neural Network (3 hidden layers)\"\n",
      "Now training model \"regular Neural Network (5 hidden layers)\"\n",
      "Epoch 1/10\n",
      "573/573 [==============================] - 36s 63ms/step - loss: 2.2150 - accuracy: 0.1990 - val_loss: 2.0656 - val_accuracy: 0.2634\n",
      "Epoch 2/10\n",
      "573/573 [==============================] - 32s 57ms/step - loss: 1.5889 - accuracy: 0.4455 - val_loss: 1.4111 - val_accuracy: 0.5452\n",
      "Epoch 3/10\n",
      "573/573 [==============================] - 30s 52ms/step - loss: 1.2176 - accuracy: 0.6022 - val_loss: 1.1933 - val_accuracy: 0.6230\n",
      "Epoch 4/10\n",
      "573/573 [==============================] - 31s 54ms/step - loss: 1.0577 - accuracy: 0.6612 - val_loss: 1.1168 - val_accuracy: 0.6521\n",
      "Epoch 5/10\n",
      "573/573 [==============================] - 29s 50ms/step - loss: 0.9675 - accuracy: 0.6911 - val_loss: 1.0188 - val_accuracy: 0.6824\n",
      "Epoch 6/10\n",
      "573/573 [==============================] - 32s 56ms/step - loss: 0.8902 - accuracy: 0.7175 - val_loss: 0.9739 - val_accuracy: 0.7005\n",
      "Epoch 7/10\n",
      "573/573 [==============================] - 36s 63ms/step - loss: 0.8418 - accuracy: 0.7324 - val_loss: 0.9489 - val_accuracy: 0.7063\n",
      "Epoch 8/10\n",
      "573/573 [==============================] - 33s 58ms/step - loss: 0.7982 - accuracy: 0.7457 - val_loss: 0.9559 - val_accuracy: 0.7037\n",
      "Epoch 9/10\n",
      "573/573 [==============================] - 36s 63ms/step - loss: 0.7654 - accuracy: 0.7563 - val_loss: 0.9224 - val_accuracy: 0.7180\n",
      "Epoch 10/10\n",
      "573/573 [==============================] - 36s 62ms/step - loss: 0.7403 - accuracy: 0.7640 - val_loss: 0.8736 - val_accuracy: 0.7336\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    for config_name, config in configs.items():\n",
    "        if 'history' in config.keys():\n",
    "            print(f'Already trained model \"{config_name}\"')\n",
    "        else:\n",
    "            print(f'Now training model \"{config_name}\"')\n",
    "            config['history'] = config['model'].fit(ds_train, epochs=config['epochs'], validation_data=ds_test, batch_size=config['batch_size'])#, verbose=0)\n",
    "except Exception as e:\n",
    "    print(e)\n",
    "    tkinter.messagebox.showerror(\"ERROR\", f\"ERROR: {e}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot the accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "for config_name, config in configs.items():\n",
    "    plt.plot(config['history'].history['accuracy'], label=config_name)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "# plt.ylim([0.75, 1])\n",
    "plt.legend(loc='lower right')\n",
    "plt.title(\"Accuracy\")\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "for config_name, config in configs.items():\n",
    "    plt.plot(config['history'].history['val_accuracy'], label=config_name)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "# plt.ylim([0.8, 1])\n",
    "plt.legend(loc='lower right')\n",
    "plt.title(\"Validation Accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notify when done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ok'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tkinter.messagebox.showinfo(\"DONE\", \"DONE\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save data for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keras weights file (<HDF5 file \"variables.h5\" (mode r+)>) saving:\n",
      "...layers\n",
      "......dense\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_1\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_2\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_3\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......flatten\n",
      ".........vars\n",
      "...metrics\n",
      "......mean\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......mean_metric_wrapper\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "...optimizer\n",
      "......vars\n",
      ".........0\n",
      ".........1\n",
      ".........10\n",
      ".........11\n",
      ".........12\n",
      ".........13\n",
      ".........14\n",
      ".........15\n",
      ".........16\n",
      ".........2\n",
      ".........3\n",
      ".........4\n",
      ".........5\n",
      ".........6\n",
      ".........7\n",
      ".........8\n",
      ".........9\n",
      "...vars\n",
      "Keras model archive saving:\n",
      "File Name                                             Modified             Size\n",
      "variables.h5                                   2023-02-03 15:40:22      9972096\n",
      "config.json                                    2023-02-03 15:40:22         2425\n",
      "metadata.json                                  2023-02-03 15:40:22           64\n",
      "Keras weights file (<HDF5 file \"variables.h5\" (mode r+)>) saving:\n",
      "...layers\n",
      "......dense\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_1\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_2\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_3\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_4\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......dense_5\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......flatten\n",
      ".........vars\n",
      "...metrics\n",
      "......mean\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "......mean_metric_wrapper\n",
      ".........vars\n",
      "............0\n",
      "............1\n",
      "...optimizer\n",
      "......vars\n",
      ".........0\n",
      ".........1\n",
      ".........10\n",
      ".........11\n",
      ".........12\n",
      ".........13\n",
      ".........14\n",
      ".........15\n",
      ".........16\n",
      ".........17\n",
      ".........18\n",
      ".........19\n",
      ".........2\n",
      ".........20\n",
      ".........21\n",
      ".........22\n",
      ".........23\n",
      ".........24\n",
      ".........3\n",
      ".........4\n",
      ".........5\n",
      ".........6\n",
      ".........7\n",
      ".........8\n",
      ".........9\n",
      "...vars\n",
      "Keras model archive saving:\n",
      "File Name                                             Modified             Size\n",
      "variables.h5                                   2023-02-03 15:40:22     46173936\n",
      "config.json                                    2023-02-03 15:40:22         3280\n",
      "metadata.json                                  2023-02-03 15:40:22           64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _update_step_xla while saving (showing 1 of 1). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: saved_models/regular Neural Network (3 hidden layers)/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: saved_models/regular Neural Network (3 hidden layers)/assets\n",
      "WARNING:absl:Found untraced functions such as _update_step_xla while saving (showing 1 of 1). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: saved_models/regular Neural Network (5 hidden layers)/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: saved_models/regular Neural Network (5 hidden layers)/assets\n"
     ]
    }
   ],
   "source": [
    "# store histories with pickle\n",
    "import pickle\n",
    "histories = {}\n",
    "for config_name, config in configs.items():\n",
    "    histories[config_name] = config['history']\n",
    "with open('savepoint.pkl', 'wb') as out:\n",
    "    pickle.dump(histories, out)\n",
    "\n",
    "# store models with tensorflow\n",
    "for config_name, config in configs.items():\n",
    "    config['model'].save(f'saved_models/{config_name}')\n",
    "\n",
    "# store models in HDF5 format\n",
    "for config_name, config in configs.items():\n",
    "    config['model'].save(f'hdf5_models/{config_name}.h5')\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test Save File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_11\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " vgg16 (Functional)          (None, 1, 1, 512)         14714688  \n",
      "                                                                 \n",
      " flatten_11 (Flatten)        (None, 512)               0         \n",
      "                                                                 \n",
      " dense_47 (Dense)            (None, 64)                32832     \n",
      "                                                                 \n",
      " dense_48 (Dense)            (None, 32)                2080      \n",
      "                                                                 \n",
      " dense_49 (Dense)            (None, 10)                330       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 14,749,930\n",
      "Trainable params: 14,749,930\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "204/204 [==============================] - 54s 263ms/step - loss: 0.2786 - accuracy: 0.9249\n",
      "Restored model, accuracy: 92.49%\n"
     ]
    }
   ],
   "source": [
    "new_model = tf.keras.models.load_model('hdf5_models/fully trainable VGG16 base model.h5')\n",
    "print(new_model.summary())\n",
    "\n",
    "# Evaluate the restored model\n",
    "loss, acc = new_model.evaluate(ds_test)\n",
    "print('Restored model, accuracy: {:5.2f}%'.format(100 * acc))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}